@jbroll/jscad-modeling 2.12.7 → 2.13.0

package/bench/booleans.bench.js

@@ -0,0 +1,103 @@
+/**
+ * Benchmarks for boolean operations
+ *
+ * Run with: node bench/booleans.bench.js
+ */
+
+const { cube, cuboid, sphere, cylinder, torus } = require('../src/primitives')
+const { union, subtract, intersect } = require('../src/operations/booleans')
+const { translate } = require('../src/operations/transforms')
+
+// Simple benchmark runner
+const benchmark = (name, fn, iterations = 10) => {
+  // Warmup
+  for (let i = 0; i < 2; i++) fn()
+
+  const start = process.hrtime.bigint()
+  for (let i = 0; i < iterations; i++) {
+    fn()
+  }
+  const end = process.hrtime.bigint()
+  const totalMs = Number(end - start) / 1e6
+  const avgMs = totalMs / iterations
+
+  console.log(`${name.padEnd(50)} ${avgMs.toFixed(1).padStart(10)} ms/op  (${iterations} iterations)`)
+  return avgMs
+}
+
+console.log('='.repeat(80))
+console.log('Boolean Operation Benchmarks')
+console.log('='.repeat(80))
+console.log()
+
+// Prepare test geometries
+const smallCube = cube({ size: 10 })
+const smallCubeOffset = translate([5, 0, 0], cube({ size: 10 }))
+const medCube = cube({ size: 20 })
+const medCubeOffset = translate([10, 0, 0], cube({ size: 20 }))
+
+const smallSphere = sphere({ radius: 5, segments: 16 })
+const smallSphereOffset = translate([3, 0, 0], sphere({ radius: 5, segments: 16 }))
+const medSphere = sphere({ radius: 5, segments: 32 })
+const medSphereOffset = translate([3, 0, 0], sphere({ radius: 5, segments: 32 }))
+
+const smallCyl = cylinder({ radius: 5, height: 10, segments: 16 })
+const smallCylOffset = translate([3, 0, 0], cylinder({ radius: 5, height: 10, segments: 16 }))
+const medCyl = cylinder({ radius: 5, height: 10, segments: 32 })
+const medCylOffset = translate([3, 0, 0], cylinder({ radius: 5, height: 10, segments: 32 }))
+
+const smallTorus = torus({ innerRadius: 1, outerRadius: 4, innerSegments: 16, outerSegments: 16 })
+const smallTorusOffset = translate([2, 0, 0], torus({ innerRadius: 1, outerRadius: 4, innerSegments: 16, outerSegments: 16 }))
+const medTorus = torus({ innerRadius: 1, outerRadius: 4, innerSegments: 32, outerSegments: 32 })
+const medTorusOffset = translate([2, 0, 0], torus({ innerRadius: 1, outerRadius: 4, innerSegments: 32, outerSegments: 32 }))
+
+console.log('--- Union Operations ---')
+benchmark('union: cube + cube', () => union(smallCube, smallCubeOffset), 50)
+benchmark('union: sphere(16) + sphere(16)', () => union(smallSphere, smallSphereOffset), 20)
+benchmark('union: sphere(32) + sphere(32)', () => union(medSphere, medSphereOffset), 10)
+benchmark('union: cylinder(16) + cylinder(16)', () => union(smallCyl, smallCylOffset), 20)
+benchmark('union: cylinder(32) + cylinder(32)', () => union(medCyl, medCylOffset), 10)
+benchmark('union: torus(16) + torus(16)', () => union(smallTorus, smallTorusOffset), 5)
+benchmark('union: torus(32) + torus(32)', () => union(medTorus, medTorusOffset), 3)
+console.log()
+
+console.log('--- Subtract Operations ---')
+benchmark('subtract: cube - cube', () => subtract(smallCube, smallCubeOffset), 50)
+benchmark('subtract: sphere(16) - sphere(16)', () => subtract(smallSphere, smallSphereOffset), 20)
+benchmark('subtract: sphere(32) - sphere(32)', () => subtract(medSphere, medSphereOffset), 10)
+benchmark('subtract: cylinder(16) - cylinder(16)', () => subtract(smallCyl, smallCylOffset), 20)
+benchmark('subtract: cylinder(32) - cylinder(32)', () => subtract(medCyl, medCylOffset), 10)
+benchmark('subtract: torus(16) - torus(16)', () => subtract(smallTorus, smallTorusOffset), 5)
+benchmark('subtract: torus(32) - torus(32)', () => subtract(medTorus, medTorusOffset), 3)
+console.log()
+
+console.log('--- Intersect Operations ---')
+benchmark('intersect: cube & cube', () => intersect(smallCube, smallCubeOffset), 50)
+benchmark('intersect: sphere(16) & sphere(16)', () => intersect(smallSphere, smallSphereOffset), 20)
+benchmark('intersect: sphere(32) & sphere(32)', () => intersect(medSphere, medSphereOffset), 10)
+benchmark('intersect: cylinder(16) & cylinder(16)', () => intersect(smallCyl, smallCylOffset), 20)
+benchmark('intersect: cylinder(32) & cylinder(32)', () => intersect(medCyl, medCylOffset), 10)
+benchmark('intersect: torus(16) & torus(16)', () => intersect(smallTorus, smallTorusOffset), 5)
+benchmark('intersect: torus(32) & torus(32)', () => intersect(medTorus, medTorusOffset), 3)
+console.log()
+
+// Multiple operations (chain)
+console.log('--- Chained Operations ---')
+const cube1 = cube({ size: 10 })
+const cube2 = translate([5, 0, 0], cube({ size: 10 }))
+const cube3 = translate([0, 5, 0], cube({ size: 10 }))
+const cube4 = translate([0, 0, 5], cube({ size: 10 }))
+
+benchmark('union: 4 cubes', () => union(cube1, cube2, cube3, cube4), 20)
+benchmark('subtract: cube - 3 cubes', () => subtract(cube1, cube2, cube3, cube4), 20)
+console.log()
+
+// Non-overlapping (fast path)
+console.log('--- Non-overlapping (fast path) ---')
+const farCube1 = cube({ size: 5 })
+const farCube2 = translate([20, 0, 0], cube({ size: 5 }))
+benchmark('union: non-overlapping cubes', () => union(farCube1, farCube2), 100)
+console.log()
+
+console.log('='.repeat(80))
+console.log('Benchmark complete')

