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

package/src/geometries/poly3/measureBoundingBox.js

@@ -1,6 +1,8 @@
 import * as vec3 from '../../maths/vec3/index.js'
 
 /**
+ * Measure the bounding box of the given polygon.
+ *
  * @param {Poly3} polygon - the polygon to measure
  * @returns {Array} an array of two vectors (3D);  minimum and maximum coordinates
  * @alias module:modeling/geometries/poly3.measureBoundingBox

package/src/geometries/poly3/measureBoundingSphere.d.ts

@@ -1,4 +1,5 @@
 import type { Poly3 } from './type.d.ts'
 import type { Vec4 } from '../../maths/vec4/type.d.ts'
 
-export function measureBoundingSphere(polygon: Poly3): Vec4
+export function measureBoundingSphere(out: Vec4, polygon: Poly3): Vec4
+export function measureBoundingSphereAndCache(polygon: Poly3): Vec4

package/src/geometries/poly3/measureBoundingSphere.js

@@ -4,16 +4,14 @@ const cache = new WeakMap()
 
 /**
  * Measure the bounding sphere of the given polygon.
+ *
+ * @param {Vec4} out - receiving vector
  * @param {Poly3} polygon - the polygon to measure
  * @returns {Vec4} the computed bounding sphere; center vertex (3D) and radius
  * @alias module:modeling/geometries/poly3.measureBoundingSphere
  */
