@jscad/modeling 2.9.1 → 2.9.4

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.9.1",
+  "version": "2.9.4",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
+  "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -60,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "a90b9bad95a417661c619dc733e62c587dc71a4a"
+  "gitHead": "662965f40a1ce628aa97f30b814586e72a3acb36"
 }

package/src/colors/colorize.test.js

@@ -38,7 +38,7 @@ test('color (rgba on geometry)', (t) => {
   const obj0 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
   const obj1 = geom3.fromPoints([[[0, 0, 0], [1, 0, 0], [1, 0, 1]]])
   const obj2 = path2.fromPoints({ closed: true }, [[0, 0], [1, 0], [1, 1]])
-  const obj3 = poly3.fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const obj3 = poly3.create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
 
   const obs = colorize([1, 1, 0.5, 0.8], obj0, obj1, obj2, obj3)
   t.is(obs.length, 4)

package/src/geometries/geom2/toOutlines.js

@@ -6,22 +6,42 @@ const toSides = require('./toSides')
  * Create a list of edges which SHARE vertices.
  * This allows the edges to be traversed in order.
  */
-const toEdges = (sides) => {
-  const vertices = {}
+const toSharedVertices = (sides) => {
+  const unique = new Map() // {key: vertex}
   const getUniqueVertex = (vertex) => {
     const key = vertex.toString()
-    if (!vertices[key]) {
-      vertices[key] = vertex
+    if (unique.has(key)) {
+      return unique.get(key)
+    } else {
+      unique.set(key, vertex)
+      return vertex
     }
-    return vertices[key]
   }
 
   return sides.map((side) => side.map(getUniqueVertex))
 }
 
+/*
+ * Convert a list of sides into a map from vertex to edges.
+ */
+const toVertexMap = (sides) => {
+  const vertexMap = new Map()
+  // first map to edges with shared vertices
+  const edges = toSharedVertices(sides)
+  // construct adjacent edges map
+  edges.forEach((edge) => {
+    if (vertexMap.has(edge[0])) {
+      vertexMap.get(edge[0]).push(edge)
+    } else {
+      vertexMap.set(edge[0], [edge])
+    }
+  })
+  return vertexMap
+}
+
 /**
  * Create the outline(s) of the given geometry.
- * @param  {geom2} geometry
+ * @param {geom2} geometry - geometry to create outlines from
  * @returns {Array} an array of outlines, where each outline is an array of ordered points
  * @alias module:modeling/geometries/geom2.toOutlines
  *
@@ -30,65 +50,35 @@ const toEdges = (sides) => {
  * let outlines = toOutlines(geometry) // returns two outlines
  */
 const toOutlines = (geometry) => {
-  const vertexMap = new Map()
-  const edges = toEdges(toSides(geometry))
-  edges.forEach((edge) => {
-    if (!(vertexMap.has(edge[0]))) {
-      vertexMap.set(edge[0], [])
-    }
-    const sideslist = vertexMap.get(edge[0])
-    sideslist.push(edge)
-  })
-
+  const vertexMap = toVertexMap(toSides(geometry)) // {vertex: [edges]}
   const outlines = []
   while (true) {
-    let startside
+    let startSide
     for (const [vertex, edges] of vertexMap) {
-      startside = edges.shift()
-      if (!startside) {
+      startSide = edges.shift()
+      if (!startSide) {
         vertexMap.delete(vertex)
         continue
       }
       break
     }
-    if (startside === undefined) break // all starting sides have been visited
+    if (startSide === undefined) break // all starting sides have been visited
 
     const connectedVertexPoints = []
-    const startvertex = startside[0]
-    const v0 = vec2.create()
+    const startVertex = startSide[0]
     while (true) {
-      connectedVertexPoints.push(startside[0])
-      const nextvertex = startside[1]
-      if (nextvertex === startvertex) break // the outline has been closed
-      const nextpossiblesides = vertexMap.get(nextvertex)
-      if (!nextpossiblesides) {
-        throw new Error('the given geometry is not closed. verify proper construction')
+      connectedVertexPoints.push(startSide[0])
+      const nextVertex = startSide[1]
+      if (nextVertex === startVertex) break // the outline has been closed
+      const nextPossibleSides = vertexMap.get(nextVertex)
+      if (!nextPossibleSides) {
+        throw new Error(`geometry is not closed at vertex ${nextVertex}`)
       }
-      let nextsideindex = -1
-      if (nextpossiblesides.length === 1) {
-        nextsideindex = 0
-      } else {
-        // more than one side starting at the same vertex
-        let bestangle
-        const startangle = vec2.angleDegrees(vec2.subtract(v0, startside[1], startside[0]))
-        for (let sideindex = 0; sideindex < nextpossiblesides.length; sideindex++) {
-          const nextpossibleside = nextpossiblesides[sideindex]
-          const nextangle = vec2.angleDegrees(vec2.subtract(v0, nextpossibleside[1], nextpossibleside[0]))
-          let angledif = nextangle - startangle
-          if (angledif < -180) angledif += 360
-          if (angledif >= 180) angledif -= 360
-          if ((nextsideindex < 0) || (angledif > bestangle)) {
-            nextsideindex = sideindex
-            bestangle = angledif
-          }
-        }
+      const nextSide = popNextSide(startSide, nextPossibleSides)
+      if (nextPossibleSides.length === 0) {
+        vertexMap.delete(nextVertex)
       }
-      const nextside = nextpossiblesides[nextsideindex]
-      nextpossiblesides.splice(nextsideindex, 1) // remove side from list
-      if (nextpossiblesides.length === 0) {
-        vertexMap.delete(nextvertex)
-      }
-      startside = nextside
+      startSide = nextSide
     } // inner loop
 
     // due to the logic of fromPoints()
@@ -102,4 +92,28 @@ const toOutlines = (geometry) => {
   return outlines
 }
 
+// find the first counter-clockwise edge from startSide and pop from nextSides
+const popNextSide = (startSide, nextSides) => {
+  if (nextSides.length === 1) {
+    return nextSides.pop()
+  }
+  const v0 = vec2.create()
+  const startAngle = vec2.angleDegrees(vec2.subtract(v0, startSide[1], startSide[0]))
+  let bestAngle
+  let bestIndex
+  nextSides.forEach((nextSide, index) => {
+    const nextAngle = vec2.angleDegrees(vec2.subtract(v0, nextSide[1], nextSide[0]))
+    let angle = nextAngle - startAngle
+    if (angle < -180) angle += 360
+    if (angle >= 180) angle -= 360
+    if (bestIndex === undefined || angle > bestAngle) {
+      bestIndex = index
+      bestAngle = angle
+    }
+  })
+  const nextSide = nextSides[bestIndex]
+  nextSides.splice(bestIndex, 1) // remove side from list
+  return nextSide
+}
+
 module.exports = toOutlines

package/src/geometries/geom3/applyTransforms.js

@@ -14,9 +14,8 @@ const applyTransforms = (geometry) => {
   if (mat4.isIdentity(geometry.transforms)) return geometry
 
   // apply transforms to each polygon
-  // const isMirror = mat4.isMirroring(geometry.transforms)
-  // TBD if (isMirror) newvertices.reverse()
   geometry.polygons = geometry.polygons.map((polygon) => poly3.transform(geometry.transforms, polygon))
+  // reset transforms
   geometry.transforms = mat4.create()
   return geometry
 }

package/src/geometries/geom3/create.js

@@ -18,7 +18,7 @@ const create = (polygons) => {
     polygons = [] // empty contents
   }
   return {
-    polygons: polygons,
+    polygons,
     transforms: mat4.create()
   }
 }

package/src/geometries/geom3/create.test.js

@@ -14,7 +14,7 @@ test('create: Creates an empty geom3', (t) => {
 
 test('create: Creates a populated geom3', (t) => {
   const points = [[0, 0, 0], [0, 10, 0], [0, 10, 10]]
-  const polygon = poly3.fromPoints(points)
+  const polygon = poly3.create(points)
 
   const polygons = [polygon]
   const expected = {

package/src/geometries/geom3/fromPoints.js

@@ -18,7 +18,7 @@ const fromPoints = (listofpoints) => {
 
   const polygons = listofpoints.map((points, index) => {
     // TODO catch the error, and rethrow with index
-    const polygon = poly3.fromPoints(points)
+    const polygon = poly3.create(points)
     return polygon
   })
   const result = create(polygons)

package/src/geometries/path2/index.d.ts

@@ -5,7 +5,6 @@ export { default as clone } from './clone'
 export { default as close } from './close'
 export { default as concat } from './concat'
 export { default as create } from './create'
-export { default as eachPoint, EachPointOptions } from './eachPoint'
 export { default as equals } from './equals'
 export { default as fromPoints, FromPointsOptions } from './fromPoints'
 export { default as fromCompactBinary } from './fromCompactBinary'

package/src/geometries/path2/index.js

@@ -22,7 +22,6 @@ module.exports = {
   close: require('./close'),
   concat: require('./concat'),
   create: require('./create'),
-  eachPoint: require('./eachPoint'),
   equals: require('./equals'),
   fromPoints: require('./fromPoints'),
   fromCompactBinary: require('./fromCompactBinary'),

package/src/geometries/poly3/create.js

@@ -18,7 +18,7 @@ const create = (vertices) => {
   if (vertices === undefined || vertices.length < 3) {
     vertices = [] // empty contents
   }
-  return { vertices: vertices }
+  return { vertices }
 }
 
 module.exports = create

package/src/geometries/poly3/validate.js

@@ -1,7 +1,10 @@
+const signedDistanceToPoint = require('../../maths/plane/signedDistanceToPoint')
+const { NEPS } = require('../../maths/constants')
 const vec3 = require('../../maths/vec3')
 const isA = require('./isA')
 const isConvex = require('./isConvex')
 const measureArea = require('./measureArea')
+const plane = require('./plane')
 
 /**
  * Determine if the given object is a valid polygon.
@@ -45,6 +48,17 @@ const validate = (object) => {
       throw new Error(`poly3 invalid vertex ${vertex}`)
     }
   })
+
+  // check that points are co-planar
+  if (object.vertices.length > 3) {
+    const normal = plane(object)
+    object.vertices.forEach((vertex) => {
+      const dist = Math.abs(signedDistanceToPoint(normal, vertex))
+      if (dist > NEPS) {
+        throw new Error(`poly3 must be coplanar: vertex ${vertex} distance ${dist}`)
+      }
+    })
+  }
 }
 
 module.exports = validate

package/src/maths/constants.d.ts

@@ -1,2 +1,3 @@
 export const EPS: number
+export const NEPS: number
 export const spatialResolution: number

package/src/maths/constants.js

@@ -14,7 +14,18 @@ const spatialResolution = 1e5
  */
 const EPS = 1e-5
 
+/**
+ * Smaller epsilon used for measuring near zero distances.
+ * @default
+ * @alias module:modeling/maths.NEPS
+ */
+const NEPS = 1e-13
+// NEPS is derived from a series of tests to determine the optimal precision
+// for comparing coplanar polygons, as provided by the sphere primitive at high
+// segmentation. NEPS is for 64 bit Number values.
+
 module.exports = {
   EPS,
+  NEPS,
   spatialResolution
 }

package/src/maths/mat4/isMirroring.js

@@ -1,7 +1,3 @@
-const cross = require('../vec3/cross')
-const dot = require('../vec3/dot')
-const fromValues = require('../vec3/fromValues')
-
 /**
  * Determine whether the given matrix is a mirroring transformation.
  *
@@ -10,15 +6,19 @@ const fromValues = require('../vec3/fromValues')
  * @alias module:modeling/maths/mat4.isMirroring
  */
 const isMirroring = (matrix) => {
-  const u = fromValues(matrix[0], matrix[4], matrix[8])
-  const v = fromValues(matrix[1], matrix[5], matrix[9])
-  const w = fromValues(matrix[2], matrix[6], matrix[10])
+  // const xVector = [matrix[0], matrix[4], matrix[8]]
+  // const yVector = [matrix[1], matrix[5], matrix[9]]
+  // const zVector = [matrix[2], matrix[6], matrix[10]]
 
-  // for a true orthogonal, non-mirrored base, u.cross(v) == w
+  // for a true orthogonal, non-mirrored base, xVector.cross(yVector) == zVector
   // If they have an opposite direction then we are mirroring
-  const mirrorvalue = dot(cross(u, u, v), w)
-  const ismirror = (mirrorvalue < 0)
-  return ismirror
+  // calcuate xVector.cross(yVector)
+  const x = matrix[4] * matrix[9] - matrix[8] * matrix[5]
+  const y = matrix[8] * matrix[1] - matrix[0] * matrix[9]
+  const z = matrix[0] * matrix[5] - matrix[4] * matrix[1]
+  // calcualte dot(cross, zVector)
+  const d = x * matrix[2] + y * matrix[6] + z * matrix[10]
+  return (d < 0)
 }
 
 module.exports = isMirroring

package/src/maths/utils/aboutEqualNormals.js

@@ -1,8 +1,4 @@
-// Normals are directional vectors with component values from 0 to 1.0, requiring specialized comparison
-// This EPS is derived from a series of tests to determine the optimal precision for comparing coplanar polygons,
-// as provided by the sphere primitive at high segmentation
-// This EPS is for 64 bit Number values
-const NEPS = 1e-13
+const { NEPS } = require('../constants')
 
 /**
  * Compare two normals (unit vectors) for near equality.

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

@@ -0,0 +1,69 @@
+const test = require('ava')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const { geom2 } = require('../../geometries')
+
+const { circle, rectangle } = require('../../primitives')
+
+const { intersect } = require('./index')
+
+const { center } = require('../transforms/center')
+
+test('intersect: intersect of one or more geom2 objects produces expected geometry', (t) => {
+  const geometry1 = circle({ radius: 2, segments: 8 })
+
+  // intersect of one object
+  const result1 = intersect(geometry1)
+  let obs = geom2.toPoints(result1)
+  let exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result1))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // intersect of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
+
+  const result2 = intersect(geometry1, geometry2)
+  obs = geom2.toPoints(result2)
+  t.notThrows(() => geom2.validate(result2))
+  t.is(obs.length, 0)
+
+  // intersect of two partially overlapping objects
+  const geometry3 = rectangle({ size: [18, 18] })
+
+  const result3 = intersect(geometry2, geometry3)
+  obs = geom2.toPoints(result3)
+  exp = [
+    [9, 9], [8, 9], [8, 8], [9, 8]
+  ]
+  t.notThrows(() => geom2.validate(result3))
+  t.is(obs.length, 4)
+  t.true(comparePoints(obs, exp))
+
+  // intersect of two completely overlapping objects
+  const result4 = intersect(geometry1, geometry3)
+  obs = geom2.toPoints(result4)
+  exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result4))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+})

package/src/operations/booleans/intersectGeom3.js

@@ -1,6 +1,7 @@
 const flatten = require('../../utils/flatten')
 
-const retessellate = require('./retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const intersectSub = require('./intersectGeom3Sub')
 
 /*

package/src/operations/booleans/{intersect.test.js → intersectGeom3.test.js}

@@ -1,83 +1,15 @@
 const test = require('ava')
 
-const { comparePolygonsAsPoints, comparePoints } = require('../../../test/helpers')
+const { comparePolygonsAsPoints } = require('../../../test/helpers')
 
-const { geom2, geom3 } = require('../../geometries')
+const { geom3 } = require('../../geometries')
 
-const { circle, rectangle, sphere, cuboid } = require('../../primitives')
+const { sphere, cuboid } = require('../../primitives')
 
 const { intersect } = require('./index')
 
 const { center } = require('../transforms/center')
 
-//  test('intersect: intersect of a path produces expected changes to points', (t) => {
-//    let geometry = path.fromPoints({}, [[0, 1, 0], [1, 0, 0]])
-//
-//    geometry = intersect({normal: [1, 0, 0]}, geometry)
-//    let obs = path.toPoints(geometry)
-//    let exp = []
-//
-//    t.deepEqual(obs, exp)
-//  })
-
-test('intersect: intersect of one or more geom2 objects produces expected geometry', (t) => {
-  const geometry1 = circle({ radius: 2, segments: 8 })
-
-  // intersect of one object
-  const result1 = intersect(geometry1)
-  let obs = geom2.toPoints(result1)
-  let exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result1))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-
-  // intersect of two non-overlapping objects
-  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
-
-  const result2 = intersect(geometry1, geometry2)
-  obs = geom2.toPoints(result2)
-  t.notThrows(() => geom2.validate(result2))
-  t.is(obs.length, 0)
-
-  // intersect of two partially overlapping objects
-  const geometry3 = rectangle({ size: [18, 18] })
-
-  const result3 = intersect(geometry2, geometry3)
-  obs = geom2.toPoints(result3)
-  exp = [
-    [9, 9], [8, 9], [8, 8], [9, 8]
-  ]
-  t.notThrows(() => geom2.validate(result3))
-  t.is(obs.length, 4)
-  t.true(comparePoints(obs, exp))
-
-  // intersect of two completely overlapping objects
-  const result4 = intersect(geometry1, geometry3)
-  obs = geom2.toPoints(result4)
-  exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result4))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-})
-
 test('intersect: intersect of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
 

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

@@ -0,0 +1,72 @@
+const test = require('ava')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const { geom2 } = require('../../geometries')
+
+const { circle, rectangle } = require('../../primitives')
+
+const { subtract } = require('./index')
+
+const { center } = require('../transforms/center')
+
+test('subtract: subtract of one or more geom2 objects produces expected geometry', (t) => {
+  const geometry1 = circle({ radius: 2, segments: 8 })
+
+  // subtract of one object
+  const result1 = subtract(geometry1)
+  let obs = geom2.toPoints(result1)
+  let exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result1))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
+
+  const result2 = subtract(geometry1, geometry2)
+  obs = geom2.toPoints(result2)
+  exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result2))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two partially overlapping objects
+  const geometry3 = rectangle({ size: [18, 18] })
+
+  const result3 = subtract(geometry2, geometry3)
+  obs = geom2.toPoints(result3)
+  exp = [
+    [12, 12], [9, 9], [8, 9], [8, 12], [9, 8], [12, 8]
+  ]
+  t.notThrows(() => geom2.validate(result3))
+  t.is(obs.length, 6)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two completely overlapping objects
+  const result4 = subtract(geometry1, geometry3)
+  obs = geom2.toPoints(result4)
+  exp = [
+  ]
+  t.notThrows(() => geom2.validate(result4))
+  t.is(obs.length, 0)
+  t.deepEqual(obs, exp)
+})

package/src/operations/booleans/subtractGeom3.js

@@ -1,6 +1,7 @@
 const flatten = require('../../utils/flatten')
 
-const retessellate = require('./retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const subtractSub = require('./subtractGeom3Sub')
 
 /*