package/bench/primitives.bench.js

@@ -0,0 +1,108 @@
+/**
+ * Benchmarks for primitive shapes
+ *
+ * Run with: node bench/primitives.bench.js
+ */
+
+const {
+  cube, cuboid, roundedCuboid,
+  sphere, geodesicSphere, ellipsoid,
+  cylinder, roundedCylinder, cylinderElliptic,
+  torus,
+  polyhedron
+} = require('../src/primitives')
+
+// Simple benchmark runner
+const benchmark = (name, fn, iterations = 100) => {
+  // Warmup
+  for (let i = 0; i < 10; i++) fn()
+
+  const start = process.hrtime.bigint()
+  for (let i = 0; i < iterations; i++) {
+    fn()
+  }
+  const end = process.hrtime.bigint()
+  const totalMs = Number(end - start) / 1e6
+  const avgMs = totalMs / iterations
+
+  console.log(`${name.padEnd(40)} ${avgMs.toFixed(3).padStart(10)} ms/op  (${iterations} iterations, ${totalMs.toFixed(1)} ms total)`)
+  return avgMs
+}
+
+console.log('='.repeat(80))
+console.log('Primitive Shape Benchmarks')
+console.log('='.repeat(80))
+console.log()
+
+// Box primitives
+console.log('--- Box Primitives ---')
+benchmark('cube (default)', () => cube())
+benchmark('cube (size: 10)', () => cube({ size: 10 }))
+benchmark('cuboid (default)', () => cuboid())
+benchmark('cuboid (size: [10, 20, 30])', () => cuboid({ size: [10, 20, 30] }))
+benchmark('roundedCuboid (default)', () => roundedCuboid())
+benchmark('roundedCuboid (roundRadius: 2)', () => roundedCuboid({ size: [10, 10, 10], roundRadius: 2 }))
+benchmark('roundedCuboid (segments: 32)', () => roundedCuboid({ size: [10, 10, 10], roundRadius: 2, segments: 32 }))
+console.log()
+
+// Sphere primitives
+console.log('--- Sphere Primitives ---')
+benchmark('sphere (default, 32 seg)', () => sphere())
+benchmark('sphere (segments: 16)', () => sphere({ segments: 16 }))
+benchmark('sphere (segments: 64)', () => sphere({ segments: 64 }), 50)
+benchmark('sphere (segments: 128)', () => sphere({ segments: 128 }), 20)
+benchmark('geodesicSphere (default)', () => geodesicSphere())
+benchmark('geodesicSphere (frequency: 6)', () => geodesicSphere({ frequency: 6 }))
+benchmark('geodesicSphere (frequency: 12)', () => geodesicSphere({ frequency: 12 }), 20)
+benchmark('ellipsoid (default)', () => ellipsoid())
+benchmark('ellipsoid (segments: 64)', () => ellipsoid({ segments: 64 }), 50)
+console.log()
+
+// Cylinder primitives
+console.log('--- Cylinder Primitives ---')
+benchmark('cylinder (default)', () => cylinder())
+benchmark('cylinder (segments: 16)', () => cylinder({ segments: 16 }))
+benchmark('cylinder (segments: 64)', () => cylinder({ segments: 64 }))
+benchmark('cylinder (segments: 128)', () => cylinder({ segments: 128 }), 50)
+benchmark('roundedCylinder (default)', () => roundedCylinder())
+benchmark('roundedCylinder (segments: 64)', () => roundedCylinder({ segments: 64 }), 50)
+benchmark('cylinderElliptic (default)', () => cylinderElliptic())
+benchmark('cylinderElliptic (segments: 64)', () => cylinderElliptic({ segments: 64 }), 50)
+console.log()
+
+// Torus primitives (uses extrudeRotate internally)
+console.log('--- Torus Primitives ---')
+benchmark('torus (default 32x32)', () => torus())
+benchmark('torus (16x16)', () => torus({ innerSegments: 16, outerSegments: 16 }))
+benchmark('torus (32x32)', () => torus({ innerSegments: 32, outerSegments: 32 }))
+benchmark('torus (48x48)', () => torus({ innerSegments: 48, outerSegments: 48 }), 50)
+benchmark('torus (64x64)', () => torus({ innerSegments: 64, outerSegments: 64 }), 20)
+benchmark('torus (partial, 180deg)', () => torus({ outerRotation: Math.PI }))
+benchmark('torus (partial, 90deg)', () => torus({ outerRotation: Math.PI / 2 }))
+console.log()
+
+// Polyhedron
+console.log('--- Polyhedron Primitives ---')
+// Tetrahedron
+const tetraPoints = [[1, 1, 1], [-1, -1, 1], [-1, 1, -1], [1, -1, -1]]
+const tetraFaces = [[0, 1, 2], [0, 3, 1], [0, 2, 3], [1, 3, 2]]
+benchmark('polyhedron (tetrahedron)', () => polyhedron({ points: tetraPoints, faces: tetraFaces }))
+
+// Larger polyhedron (icosahedron-like)
+const phi = (1 + Math.sqrt(5)) / 2
+const icoPoints = [
+  [-1, phi, 0], [1, phi, 0], [-1, -phi, 0], [1, -phi, 0],
+  [0, -1, phi], [0, 1, phi], [0, -1, -phi], [0, 1, -phi],
+  [phi, 0, -1], [phi, 0, 1], [-phi, 0, -1], [-phi, 0, 1]
+]
+const icoFaces = [
+  [0, 11, 5], [0, 5, 1], [0, 1, 7], [0, 7, 10], [0, 10, 11],
+  [1, 5, 9], [5, 11, 4], [11, 10, 2], [10, 7, 6], [7, 1, 8],
+  [3, 9, 4], [3, 4, 2], [3, 2, 6], [3, 6, 8], [3, 8, 9],
+  [4, 9, 5], [2, 4, 11], [6, 2, 10], [8, 6, 7], [9, 8, 1]
+]
+benchmark('polyhedron (icosahedron)', () => polyhedron({ points: icoPoints, faces: icoFaces }))
+console.log()
+
+console.log('='.repeat(80))
+console.log('Benchmark complete')

