@jscad/modeling 3.0.3-alpha.0 → 3.0.4-alpha.0

package/src/operations/booleans/trees/splitPolygonByPlane.test.js

@@ -0,0 +1,138 @@
+import test from 'ava'
+
+import { poly3 } from '../../../geometries/index.js'
+import { plane } from '../../../maths/index.js'
+
+import { splitPolygonByPlane } from './splitPolygonByPlane.js'
+
+test('splitPolygonByPlane: test coplanar-front polygon returns type 0.', (t) => {
+  // Polygon in XY plane at z=0
+  const polygon = poly3.create([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]])
+  // Plane is also XY plane at z=0, normal pointing up
+  const splane = plane.fromPoints(plane.create(), [0, 0, 0], [1, 0, 0], [1, 1, 0])
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 0) // coplanar-front
+  t.is(result.front, undefined)
+  t.is(result.back, undefined)
+})
+
+test('splitPolygonByPlane: test polygon entirely in front returns type 2.', (t) => {
+  // Polygon at z=5
+  const polygon = poly3.create([[0, 0, 5], [1, 0, 5], [1, 1, 5], [0, 1, 5]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0] // normal (0,0,1), w=0
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 2) // front
+  t.is(result.front, undefined)
+  t.is(result.back, undefined)
+})
+
+test('splitPolygonByPlane: test polygon entirely in back returns type 3.', (t) => {
+  // Polygon at z=-5
+  const polygon = poly3.create([[0, 0, -5], [1, 0, -5], [1, 1, -5], [0, 1, -5]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0] // normal (0,0,1), w=0
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 3) // back
+  t.is(result.front, undefined)
+  t.is(result.back, undefined)
+})
+
+test('splitPolygonByPlane: test spanning polygon returns type 4 with front and back.', (t) => {
+  // Polygon spanning z=0 plane (from z=-1 to z=1)
+  const polygon = poly3.create([[0, 0, -1], [1, 0, -1], [1, 0, 1], [0, 0, 1]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0] // normal (0,0,1), w=0
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 4) // spanning
+  t.not(result.front, undefined)
+  t.not(result.back, undefined)
+
+  // Front polygon should have z >= 0
+  const frontPoints = poly3.toVertices(result.front)
+  t.true(frontPoints.length >= 3)
+  frontPoints.forEach((p) => {
+    t.true(p[2] >= -1e-5, `front point z=${p[2]} should be >= 0`)
+  })
+
+  // Back polygon should have z <= 0
+  const backPoints = poly3.toVertices(result.back)
+  t.true(backPoints.length >= 3)
+  backPoints.forEach((p) => {
+    t.true(p[2] <= 1e-5, `back point z=${p[2]} should be <= 0`)
+  })
+})
+
+test('splitPolygonByPlane: test duplicate vertices are removed from split result.', (t) => {
+  // Create a polygon that when split would produce duplicate vertices
+  // Triangle with one vertex on the plane
+  const polygon = poly3.create([[0, 0, 0], [1, 0, 1], [1, 0, -1]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0]
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 4) // spanning
+
+  // Verify no consecutive duplicate vertices in front
+  if (result.front) {
+    const frontPoints = poly3.toVertices(result.front)
+    for (let i = 0; i < frontPoints.length; i++) {
+      const curr = frontPoints[i]
+      const next = frontPoints[(i + 1) % frontPoints.length]
+      const dx = curr[0] - next[0]
+      const dy = curr[1] - next[1]
+      const dz = curr[2] - next[2]
+      const distSq = dx * dx + dy * dy + dz * dz
+      t.true(distSq > 1e-10, 'front polygon should not have duplicate consecutive vertices')
+    }
+  }
+
+  // Verify no consecutive duplicate vertices in back
+  if (result.back) {
+    const backPoints = poly3.toVertices(result.back)
+    for (let i = 0; i < backPoints.length; i++) {
+      const curr = backPoints[i]
+      const next = backPoints[(i + 1) % backPoints.length]
+      const dx = curr[0] - next[0]
+      const dy = curr[1] - next[1]
+      const dz = curr[2] - next[2]
+      const distSq = dx * dx + dy * dy + dz * dz
+      t.true(distSq > 1e-10, 'back polygon should not have duplicate consecutive vertices')
+    }
+  }
+})
+
+test('splitPolygonByPlane: test complex spanning polygon splits correctly.', (t) => {
+  // Hexagon spanning the XY plane
+  const polygon = poly3.create([
+    [1, 0, -1],
+    [0.5, 0.866, -1],
+    [-0.5, 0.866, 1],
+    [-1, 0, 1],
+    [-0.5, -0.866, 1],
+    [0.5, -0.866, -1]
+  ])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0]
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 4) // spanning
+  t.not(result.front, undefined)
+  t.not(result.back, undefined)
+
+  // Both resulting polygons should be valid (at least 3 vertices)
+  const frontPoints = poly3.toVertices(result.front)
+  const backPoints = poly3.toVertices(result.back)
+  t.true(frontPoints.length >= 3, 'front polygon should have at least 3 vertices')
+  t.true(backPoints.length >= 3, 'back polygon should have at least 3 vertices')
+})