-export const measureBoundingSphere = (polygon) => {
-  const boundingSphere = cache.get(polygon)
-  if (boundingSphere) return boundingSphere
-
+export const measureBoundingSphere = (out, polygon) => {
   const vertices = polygon.vertices
-  const out = vec4.create()
 
   if (vertices.length === 0) {
     out[0] = 0
@@ -31,14 +29,15 @@ export const measureBoundingSphere = (polygon) => {
   let maxy = minx
   let maxz = minx
 
-  vertices.forEach((v) => {
+  for (let i = 0; i < vertices.length; i++) {
+    const v = vertices[i]
     if (minx[0] > v[0]) minx = v
     if (miny[1] > v[1]) miny = v
     if (minz[2] > v[2]) minz = v
     if (maxx[0] < v[0]) maxx = v
     if (maxy[1] < v[1]) maxy = v
     if (maxz[2] < v[2]) maxz = v
-  })
+  }
 
   out[0] = (minx[0] + maxx[0]) * 0.5 // center of sphere
   out[1] = (miny[1] + maxy[1]) * 0.5
@@ -48,7 +47,25 @@ export const measureBoundingSphere = (polygon) => {
   const z = out[2] - maxz[2]
   out[3] = Math.sqrt(x * x + y * y + z * z) // radius of sphere
 
-  cache.set(polygon, out)
+  return out
+}
+
+/**
+ * Measure the bounding sphere of the given polygon.
+ *
+ * This version maintains a cache, retrievning previously calculated bounds if found.
+ *
+ * @param {Poly3} polygon - the polygon to measure
+ * @returns {Vec4} the computed bounding sphere; center vertex (3D) and radius
+ * @alias module:modeling/geometries/poly3.measureBoundingSphere
+ */
+export const measureBoundingSphereAndCache = (polygon) => {
+  const boundingSphere = cache.get(polygon)
+  if (boundingSphere) return boundingSphere
 
+  const out = [0, 0, 0, 0]
+  measureBoundingSphere(out, polygon)
+
+  cache.set(polygon, out)
   return out
 }

package/src/geometries/poly3/measureBoundingSphere.test.js

@@ -7,19 +7,22 @@ import { measureBoundingSphere, create, transform } from './index.js'
 test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let ply1 = create()
   let exp1 = [0, 0, 0, 0]
-  let ret1 = measureBoundingSphere(ply1)
+  let ret1 = [0, 0, 0, 0]
+  ret1 = measureBoundingSphere(ret1, ply1)
   t.deepEqual(ret1, exp1)
 
   // simple triangle
   let ply2 = create([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
   let exp2 = [0, 5, 5, 7.0710678118654755]
-  let ret2 = measureBoundingSphere(ply2)
+  let ret2 = [0, 0, 0, 0]
+  ret2 = measureBoundingSphere(ret2, ply2)
   t.deepEqual(ret2, exp2)
 
   // simple square
   let ply3 = create([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
   let exp3 = [0, 5, 5, 7.0710678118654755]
-  let ret3 = measureBoundingSphere(ply3)
+  let ret3 = [0, 0, 0, 0]
+  ret3 = measureBoundingSphere(ret3, ply3)
   t.deepEqual(ret3, exp3)
 
   // V-shape
@@ -37,7 +40,8 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   ]
   let ply4 = create(vertices)
   let exp4 = [0, 4.5, 3, 4.6097722286464435]
-  let ret4 = measureBoundingSphere(ply4)
+  let ret4 = [0, 0, 0, 0]
+  ret4 = measureBoundingSphere(ret4, ply4)
   t.deepEqual(ret4, exp4)
 
   // rotated to various angles
@@ -46,10 +50,10 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   ply2 = transform(rotation, ply2)
   ply3 = transform(rotation, ply3)
   ply4 = transform(rotation, ply4)
-  ret1 = measureBoundingSphere(ply1)
-  ret2 = measureBoundingSphere(ply2)
-  ret3 = measureBoundingSphere(ply3)
-  ret4 = measureBoundingSphere(ply4)
+  ret1 = measureBoundingSphere(ret1, ply1)
+  ret2 = measureBoundingSphere(ret2, ply2)
+  ret3 = measureBoundingSphere(ret3, ply3)
+  ret4 = measureBoundingSphere(ret4, ply4)
   exp1 = [0, 0, 0, 0]
   t.deepEqual(ret1, exp1)
   exp2 = [-3.5355339059327373, 3.5355339059327378, 5, 7.0710678118654755]

package/src/index.js

@@ -13,3 +13,44 @@ export * from './operations/hulls/index.js'
 export * from './operations/modifiers/index.js'
 export * from './operations/offsets/index.js'
 export * from './operations/transforms/index.js'
+
+// V2 API compatibility:
+export * as colors from './colors/index.js'
+export * as curves from './curves/index.js'
+import { geom2, geom3, path2, poly2, poly3 } from './geometries/index.js'
+export const geometries = {
+  geom2: {
+    ...geom2,
+    create: (sides) => geom2.fromSides(sides),
+    fromPoints: (points) => geometries.geom2.create([points])
+  },
+  geom3,
+  path2,
+  poly2,
+  poly3: {
+    ...poly3,
+    fromPoints: (points) => poly3.create([points]),
+    fromPointsAndPlane: poly3.fromVerticesAndPlane,
+    toPoints: poly3.toVertices
+  }
+}
+export * as maths from './maths/index.js'
+export * as measurements from './measurements/index.js'
+export * as primitives from './primitives/index.js'
+export * as text from './text/index.js'
+export * as booleans from './operations/booleans/index.js'
+import * as extrusion from './operations/extrusions/index.js'
+import * as offsets from './operations/offsets/index.js'
+export const extrusions = {
+  ...extrusion,
+  extrudeRectangular: (opt, geom) => extrusions.extrudeLinear(opt, offsets.offset(opt, geom)),
+  slice: geometries.slice
+}
+export * as hulls from './operations/hulls/index.js'
+export * as modifiers from './operations/modifiers/index.js'
+export const expansions = {
+  ...offsets,
+  expand: offsets.offset
+}
+export * as transforms from './operations/transforms/index.js'
+export * as utils from './utils/index.js'

package/src/measurements/measureBoundingSphere.js

@@ -64,17 +64,13 @@ const measureBoundingSphereOfPoints = (points) => {
  * Measure the bounding sphere of the given (path2) geometry.
  * @return {[[x, y, z], radius]} the bounding sphere for the geometry
  */
-const measureBoundingSphereOfPath2 = (points) => {
-  return measureBoundingSphereOfPoints(path2.toPoints(points))
-}
+const measureBoundingSphereOfPath2 = (geometry) => measureBoundingSphereOfPoints(path2.toPoints(geometry))
 
 /*
  * Measure the bounding sphere of the given (geom2) geometry.
  * @return {[[x, y, z], radius]} the bounding sphere for the geometry
  */
-const measureBoundingSphereOfGeom2 = (geometry) => {
-  return measureBoundingSphereOfPoints(geom2.toPoints(geometry))
-}
+const measureBoundingSphereOfGeom2 = (geometry) => measureBoundingSphereOfPoints(geom2.toPoints(geometry))
 
 /*
  * Measure the bounding sphere of the given (geom3) geometry.

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

@@ -17,7 +17,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
 
   // intersect of one object
   const result1 = intersect(geometry1)
-  let obs = geom3.toPoints(result1)
+  let obs = geom3.toVertices(result1)
   let exp = [
     [[2, 0, 0], [1.4142135623730951, -1.414213562373095, 0],
       [1.0000000000000002, -1, -1.414213562373095], [1.4142135623730951, 0, -1.414213562373095]],
@@ -78,7 +78,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   const geometry2 = center({ relativeTo: [10, 10, 10] }, cuboid({ size: [4, 4, 4] }))
 
   const result2 = intersect(geometry1, geometry2)
-  obs = geom3.toPoints(result2)
+  obs = geom3.toVertices(result2)
   t.notThrows(() => geom3.validate(result2))
   t.is(measureArea(result2), 0)
   t.is(measureVolume(result2), 0)
@@ -88,7 +88,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   const geometry3 = cuboid({ size: [18, 18, 18] })
 
   const result3 = intersect(geometry2, geometry3)
-  obs = geom3.toPoints(result3)
+  obs = geom3.toVertices(result3)
 
   // the order changes based on the best plane chosen in Node.js
   exp = [
@@ -108,7 +108,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
 
   // intersect of two completely overlapping objects
   const result4 = intersect(geometry1, geometry3)
-  obs = geom3.toPoints(result4)
+  obs = geom3.toVertices(result4)
   t.notThrows.skip(() => geom3.validate(result4))
   t.is(measureArea(result4), 44.053756306589825)
   t.is(measureVolume(result4), 25.751611331979678)

package/src/operations/booleans/martinez/compareEvents.js

@@ -23,23 +23,18 @@ export const compareEvents = (e1, e2) => {
   // Event with lower y-coordinate is processed first
   if (p1[1] !== p2[1]) return p1[1] > p2[1] ? 1 : -1
 
-  return specialCases(e1, e2, p1, p2)
-}
-
-const specialCases = (e1, e2, p1, p2) => {
   // Same coordinates, but one is a left endpoint and the other is
   // a right endpoint. The right endpoint is processed first
   if (e1.left !== e2.left) { return e1.left ? 1 : -1 }
 
-  // const p2 = e1.otherEvent.point, p3 = e2.otherEvent.point
-  // const sa = (p1[0] - p3[0]) * (p2[1] - p3[1]) - (p2[0] - p3[0]) * (p1[1] - p3[1])
   // Same coordinates, both events
   // are left endpoints or right endpoints.
   // not collinear
   if (signedArea(p1, e1.otherEvent.point, e2.otherEvent.point) !== 0) {
-    // the event associate to the bottom segment is processed first
+    // the event associate to the lowest segment is processed first
     return (!e1.isBelow(e2.otherEvent.point)) ? 1 : -1
   }
 
+  // Same coordinates, subject events are processed first
   return (!e1.isSubject && e2.isSubject) ? 1 : -1
 }

package/src/operations/booleans/martinez/connectEdges.js

@@ -12,45 +12,39 @@ import { Contour } from './contour.js'
  * @return {SweepEvent[]}
  */
 const orderEvents = (sortedEvents) => {
-  let event, i, len, tmp
   const resultEvents = []
-  for (i = 0, len = sortedEvents.length; i < len; i++) {
-    event = sortedEvents[i]
-    if ((event.left && event.inResult) ||
-      (!event.left && event.otherEvent.inResult)) {
-      resultEvents.push(event)
+  sortedEvents.forEach((e) => {
+    if ((e.left && e.inResult) || (!e.left && e.otherEvent.inResult)) {
+      resultEvents.push(e)
     }
-  }
+  })
   // Due to overlapping edges the resultEvents array can be not wholly sorted
   let sorted = false
   while (!sorted) {
     sorted = true
-    for (i = 0, len = resultEvents.length; i < len; i++) {
+    const len = resultEvents.length
+    for (let i = 0; i < len; i++) {
       if ((i + 1) < len &&
         compareEvents(resultEvents[i], resultEvents[i + 1]) === 1) {
-        tmp = resultEvents[i]
+        const tmp = resultEvents[i]
         resultEvents[i] = resultEvents[i + 1]
         resultEvents[i + 1] = tmp
         sorted = false
       }
     }
   }
-
-  for (i = 0, len = resultEvents.length; i < len; i++) {
-    event = resultEvents[i]
-    event.otherPos = i
-  }
+  // and index
+  resultEvents.forEach((e, i) => { e.otherPos = i })
 
   // imagine, the right event is found in the beginning of the queue,
   // when his left counterpart is not marked yet
-  for (i = 0, len = resultEvents.length; i < len; i++) {
-    event = resultEvents[i]
-    if (!event.left) {
-      tmp = event.otherPos
-      event.otherPos = event.otherEvent.otherPos
-      event.otherEvent.otherPos = tmp
+  resultEvents.forEach((e) => {
+    if (!e.left) {
+      const otherPos = e.otherPos
+      e.otherPos = e.otherEvent.otherPos
+      e.otherEvent.otherPos = otherPos
     }
-  }
+  })
 
   return resultEvents
 }
@@ -62,14 +56,15 @@ const orderEvents = (sortedEvents) => {
  * @return {number}
  */
 const nextPos = (pos, resultEvents, processed, origPos) => {
-  let newPos = pos + 1
-  const p = resultEvents[pos].point
-  let p1
   const length = resultEvents.length
 
+  const p0 = resultEvents[pos].point
+
+  let newPos = pos + 1
+  let p1
   if (newPos < length) { p1 = resultEvents[newPos].point }
 
-  while (newPos < length && p1[0] === p[0] && p1[1] === p[1]) {
+  while (newPos < length && p1[0] === p0[0] && p1[1] === p0[1]) {
     if (!processed[newPos]) {
       return newPos
     } else {
@@ -81,7 +76,6 @@ const nextPos = (pos, resultEvents, processed, origPos) => {
   }
 
   newPos = pos - 1
-
   while (processed[newPos] && newPos > origPos) {
     newPos--
   }
@@ -90,7 +84,8 @@ const nextPos = (pos, resultEvents, processed, origPos) => {
 }
 
 const initializeContourFromContext = (event, contours, contourId) => {
-  const contour = new Contour()
+  const contour = new Contour() // default is exterior contour of depth 0
+
   if (event.prevInResult != null) {
     const prevInResult = event.prevInResult
     // Note that it is valid to query the "previous in result" for its output contour id,
@@ -99,6 +94,7 @@ const initializeContourFromContext = (event, contours, contourId) => {
     // result".
     const lowerContourId = prevInResult.outputContourId
     const lowerResultTransition = prevInResult.resultTransition
+
     if (lowerContourId < 0) {
       contour.holeOf = null
       contour.depth = 0
@@ -122,30 +118,24 @@ const initializeContourFromContext = (event, contours, contourId) => {
       }
     } else {
       // We are outside => this contour is an exterior contour of same depth.
-      contour.holeOf = null
       contour.depth = contours[lowerContourId].depth
     }
-  } else {
-    // There is no lower/previous contour => this contour is an exterior contour of depth 0.
-    contour.holeOf = null
-    contour.depth = 0
   }
   return contour
 }
 
 /**
  * @param {Array.<SweepEvent>} sortedEvents
- * @return {Array.<*>} polygons
+ * @return array of Contour
  */
 export const connectEdges = (sortedEvents) => {
   const resultEvents = orderEvents(sortedEvents)
-  const len = resultEvents.length
+  const evlen = resultEvents.length
 
-  // "false"-filled array
-  const processed = {}
+  const processed = []
   const contours = []
 
-  for (let i = 0; i < len; i++) {
+  for (let i = 0; i < evlen; i++) {
     if (processed[i]) {
       continue
     }
@@ -156,7 +146,7 @@ export const connectEdges = (sortedEvents) => {
     // Helper function that combines marking an event as processed with assigning its output contour ID
     const markAsProcessed = (pos) => {
       processed[pos] = true
-      if (pos < resultEvents.length && resultEvents[pos]) {
+      if (pos < evlen) {
         resultEvents[pos].outputContourId = contourId
       }
     }
@@ -164,8 +154,7 @@ export const connectEdges = (sortedEvents) => {
     let pos = i
     const origPos = i
 
-    const initial = resultEvents[i].point
-    contour.points.push(initial)
+    contour.points.push(resultEvents[pos].point)
 
     while (true) {
       markAsProcessed(pos)
@@ -177,7 +166,7 @@ export const connectEdges = (sortedEvents) => {
 
       pos = nextPos(pos, resultEvents, processed, origPos)
 
-      if (pos === origPos || pos >= resultEvents.length || !resultEvents[pos]) {
+      if (pos === origPos || pos >= evlen) {
         break
       }
     }

package/src/operations/booleans/martinez/contour.js

@@ -3,7 +3,7 @@ export class Contour {
     this.points = []
     this.holeIds = []
     this.holeOf = null
-    this.depth = null
+    this.depth = 0
   }
 
   isExterior () {

package/src/operations/booleans/martinez/divideSegment.js

@@ -2,28 +2,29 @@ import { SweepEvent } from './sweepEvent.js'
 import { compareEvents } from './compareEvents.js'
 
 /**
- * @param {SweepEvent} se
- * @param {Array.<Number>} p
+ * Divide the given segment at the given point, push the parts on the given queue.
+ * @param {SweepEvent} segment
+ * @param {Array.<Number>} point
  * @param {Queue} queue
- * @return {Queue}
+ * @return {Queue} given queue
  */
-export const divideSegment = (se, p, queue) => {
-  const r = new SweepEvent(p, false, se, se.isSubject)
-  const l = new SweepEvent(p, true, se.otherEvent, se.isSubject)
+export const divideSegment = (segment, point, queue) => {
+  const r = new SweepEvent(point, false, segment, segment.isSubject)
+  const l = new SweepEvent(point, true, segment.otherEvent, segment.isSubject)
 
-  r.contourId = l.contourId = se.contourId
+  r.contourId = l.contourId = segment.contourId
 
   // avoid a rounding error. The left event would be processed after the right event
-  if (compareEvents(l, se.otherEvent) > 0) {
-    se.otherEvent.left = true
+  if (compareEvents(l, segment.otherEvent) > 0) {
+    segment.otherEvent.left = true
     l.left = false
   }
 
   // avoid a rounding error. The left event would be processed after the right event
   // if (compareEvents(se, r) > 0) {}
 
-  se.otherEvent.otherEvent = l
-  se.otherEvent = r
+  segment.otherEvent.otherEvent = l
+  segment.otherEvent = r
 
   queue.push(l)
   queue.push(r)

package/src/operations/booleans/martinez/fillQueue.js

@@ -9,26 +9,23 @@ import { DIFFERENCE } from './operation.js'
 import { SweepEvent } from './sweepEvent.js'
 import { Queue } from './tinyqueue.js'
 
-const max = Math.max
-const min = Math.min
+let externalRingId = 0
 
-let contourId = 0
-
-const processPolygon = (contourOrHole, isSubject, depth, queue, bbox, isExteriorRing) => {
+const processPolygon = (contourOrHole, isSubject, ringId, queue, bbox, isExteriorRing) => {
   const len = contourOrHole.length - 1
-  let s1, s2, e1, e2
   for (let i = 0; i < len; i++) {
-    s1 = contourOrHole[i]
-    s2 = contourOrHole[i + 1]
-    e1 = new SweepEvent(s1, false, undefined, isSubject)
-    e2 = new SweepEvent(s2, false, e1, isSubject)
+    const s1 = contourOrHole[i]
+    const s2 = contourOrHole[i + 1]
+    const e1 = new SweepEvent(s1, false, undefined, isSubject)
+    const e2 = new SweepEvent(s2, false, e1, isSubject)
+
     e1.otherEvent = e2
 
     if (s1[0] === s2[0] && s1[1] === s2[1]) {
       continue // skip collapsed edges, or it breaks
     }
 
-    e1.contourId = e2.contourId = depth
+    e1.contourId = e2.contourId = ringId
     if (!isExteriorRing) {
       e1.isExteriorRing = false
       e2.isExteriorRing = false
@@ -41,10 +38,10 @@ const processPolygon = (contourOrHole, isSubject, depth, queue, bbox, isExterior
 
     const x = s1[0]
     const y = s1[1]
-    bbox[0] = min(bbox[0], x)
-    bbox[1] = min(bbox[1], y)
-    bbox[2] = max(bbox[2], x)
-    bbox[3] = max(bbox[3], y)
+    bbox[0] = Math.min(bbox[0], x)
+    bbox[1] = Math.min(bbox[1], y)
+    bbox[2] = Math.max(bbox[2], x)
+    bbox[3] = Math.max(bbox[3], y)
 
     // Pushing it so the queue is sorted from left to right,
     // with object on the left having the highest priority.
@@ -55,24 +52,23 @@ const processPolygon = (contourOrHole, isSubject, depth, queue, bbox, isExterior
 
 export const fillQueue = (subject, clipping, sbbox, cbbox, operation) => {
   const eventQueue = new Queue([], compareEvents)
-  let polygonSet, isExteriorRing, i, ii, j, jj //, k, kk
 
-  for (i = 0, ii = subject.length; i < ii; i++) {
-    polygonSet = subject[i]
-    for (j = 0, jj = polygonSet.length; j < jj; j++) {
-      isExteriorRing = j === 0
-      if (isExteriorRing) contourId++
-      processPolygon(polygonSet[j], true, contourId, eventQueue, sbbox, isExteriorRing)
+  for (let i = 0; i < subject.length; i++) {
+    const polygonSet = subject[i]
+    for (let j = 0; j < polygonSet.length; j++) {
+      const isExteriorRing = j === 0
+      if (isExteriorRing) externalRingId++
+      processPolygon(polygonSet[j], true, externalRingId, eventQueue, sbbox, isExteriorRing)
     }
   }
 
-  for (i = 0, ii = clipping.length; i < ii; i++) {
-    polygonSet = clipping[i]
-    for (j = 0, jj = polygonSet.length; j < jj; j++) {
-      isExteriorRing = j === 0
+  for (let i = 0; i < clipping.length; i++) {
+    const polygonSet = clipping[i]
+    for (let j = 0; j < polygonSet.length; j++) {
+      let isExteriorRing = j === 0
       if (operation === DIFFERENCE) isExteriorRing = false
-      if (isExteriorRing) contourId++
-      processPolygon(polygonSet[j], false, contourId, eventQueue, cbbox, isExteriorRing)
+      if (isExteriorRing) externalRingId++
+      processPolygon(polygonSet[j], false, externalRingId, eventQueue, cbbox, isExteriorRing)
     }
   }
 

package/src/operations/booleans/martinez/index.js

@@ -135,6 +135,7 @@ export const boolean = (subjectGeom, clippingGeom, operation) => {
       // Followed by holes if any
       for (let j = 0; j < contour.holeIds.length; j++) {
         const holeId = contour.holeIds[j]
+        // Reverse the order of points for holes
         const holePoints = contours[holeId].points
         const hole = []
         for (let k = holePoints.length - 2; k >= 0; k--) {
@@ -146,7 +147,7 @@ export const boolean = (subjectGeom, clippingGeom, operation) => {
     }
   }
 
-  if (polygons) {
+  if (polygons.length) {
     return fromOutlines(polygons.flat())
   } else {
     return geom2.create()