@jscad/modeling 3.0.5-alpha.0 → 3.0.6-alpha.0

package/src/operations/extrusions/extrudeLinearGeom2.js

@@ -4,6 +4,8 @@ import * as vec3 from '../../maths/vec3/index.js'
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as slice from '../../geometries/slice/index.js'
 
+import { isNumberArray } from '../../primitives/commonChecks.js'
+
 import { extrudeFromSlices } from './extrudeFromSlices.js'
 
 /*
@@ -26,6 +28,7 @@ export const extrudeLinearGeom2 = (options, geometry) => {
   }
   let { offset, twistAngle, twistSteps, repair } = Object.assign({ }, defaults, options)
 
+  if (!isNumberArray(offset, 3)) throw new Error('offset must be an array of three numbers')
   if (twistSteps < 1) throw new Error('twistSteps must be 1 or more')
 
   if (twistAngle === 0) {
@@ -33,18 +36,18 @@ export const extrudeLinearGeom2 = (options, geometry) => {
   }
 
   // convert to vector in order to perform transforms
-  const offsetV = vec3.clone(offset)
-
   let baseSlice = slice.fromOutlines(geom2.toOutlines(geometry))
-  if (offsetV[2] < 0) baseSlice = slice.reverse(baseSlice)
+  if (offset[2] < 0) baseSlice = slice.reverse(baseSlice)
 
-  const matrix = mat4.create()
+  const matrix1 = mat4.create()
+  const matrix2 = mat4.create()
+  const offset1 = vec3.create()
   const createTwist = (progress, index, base) => {
     const Zrotation = index / twistSteps * twistAngle
-    const Zoffset = vec3.scale(vec3.create(), offsetV, index / twistSteps)
-    mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromTranslation(mat4.create(), Zoffset))
+    const Zoffset = vec3.scale(offset1, offset, index / twistSteps)
+    mat4.multiply(matrix1, mat4.fromZRotation(matrix1, Zrotation), mat4.fromTranslation(matrix2, Zoffset))
 
-    return slice.transform(matrix, base)
+    return slice.transform(matrix1, base)
   }
 
   options = {

package/src/operations/hulls/quickhull/Face.js

@@ -308,9 +308,14 @@ export class Face {
     const e2 = new HalfEdge(v2, face)
 
     // join edges
-    e0.next = e2.prev = e1
-    e1.next = e0.prev = e2
-    e2.next = e1.prev = e0
+    e0.next = e1
+    e2.prev = e1
+
+    e1.next = e2
+    e0.prev = e2
+
+    e2.next = e0
+    e1.prev = e0
 
     // main half edge reference
     face.edge = e0

package/src/operations/hulls/quickhull/QuickHull.js

@@ -118,6 +118,7 @@ export class QuickHull {
       end.next = null
       return face.outside
     }
+    return undefined
   }
 
   /**
@@ -215,11 +216,13 @@ export class QuickHull {
 
     // initially assume that the first vertex is the min/max
     for (i = 0; i < 3; i += 1) {
-      minVertices[i] = maxVertices[i] = this.vertices[0]
+      minVertices[i] = this.vertices[0]
+      maxVertices[i] = this.vertices[0]
     }
     // copy the coordinates of the first vertex to min/max
     for (i = 0; i < 3; i += 1) {
-      min[i] = max[i] = this.vertices[0].point[i]
+      min[i] = this.vertices[0].point[i]
+      max[i] = this.vertices[0].point[i]
     }
 
     // compute the min/max vertex on all 6 directions
@@ -456,6 +459,7 @@ export class QuickHull {
       }
       return eyeVertex
     }
+    return undefined
   }
 
   /**
@@ -477,7 +481,8 @@ export class QuickHull {
 
     let edge
     if (!crossEdge) {
-      edge = crossEdge = face.getEdge(0)
+      crossEdge = face.getEdge(0)
+      edge = crossEdge
     } else {
       // start from the next edge since `crossEdge` was already analyzed
       // (actually `crossEdge.opposite` was the face who called this method
@@ -722,7 +727,7 @@ export class QuickHull {
     for (let i = 0; i < this.newFaces.length; i += 1) {
       const face = this.newFaces[i]
       if (face.mark === VISIBLE) {
-        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX_WRT_LARGER_FACE)) {} // eslint-disable-line no-empty
+        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX_WRT_LARGER_FACE)) {}
       }
     }
 
@@ -733,7 +738,7 @@ export class QuickHull {
       const face = this.newFaces[i]
       if (face.mark === NON_CONVEX) {
         face.mark = VISIBLE
-        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX)) {} // eslint-disable-line no-empty
+        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX)) {}
       }
     }
 

package/src/operations/hulls/quickhull/VertexList.js

@@ -11,7 +11,8 @@ export class VertexList {
   }
 
   clear () {
-    this.head = this.tail = null
+    this.head = null
+    this.tail = null
   }
 
   /**

package/src/operations/modifiers/reTesselateCoplanarPolygons.js

@@ -317,8 +317,8 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
           const vertices3d = points2d.map((point2d) => orthonormalFormula.to3D(point2d))
           const polygon = poly3.fromVerticesAndPlane(vertices3d, plane) // TODO support shared
 
-          // if we let empty polygon out, next retesselate will crash
-          if (polygon.vertices.length) destPolygons.push(polygon)
+          // if we let invalid polygons out, next retesselate will crash
+          if (polygon.vertices.length > 2) destPolygons.push(polygon)
         }
       }
     } // if(yIndex > 0)

package/src/operations/modifiers/reTesselateCoplanarPolygons.test.js

@@ -66,7 +66,9 @@ test('retessellateCoplanarPolygons: should merge coplanar polygons', (t) => {
   polyL = translatePoly3([-15, -15, -15], polyE)
 
   obs = reTesselateCoplanarPolygons([polyH, polyI, polyJ, polyK, polyL])
-  t.is(obs.length, 1)
+  obs.forEach((polygon) => {
+    poly3.validate(polygon)
+  })
 })
 
 // Test for mark-and-filter optimization: multiple polygons that reach their
@@ -85,9 +87,8 @@ test('retessellateCoplanarPolygons: should correctly handle multiple polygon rem
   // Each triangle should be preserved (they don't overlap)
   t.is(obs.length, 3)
 
-  // Verify each polygon has 3 vertices (triangles)
   obs.forEach((polygon) => {
-    t.is(polygon.vertices.length, 3)
+    poly3.validate(polygon)
   })
 })
 
@@ -103,3 +104,28 @@ test('retessellateCoplanarPolygons: should merge adjacent polygons with shared e
   t.is(obs.length, 1)
   t.is(obs[0].vertices.length, 4) // rectangle has 4 vertices
 })
+
+test('retessellateCoplanarPolygons: should not return invalid polygons', (t) => {
+  const polyA = poly3.create([
+    [ 3.72172376113686, -3.7661089598376325, 13 ],
+    [ 3.72172376113686, -3.7661089598376325, 13.515937566757202 ],
+    [ 3.721663581864801, -3.766195461144145, 13.515937566757202 ]
+  ])
+  const polyB = poly3.create([
+    [ 3.721663581864801, -3.766195461144145, 13.0084828728813 ],
+    [ 3.721663581864801, -3.766195461144145, 13.00100040435791 ],
+    [ 3.721716664059388, -3.7661191611320772, 13.00100040435791 ]
+  ])
+  const polyC = poly3.create([
+    [ 3.721663581864801, -3.766195461144145, 13.515937566757202 ],
+    [ 3.721663581864801, -3.766195461144145, 13.0084828728813 ],
+    [ 3.7217166640593886, -3.766119161132077, 13.00100040435791 ],
+    [ 3.7217236444490864, -3.766109127563903, 13.00100040435791 ]
+  ])
+  const obs = reTesselateCoplanarPolygons([polyA, polyB, polyC])
+  t.is(obs.length, 1)
+
+  obs.forEach((polygon) => {
+    poly3.validate(polygon)
+  })
+})

package/src/operations/modifiers/retessellate.js

@@ -18,6 +18,7 @@ export const retessellate = (geometry) => {
     return geometry
   }
 
+  // FIXME this is creating new polygons
   const polygons = geom3.toPolygons(geometry).map((polygon, index) => ({ vertices: polygon.vertices, plane: poly3.plane(polygon), index: index }))
   const classified = classifyPolygons(polygons)
 

package/src/operations/modifiers/snap.js

@@ -1,5 +1,5 @@
 import * as vec2 from '../../maths/vec2/index.js'
-import * as vec3 from '../../maths/vec2/index.js'
+import * as vec3 from '../../maths/vec3/index.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
@@ -18,7 +18,7 @@ const snapPath2 = (geometry) => {
   const points = path2.toPoints(geometry)
   const newPoints = points.map((point) => vec2.snap(vec2.create(), point, epsilon))
   // snap can produce duplicate points, remove those
-  return path2.fromPoints({}, newPoints)
+  return path2.fromPoints({ closed: geometry.isClosed }, newPoints)
 }
 
 /*
@@ -28,7 +28,7 @@ const snapPath3 = (geometry) => {
   const vertices = path3.toVertices(geometry)
   const newVertices = vertices.map((vertice) => vec3.snap(vec3.create(), vertice, epsilon))
   // snap can produce duplicate points, remove those
-  return path3.fromVertices({}, newVertices)
+  return path3.fromVertices({ closed: geometry.isClosed }, newVertices)
 }
 
 /*

package/src/operations/modifiers/snap.test.js

@@ -15,9 +15,10 @@ test('snap: snap of a path2 produces an expected path2', (t) => {
   const geometry2 = arc({ radius: 1 / 2, segments: 8 })
   const geometry3 = arc({ radius: 1.3333333333333333 / 2, segments: 8 })
   const geometry4 = arc({ radius: TAU / 4 * 1000, segments: 8 })
+  const geometry5 = path2.fromPoints({ closed: true }, [[0, 0], [2, 2], [4, 0]])
 
-  const results = snap(geometry1, geometry2, geometry3, geometry4)
-  t.is(results.length, 4)
+  const results = snap(geometry1, geometry2, geometry3, geometry4, geometry5)
+  t.is(results.length, 5)
 
   let pts = path2.toPoints(results[0])
   let exp = []
@@ -61,6 +62,15 @@ test('snap: snap of a path2 produces an expected path2', (t) => {
     [1110.7100826766714, -1110.7100826766714]
   ]
   t.true(comparePoints(pts, exp))
+
+  t.true(results[4].isClosed)
+  pts = path2.toPoints(results[4])
+  exp = [
+    [0, 0],
+    [2.00001, 2.00001],
+    [3.9999900000000004, 0]
+  ]
+  t.true(comparePoints(pts, exp))
 })
 
 test('snap: snap of a geom2 produces an expected geom2', (t) => {

package/src/operations/offsets/offsetGeom3.test.js

@@ -91,6 +91,6 @@ test('offsetGeom3: offset completes properly, issue 876', (t) => {
 
   const obs = offset({ delta: 1.3, corners: 'round', segments: 12 }, sub)
   t.notThrows.skip(() => geom3.validate(obs))
-  t.is(measureArea(obs), 524.9674760547548)
-  t.is(measureVolume(obs), 604.0599465573156)
+  t.is(measureArea(obs), 524.9674756919702)
+  t.is(measureVolume(obs), 604.0599468042326)
 })

package/src/operations/transforms/translate.js

@@ -20,8 +20,12 @@ export const translate = (offset, ...objects) => {
   if (!Array.isArray(offset)) throw new Error('offset must be an array')
 
   // adjust the offset if necessary
-  offset = offset.slice() // don't modify the original
-  while (offset.length < 3) offset.push(0)
+  if (offset.length < 3) {
+    offset = offset.slice() // don't modify the original
+    while (offset.length < 3) {
+      offset.push(0)
+    }
+  }
 
   const matrix = mat4.fromTranslation(mat4.create(), offset)
 

package/src/primitives/arc.js

@@ -51,14 +51,13 @@ export const arc = (options = {}) => {
 
   const minAngle = Math.acos(((radius * radius) + (radius * radius) - (EPS * EPS)) / (2 * radius * radius))
 
-  const centerV = vec2.clone(center)
   let point
   const pointArray = []
   if (rotation < minAngle) {
     // there is no rotation, just a single point
     point = vec2.fromAngleRadians(vec2.create(), startAngle)
     vec2.scale(point, point, radius)
-    vec2.add(point, point, centerV)
+    vec2.add(point, point, center)
     pointArray.push(point)
   } else {
     const numSteps = Math.floor(segments * (Math.abs(rotation) / TAU))
@@ -77,9 +76,9 @@ export const arc = (options = {}) => {
       const angle = startAngle + (step * (rotation / numSteps))
       point = vec2.fromAngleRadians(vec2.create(), angle)
       vec2.scale(point, point, radius)
-      vec2.add(point, point, centerV)
+      vec2.add(point, point, center)
       pointArray.push(point)
     }
   }
-  return path2.fromPoints({ closed: false }, pointArray)
+  return path2.fromPoints({}, pointArray)
 }

package/src/primitives/ellipse.js

@@ -61,7 +61,6 @@ export const ellipse = (options = {}) => {
 
   segments = Math.floor(segments * (rotation / TAU))
 
-  const centerV = vec2.clone(center)
   const step = rotation / segments // radians per segment
 
   const points = []
@@ -69,9 +68,9 @@ export const ellipse = (options = {}) => {
   for (let i = 0; i < segments; i++) {
     const angle = (step * i) + startAngle
     const point = vec2.fromValues(radius[0] * cos(angle), radius[1] * sin(angle))
-    vec2.add(point, centerV, point)
+    vec2.add(point, center, point)
     points.push(point)
   }
-  if (rotation < TAU) points.push(centerV)
+  if (rotation < TAU) points.push(vec2.clone(center)) // close with a new point
   return geom2.create([points])
 }

package/src/primitives/star.js

@@ -71,10 +71,8 @@ export const star = (options = {}) => {
     innerRadius = outerRadius * getRadiusRatio(vertices, density)
   }
 
-  const centerV = vec2.clone(center)
-
-  const outerPoints = getPoints(vertices, outerRadius, startAngle, centerV)
-  const innerPoints = getPoints(vertices, innerRadius, startAngle + Math.PI / vertices, centerV)
+  const outerPoints = getPoints(vertices, outerRadius, startAngle, center)
+  const innerPoints = getPoints(vertices, innerRadius, startAngle + Math.PI / vertices, center)
 
   const allPoints = []
   for (let i = 0; i < vertices; i++) {

package/test/helpers/nearlyEqual.js

@@ -29,4 +29,5 @@ export const nearlyEqual = (t, a, b, epsilon, failMessage) => {
     failMessage = failMessage === undefined ? 'Numbers outside of epsilon' : failMessage
     t.fail(failMessage + '(' + a + ',' + b + ')')
   }
+  return true
 }