package/src/operations/booleans/unionGeom3.test.js

@@ -144,3 +144,38 @@ test('union of geom3 with rounding issues #137', (t) => {
   t.is(measureVolume(result), 7779.201144000001)
   t.is(pts.length, 6) // number of polygons in union
 })
+
+// Test for push loop optimization: verify union works correctly with multiple geometries
+// This ensures the concat-to-push-loop optimization handles array merging properly
+test('union of geom3 with multiple overlapping geometries', (t) => {
+  // Create several overlapping cuboids to generate a complex union
+  const geometry1 = cuboid({ size: [10, 10, 10] })
+  const geometry2 = center({ relativeTo: [5, 0, 0] }, cuboid({ size: [10, 10, 10] }))
+  const geometry3 = center({ relativeTo: [0, 5, 0] }, cuboid({ size: [10, 10, 10] }))
+
+  // Union should work correctly with multiple geometries
+  const obs = union(geometry1, geometry2, geometry3)
+  const pts = geom3.toVertices(obs)
+
+  // Skip manifold validation - focus on testing polygon merging works correctly
+  // (CSG on overlapping boxes can produce non-manifold edges at coplanar faces)
+  // Should produce a merged geometry with polygons from all inputs
+  t.true(pts.length > 6) // more than a single cube
+})
+
+// Test for push loop optimization: verify non-overlapping geometries combine correctly
+test('union of multiple non-overlapping geom3 preserves all polygons', (t) => {
+  // Create multiple small cuboids that don't overlap
+  const cubes = []
+  for (let i = 0; i < 10; i++) {
+    cubes.push(center({ relativeTo: [i * 5, 0, 0] }, cuboid({ size: [2, 2, 2] })))
+  }
+
+  // Union all of them
+  const obs = union(...cubes)
+  const pts = geom3.toVertices(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  // Each cuboid has 6 faces, so 10 cuboids = 60 polygons
+  t.is(pts.length, 60)
+})

package/src/operations/extrusions/extrudeFromSlices.js

@@ -59,7 +59,7 @@ export const extrudeFromSlices = (options, base) => {
   let startSlice = null
   let endSlice = null
   let prevSlice = null
-  let polygons = []
+  const polygons = []
   for (let s = 0; s < numberOfSlices; s++) {
     // invoke the callback function to get the next slice
     // NOTE: callback can return null to skip the slice
@@ -71,7 +71,10 @@ export const extrudeFromSlices = (options, base) => {
       if (currentSlice.contours.length === 0) throw new Error('the callback function must return slices with one or more contours')
 
       if (prevSlice) {
-        polygons = polygons.concat(extrudeWalls(prevSlice, currentSlice))
+        const walls = extrudeWalls(prevSlice, currentSlice)
+        for (let i = 0; i < walls.length; i++) {
+          polygons.push(walls[i])
+        }
       }
 
       // save start and end slices for caps if necessary
@@ -85,17 +88,24 @@ export const extrudeFromSlices = (options, base) => {
   if (capEnd) {
     // create a cap at the end
     const endPolygons = slice.toPolygons(endSlice)
-    polygons = polygons.concat(endPolygons)
+    for (let i = 0; i < endPolygons.length; i++) {
+      polygons.push(endPolygons[i])
+    }
   }
   if (capStart) {
     // create a cap at the start
     const startPolygons = slice.toPolygons(startSlice).map(poly3.invert)
-    polygons = polygons.concat(startPolygons)
+    for (let i = 0; i < startPolygons.length; i++) {
+      polygons.push(startPolygons[i])
+    }
   }
   if (!capStart && !capEnd) {
     // create walls between end and start slices
     if (close && !slice.equals(endSlice, startSlice)) {
-      polygons = polygons.concat(extrudeWalls(endSlice, startSlice))
+      const walls = extrudeWalls(endSlice, startSlice)
+      for (let i = 0; i < walls.length; i++) {
+        polygons.push(walls[i])
+      }
     }
   }
   return geom3.create(polygons)

package/src/operations/extrusions/extrudeRotate.js

@@ -110,13 +110,14 @@ export const extrudeRotate = (options, geometry) => {
   baseSlice = slice.reverse(baseSlice)
 
   const matrix = mat4.create()
+  const xRotationMatrix = mat4.fromXRotation(mat4.create(), TAU / 4) // compute once, reuse
   const createSlice = (progress, index, base) => {
     let Zrotation = rotationPerSlice * index + startAngle
     // fix rounding error when rotating TAU radians
     if (totalRotation === TAU && index === segments) {
       Zrotation = startAngle
     }
-    mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromXRotation(mat4.create(), TAU / 4))
+    mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), xRotationMatrix)
 
     return slice.transform(matrix, base)
   }

package/src/operations/extrusions/extrudeRotate.test.js

@@ -194,4 +194,38 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
+// Test for mat4 reuse optimization: verify rotation matrices are computed correctly
+// This ensures the optimization of computing xRotationMatrix once doesn't break anything
+test('extrudeRotate: (mat4 reuse) rotation matrices produce correct geometry', (t) => {
+  // Simple rectangle that will be rotated to form a tube-like shape
+  const geometry2 = geom2.create([[[6, 1], [5, 1], [5, -1], [6, -1]]])
+
+  // Full rotation with many segments to test matrix reuse across iterations
+  const geometry3 = extrudeRotate({ segments: 32 }, geometry2)
+  const pts = geom3.toVertices(geometry3)
+
+  t.notThrows(() => geom3.validate(geometry3))
+  // 32 segments * 8 walls per segment (4 edges * 2 triangles) = 256 polygons
+  t.is(pts.length, 256)
+
+  // Verify the geometry is closed (first and last slices connect properly)
+  // This tests the Zrotation rounding error fix at index === segments
+  const obs = extrudeRotate({ segments: 16 }, geometry2)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 204.69587079560992)
+  t.is(measureVolume(obs), 67.35228409625583)
+})
+
+// Test for mat4 reuse with partial rotation (tests both capped and matrix reuse)
+test('extrudeRotate: (mat4 reuse) partial rotation produces correct caps', (t) => {
+  const geometry2 = geom2.create([[[6, 1], [5, 1], [5, -1], [6, -1]]])
+
+  // Quarter rotation - should have start and end caps
+  const obs = extrudeRotate({ segments: 8, angle: TAU / 4 }, geometry2)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 53.232491234231944)
+  t.is(measureVolume(obs), 15.556349186104049)
+})
+
 // TEST HOLES

package/src/operations/extrusions/extrudeWalls.test.js

@@ -56,3 +56,63 @@ test('extrudeWalls (different shapes)', (t) => {
   walls = extrudeWalls(slice3, slice.transform(matrix, slice2))
   t.is(walls.length, 24)
 })
+
+// Test for vec3 reuse optimization in repartitionEdges
+// When shapes have different edge counts, edges are repartitioned using vec3 operations
+test('extrudeWalls (repartitionEdges vec3 reuse)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 5])
+
+  // Triangle (3 edges)
+  const triangle = slice.create([[
+    [0, 10, 0], [-8.66, -5, 0], [8.66, -5, 0]
+  ]])
+
+  // Hexagon (6 edges) - LCM with triangle is 6, so triangle edges get split
+  const hexagon = slice.create([[
+    [0, 10, 0], [-8.66, 5, 0],
+    [-8.66, -5, 0],
+    [0, -10, 0],
+    [8.66, -5, 0],
+    [8.66, 5, 0]
+  ]])
+
+  // Triangle to hexagon requires repartitioning (3 -> 6 edges)
+  // This exercises the vec3 reuse optimization in repartitionEdges
+  const walls = extrudeWalls(triangle, slice.transform(matrix, hexagon))
+
+  // 6 edges * 2 triangles per edge = 12 wall polygons
+  t.is(walls.length, 12)
+
+  // Verify all walls are valid triangles
+  walls.forEach((wall) => {
+    t.is(wall.vertices.length, 3)
+  })
+})
+
+// Test for vec3 reuse with higher repartition multiple
+test('extrudeWalls (repartitionEdges with high multiple)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 10])
+
+  // Square (4 edges)
+  const square = slice.create([[
+    [-5, 5, 0], [-5, -5, 0], [5, -5, 0], [5, 5, 0]
+  ]])
+
+  // Octagon (8 edges) - LCM with square is 8, so square edges get doubled
+  const octagon = slice.create([[
+    [0, 5, 0],
+    [-3.54, 3.54, 0],
+    [-5, 0, 0],
+    [-3.54, -3.54, 0],
+    [0, -5, 0],
+    [3.54, -3.54, 0],
+    [5, 0, 0],
+    [3.54, 3.54, 0]
+  ]])
+
+  // Square to octagon requires repartitioning (4 -> 8 edges)
+  const walls = extrudeWalls(square, slice.transform(matrix, octagon))
+
+  // 8 edges * 2 triangles per edge = 16 wall polygons
+  t.is(walls.length, 16)
+})