package/bench/splitPolygon.bench.js

@@ -0,0 +1,143 @@
+/**
+ * Direct benchmark for splitPolygonByPlane - the hot path in boolean operations
+ *
+ * Run with: node --expose-gc bench/splitPolygon.bench.js
+ */
+
+const { sphere, torus } = require('../src/primitives')
+const splitPolygonByPlane = require('../src/operations/booleans/trees/splitPolygonByPlane')
+const poly3 = require('../src/geometries/poly3')
+const plane = require('../src/maths/plane')
+
+// Benchmark helper
+const benchmark = (name, setup, fn, iterations = 1000) => {
+  const data = setup()
+
+  // Force GC if available
+  if (global.gc) global.gc()
+
+  // Warmup
+  for (let i = 0; i < 100; i++) fn(data)
+
+  if (global.gc) global.gc()
+  const heapBefore = process.memoryUsage().heapUsed
+
+  const start = process.hrtime.bigint()
+  for (let i = 0; i < iterations; i++) {
+    fn(data)
+  }
+  const end = process.hrtime.bigint()
+
+  if (global.gc) global.gc()
+  const heapAfter = process.memoryUsage().heapUsed
+
+  const totalNs = Number(end - start)
+  const avgNs = totalNs / iterations
+  const avgUs = avgNs / 1000
+  const heapDelta = (heapAfter - heapBefore) / 1024
+
+  console.log(`${name.padEnd(50)} ${avgUs.toFixed(2).padStart(8)} µs/op  heap: ${heapDelta > 0 ? '+' : ''}${heapDelta.toFixed(0)} KB`)
+  return avgUs
+}
+
+console.log('='.repeat(80))
+console.log('splitPolygonByPlane Direct Benchmark')
+console.log('='.repeat(80))
+console.log()
+
+// Get polygons from a sphere
+const testSphere = sphere({ radius: 5, segments: 32 })
+const polygons = testSphere.polygons
+
+console.log(`Test geometry: sphere(32) with ${polygons.length} polygons`)
+console.log(`Average vertices per polygon: ${(polygons.reduce((sum, p) => sum + p.vertices.length, 0) / polygons.length).toFixed(1)}`)
+console.log()
+
+// Test 1: Coplanar case (fast path - type 0 or 1)
+console.log('--- Coplanar Cases (fast path) ---')
+benchmark('coplanar-front (type 0)', () => {
+  const polygon = polygons[0]
+  const pplane = poly3.plane(polygon)
+  return { polygon, splane: pplane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+// Test 2: Entirely front (type 2)
+console.log()
+console.log('--- One-side Cases (no split needed) ---')
+benchmark('entirely front (type 2)', () => {
+  const polygon = polygons[0]
+  // Create a plane far behind the polygon
+  const splane = [0, 0, 1, -100]
+  return { polygon, splane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+benchmark('entirely back (type 3)', () => {
+  const polygon = polygons[0]
+  // Create a plane far in front of the polygon
+  const splane = [0, 0, 1, 100]
+  return { polygon, splane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+// Test 3: Spanning case (type 4) - this is where allocations hurt
+console.log()
+console.log('--- Spanning Cases (allocations happen here) ---')
+benchmark('spanning split (type 4) - triangle', () => {
+  // A triangle that will be split
+  const polygon = poly3.create([[0, 0, 0], [10, 0, 0], [5, 10, 0]])
+  const splane = [1, 0, 0, 5] // Split down the middle
+  return { polygon, splane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+benchmark('spanning split (type 4) - quad', () => {
+  const polygon = poly3.create([[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 10, 0]])
+  const splane = [1, 0, 0, 5]
+  return { polygon, splane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+benchmark('spanning split (type 4) - hexagon', () => {
+  const polygon = poly3.create([
+    [0, 0, 0], [5, 0, 0], [7.5, 4, 0],
+    [5, 8, 0], [0, 8, 0], [-2.5, 4, 0]
+  ])
+  const splane = [1, 0, 0, 2.5]
+  return { polygon, splane }
+}, (data) => splitPolygonByPlane(data.splane, data.polygon), 10000)
+
+// Test 4: Realistic mix from actual boolean operation
+console.log()
+console.log('--- Realistic Mix (simulating boolean op) ---')
+benchmark('mixed types from sphere polygons', () => {
+  // Use multiple polygons with a plane that hits various cases
+  const splane = [0.577, 0.577, 0.577, 0] // Diagonal plane through origin
+  return { polygons: polygons.slice(0, 50), splane }
+}, (data) => {
+  let spanning = 0
+  for (const polygon of data.polygons) {
+    const result = splitPolygonByPlane(data.splane, polygon)
+    if (result.type === 4) spanning++
+  }
+  return spanning
+}, 1000)
+
+// Measure allocation overhead specifically
+console.log()
+console.log('--- Allocation Stress Test ---')
+benchmark('10k spanning splits (allocation heavy)', () => {
+  const polygon = poly3.create([[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 10, 0]])
+  const splane = [1, 0, 0, 5]
+  return { polygon, splane }
+}, (data) => {
+  for (let i = 0; i < 100; i++) {
+    splitPolygonByPlane(data.splane, data.polygon)
+  }
+}, 100)
+
+console.log()
+console.log('='.repeat(80))
+console.log('Benchmark complete')
+console.log()
+console.log('Note: "spanning split" cases allocate the most:')
+console.log('  - result object { type, front, back }')
+console.log('  - vertexIsBack[] array')
+console.log('  - frontvertices[] and backvertices[] arrays')
+console.log('  - Two new poly3 objects (front and back)')