package/src/operations/minkowski/index.d.ts

@@ -0,0 +1 @@
+export { minkowskiSum } from './minkowskiSum'

package/src/operations/minkowski/index.js

@@ -0,0 +1,15 @@
+/**
+ * Minkowski sum operations for 3D geometries.
+ *
+ * The Minkowski sum of two shapes A and B is the set of all points that are
+ * the sum of a point in A and a point in B. This is useful for:
+ * - Offsetting/inflating shapes (using a sphere creates rounded edges)
+ * - Collision detection (shapes collide iff their Minkowski difference contains origin)
+ * - Motion planning and swept volumes
+ *
+ * @module modeling/minkowski
+ * @example
+ * import { minkowskiSum } from '@jscad/modeling'
+ * const rounded = minkowskiSum(cube, sphere)
+ */
+export { minkowskiSum } from './minkowskiSum.js'

package/src/operations/minkowski/minkowskiSum.d.ts

@@ -0,0 +1,4 @@
+import type { Geom3 } from '../../geometries/types'
+
+export function minkowskiSum(geometryA: Geom3, geometryB: Geom3): Geom3
+export function minkowskiSum(...geometries: Geom3[]): Geom3

package/src/operations/minkowski/minkowskiSum.js

@@ -0,0 +1,223 @@
+import { flatten } from '../../utils/flatten.js'
+
+import { geom3, poly3 } from '../../geometries/index.js'
+
+import { hullPoints3 } from '../hulls/hullPoints3.js'
+import { unionGeom3 } from '../booleans/unionGeom3.js'
+
+/**
+ * Compute the Minkowski sum of two 3D geometries.
+ *
+ * The Minkowski sum A ⊕ B is the set of all points a + b where a ∈ A and b ∈ B.
+ * Geometrically, this "inflates" geometry A by the shape of geometry B.
+ *
+ * Common use cases:
+ * - Offset a solid by a sphere to round all edges and corners
+ * - Offset a solid by a cube to create chamfered edges
+ * - Collision detection (if Minkowski sum contains origin, shapes overlap)
+ *
+ * For best performance, use convex geometries. Non-convex geometries are supported
+ * when the second operand is convex, but require decomposition and are slower.
+ *
+ * @param {...Object} geometries - two geom3 geometries (second should be convex for non-convex first)
+ * @returns {geom3} new 3D geometry representing the Minkowski sum
+ * @alias module:modeling/minkowski.minkowskiSum
+ *
+ * @example
+ * const { primitives, minkowski } = require('@jscad/modeling')
+ * const cube = primitives.cuboid({ size: [10, 10, 10] })
+ * const sphere = primitives.sphere({ radius: 2, segments: 16 })
+ * const rounded = minkowski.minkowskiSum(cube, sphere)
+ */
+export const minkowskiSum = (...geometries) => {
+  geometries = flatten(geometries)
+
+  if (geometries.length !== 2) {
+    throw new Error('minkowskiSum requires exactly two geometries')
+  }
+
+  const [geomA, geomB] = geometries
+
+  if (!geom3.isA(geomA) || !geom3.isA(geomB)) {
+    throw new Error('minkowskiSum requires geom3 geometries')
+  }
+
+  const aConvex = geom3.isConvex(geomA)
+  const bConvex = geom3.isConvex(geomB)
+
+  // Fast path: both convex
+  if (aConvex && bConvex) {
+    return minkowskiSumConvex(geomA, geomB)
+  }
+
+  // Non-convex A + convex B: decompose A into tetrahedra
+  if (!aConvex && bConvex) {
+    return minkowskiSumNonConvexConvex(geomA, geomB)
+  }
+
+  // Convex A + non-convex B: swap operands (Minkowski sum is commutative)
+  if (aConvex && !bConvex) {
+    return minkowskiSumNonConvexConvex(geomB, geomA)
+  }
+
+  // Both non-convex: not yet supported
+  throw new Error('minkowskiSum of two non-convex geometries is not yet supported')
+}
+
+/*
+ * Compute Minkowski sum of non-convex A with convex B.
+ *
+ * Decomposes A into tetrahedra, computes Minkowski sum of each with B,
+ * then unions all results.
+ */
+const minkowskiSumNonConvexConvex = (geomA, geomB) => {
+  const tetrahedra = decomposeIntoTetrahedra(geomA)
+
+  if (tetrahedra.length === 0) {
+    return geom3.create()
+  }
+
+  // Compute Minkowski sum for each tetrahedron
+  const parts = tetrahedra.map((tet) => minkowskiSumConvex(tet, geomB))
+
+  // Union all parts using internal unionGeom3
+  if (parts.length === 1) {
+    return parts[0]
+  }
+
+  return unionGeom3(parts)
+}
+
+/*
+ * Decompose a geom3 into tetrahedra using face-local apex points.
+ * Each resulting tetrahedron is guaranteed to be convex.
+ *
+ * Unlike centroid-based decomposition, this approach works correctly for
+ * shapes where the centroid is outside the geometry (e.g., torus, U-shapes).
+ * Each polygon gets its own apex point, offset inward along its normal.
+ */
+const decomposeIntoTetrahedra = (geometry) => {
+  const polygons = geom3.toPolygons(geometry)
+
+  if (polygons.length === 0) {
+    return []
+  }
+
+  const tetrahedra = []
+
+  // For each polygon, compute a face-local apex and create tetrahedra
+  for (let i = 0; i < polygons.length; i++) {
+    const polygon = polygons[i]
+    const vertices = polygon.vertices
+
+    // Compute polygon center
+    let cx = 0
+    let cy = 0
+    let cz = 0
+    for (let k = 0; k < vertices.length; k++) {
+      cx += vertices[k][0]
+      cy += vertices[k][1]
+      cz += vertices[k][2]
+    }
+    cx /= vertices.length
+    cy /= vertices.length
+    cz /= vertices.length
+
+    // Get polygon plane (normal + offset)
+    const plane = poly3.plane(polygon)
+    const nx = plane[0]
+    const ny = plane[1]
+    const nz = plane[2]
+
+    // Offset inward along negative normal to create face-local apex
+    // The normal points outward, so we go in the negative direction
+    // Use a small offset - the actual distance doesn't matter much
+    // as long as the apex is on the interior side of the face
+    const offset = 0.1
+    const apex = [ // Vertex used as apex in tetrahedron polygons below
+      cx - nx * offset,
+      cy - ny * offset,
+      cz - nz * offset
+    ]
+
+    // Fan triangulate the polygon and create tetrahedra from apex
+    for (let j = 1; j < vertices.length - 1; j++) {
+      const v0 = vertices[0]
+      const v1 = vertices[j]
+      const v2 = vertices[j + 1]
+
+      // Create tetrahedron from apex and triangle
+      const tetPolygons = createTetrahedronPolygons(apex, v0, v1, v2)
+      tetrahedra.push(geom3.create(tetPolygons))
+    }
+  }
+
+  return tetrahedra
+}
+
+/*
+ * Create the 4 triangular faces of a tetrahedron.
+ *
+ * Tetrahedron has 4 faces, each a triangle
+ */
+const createTetrahedronPolygons = (p0, p1, p2, p3) => [
+  poly3.create([p0, p2, p1]), // base seen from p3
+  poly3.create([p0, p1, p3]), // face opposite p2
+  poly3.create([p1, p2, p3]), // face opposite p0
+  poly3.create([p2, p0, p3]) // face opposite p1
+]
+
+/*
+ * Compute Minkowski sum of two convex polyhedra.
+ *
+ * For convex polyhedra, the Minkowski sum equals the convex hull of
+ * all pairwise vertex sums. This is O(n*m) for n and m vertices,
+ * plus the cost of the convex hull algorithm.
+ */
+const minkowskiSumConvex = (geomA, geomB) => {
+  const pointsA = extractUniqueVertices(geomA)
+  const pointsB = extractUniqueVertices(geomB)
+
+  if (pointsA.length === 0 || pointsB.length === 0) {
+    return geom3.create()
+  }
+
+  // Compute all pairwise sums
+  const summedPoints = []
+  for (let i = 0; i < pointsA.length; i++) {
+    const a = pointsA[i]
+    for (let j = 0; j < pointsB.length; j++) {
+      const b = pointsB[j]
+      summedPoints.push([a[0] + b[0], a[1] + b[1], a[2] + b[2]])
+    }
+  }
+
+  // Compute convex hull of the summed points
+  const hullPolygons = hullPoints3(summedPoints)
+
+  return geom3.create(hullPolygons)
+}
+
+/*
+ * Extract unique vertices from a geom3.
+ * Uses a Set with string keys for deduplication.
+ */
+const extractUniqueVertices = (geometry) => {
+  const found = new Set()
+  const unique = []
+
+  const polygons = geom3.toPolygons(geometry)
+  for (let i = 0; i < polygons.length; i++) {
+    const vertices = polygons[i].vertices
+    for (let j = 0; j < vertices.length; j++) {
+      const v = vertices[j]
+      const key = `${v[0]},${v[1]},${v[2]}`
+      if (!found.has(key)) {
+        found.add(key)
+        unique.push(v)
+      }
+    }
+  }
+
+  return unique
+}