@jscad/modeling 2.12.5 → 3.0.1-alpha.0

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

@@ -0,0 +1,132 @@
+import { NORMAL } from './edgeType.js'
+
+export class SweepEvent {
+  /**
+   * Sweepline event
+   *
+   * @class {SweepEvent}
+   * @param {Array.<Number>} point
+   * @param {boolean} left
+   * @param {SweepEvent=} otherEvent
+   * @param {boolean} isSubject
+   * @param {number} edgeType
+   */
+  constructor (point, left, otherEvent, isSubject, edgeType) {
+    /**
+     * Is left endpoint?
+     * @type {Boolean}
+     */
+    this.left = left
+
+    /**
+     * @type {Array.<Number>}
+     */
+    this.point = point
+
+    /**
+     * Other edge reference
+     * @type {SweepEvent}
+     */
+    this.otherEvent = otherEvent
+
+    /**
+     * Belongs to source or clipping polygon
+     * @type {Boolean}
+     */
+    this.isSubject = isSubject
+
+    /**
+     * Edge contribution type
+     * @type {Number}
+     */
+    this.type = edgeType || NORMAL
+
+    /**
+     * In-out transition for the sweepline crossing polygon
+     * @type {Boolean}
+     */
+    this.inOut = false
+
+    /**
+     * @type {Boolean}
+     */
+    this.otherInOut = false
+
+    /**
+     * Previous event in result?
+     * @type {SweepEvent}
+     */
+    this.prevInResult = null
+
+    /**
+     * Type of result transition (0 = not in result, +1 = out-in, -1, in-out)
+     * @type {Number}
+     */
+    this.resultTransition = 0
+
+    // connection step
+
+    /**
+     * @type {Number}
+     */
+    this.otherPos = -1
+
+    /**
+     * @type {Number}
+     */
+    this.outputContourId = -1
+
+    this.isExteriorRing = true // TODO: Looks unused, remove?
+  }
+
+  /**
+   * @param {Array.<Number>} p
+   * @return {Boolean}
+   */
+  isBelow (p) {
+    const p0 = this.point
+    const p1 = this.otherEvent.point
+    return this.left
+      ? (p0[0] - p[0]) * (p1[1] - p[1]) - (p1[0] - p[0]) * (p0[1] - p[1]) > 0
+      // signedArea(this.point, this.otherEvent.point, p) > 0 :
+      : (p1[0] - p[0]) * (p0[1] - p[1]) - (p0[0] - p[0]) * (p1[1] - p[1]) > 0
+    // signedArea(this.otherEvent.point, this.point, p) > 0
+  }
+
+  /**
+   * @param {Array.<Number>} p
+   * @return {Boolean}
+   */
+  isAbove (p) {
+    return !this.isBelow(p)
+  }
+
+  /**
+   * @return {Boolean}
+   */
+  isVertical () {
+    return this.point[0] === this.otherEvent.point[0]
+  }
+
+  /**
+   * Does event belong to result?
+   * @return {Boolean}
+   */
+  get inResult () {
+    return this.resultTransition !== 0
+  }
+
+  clone () {
+    const copy = new SweepEvent(
+      this.point, this.left, this.otherEvent, this.isSubject, this.type)
+
+    copy.contourId = this.contourId
+    copy.resultTransition = this.resultTransition
+    copy.prevInResult = this.prevInResult
+    copy.isExteriorRing = this.isExteriorRing
+    copy.inOut = this.inOut
+    copy.otherInOut = this.otherInOut
+
+    return copy
+  }
+}

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

@@ -0,0 +1,76 @@
+/*
+ * The smallest and simplest binary heap priority queue in JavaScript
+ * Copyright (c) 2017, Vladimir Agafonkin
+ * https://github.com/mourner/tinyqueue
+ */
+
+export class Queue {
+  constructor (data, compare) {
+    this.data = data
+    this.length = this.data.length
+    this.compare = compare
+
+    if (this.length > 0) {
+      for (let i = (this.length >> 1) - 1; i >= 0; i--) this._down(i)
+    }
+  }
+
+  push (item) {
+    this.data.push(item)
+    this._up(this.length++)
+  }
+
+  pop () {
+    if (this.length === 0) return undefined
+
+    const top = this.data[0]
+    const bottom = this.data.pop()
+
+    if (--this.length > 0) {
+      this.data[0] = bottom
+      this._down(0)
+    }
+
+    return top
+  }
+
+  peek () {
+    return this.data[0]
+  }
+
+  _up (pos) {
+    const { data, compare } = this
+    const item = data[pos]
+
+    while (pos > 0) {
+      const parent = (pos - 1) >> 1
+      const current = data[parent]
+      if (compare(item, current) >= 0) break
+      data[pos] = current
+      pos = parent
+    }
+
+    data[pos] = item
+  }
+
+  _down (pos) {
+    const { data, compare } = this
+    const halfLength = this.length >> 1
+    const item = data[pos]
+
+    while (pos < halfLength) {
+      let bestChild = (pos << 1) + 1 // initially it is the left child
+      const right = bestChild + 1
+
+      if (right < this.length && compare(data[right], data[bestChild]) < 0) {
+        bestChild = right
+      }
+      if (compare(data[bestChild], item) >= 0) break
+
+      data[pos] = data[bestChild]
+      pos = bestChild
+    }
+
+    data[pos] = item
+  }
+}

package/src/operations/booleans/mayOverlap.js

@@ -1,15 +1,15 @@
-const { EPS } = require('../../maths/constants')
+import { EPS } from '../../maths/constants.js'
 
-const measureBoundingBox = require('../../measurements/measureBoundingBox')
+import { measureBoundingBox } from '../../measurements/measureBoundingBox.js'
 
 /*
  * Determine if the given geometries overlap by comparing min and max bounds.
  * NOTE: This is used in union for performance gains.
- * @param {geom3} geometry1 - geometry for comparison
- * @param {geom3} geometry2 - geometry for comparison
+ * @param {Geom3} geometry1 - geometry for comparison
+ * @param {Geom3} geometry2 - geometry for comparison
  * @returns {boolean} true if the geometries overlap
  */
-const mayOverlap = (geometry1, geometry2) => {
+export const mayOverlap = (geometry1, geometry2) => {
   // FIXME accessing the data structure of the geometry should not be allowed
   if ((geometry1.polygons.length === 0) || (geometry2.polygons.length === 0)) {
     return false
@@ -31,5 +31,3 @@ const mayOverlap = (geometry1, geometry2) => {
   if ((min1[2] - max2[2]) > EPS) return false
   return true
 }
-
-module.exports = mayOverlap

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

@@ -1,14 +1,14 @@
-const test = require('ava')
+import test from 'ava'
 
-const { EPS } = require('../../maths/constants')
+import { EPS } from '../../maths/constants.js'
 
-const { geom3 } = require('../../geometries')
+import { geom3 } from '../../geometries/index.js'
 
-const { cuboid } = require('../../primitives')
+import { cuboid } from '../../primitives/index.js'
 
-const mayOverlap = require('./mayOverlap')
+import { center } from '../transforms/index.js'
 
-const { center } = require('../transforms/center')
+import { mayOverlap } from './mayOverlap.js'
 
 test.only('mayOverlap: determination of overlap is reliable', (t) => {
   const geometry1 = center({ relativeTo: [0, 0, 0] }, cuboid({ size: [4, 4, 4] }))

package/src/operations/booleans/scission.d.ts

@@ -1,6 +1,5 @@
-import { Geom2, Geom3 } from '../../geometries/types'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geom3 } from '../../geometries/geom3/type.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
-export default scission
-
-declare function scission(...geometries: RecursiveArray<Geom3>): Geom3[]
+export function scission(...geometries: RecursiveArray<Geom3>): Geom3
+export function scission(...geometries: RecursiveArray<Geom3>): Array<Geom3>

package/src/operations/booleans/scission.js

@@ -1,10 +1,6 @@
-const flatten = require('../../utils/flatten')
+import * as geom3 from '../../geometries/geom3/index.js'
 
-// const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-
-// const scissionGeom2 = require('./scissionGeom2')
-const scissionGeom3 = require('./scissionGeom3')
+import { scissionGeom3 } from './scissionGeom3.js'
 
 /**
  * Scission (divide) the given geometry into the component pieces.
@@ -16,7 +12,7 @@ const scissionGeom3 = require('./scissionGeom3')
  * @alias module:modeling/booleans.scission
  *
  * @example
- * let figure = require('./my.stl')
+ * let figure = use('./my.stl')
  * let pieces = scission(figure)
  *
  * @example
@@ -29,17 +25,13 @@ const scissionGeom3 = require('./scissionGeom3')
  *      |       |            |    B  |
  *      +-------+            +-------+
  */
-const scission = (...objects) => {
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
+export const scission = (...objects) => {
   const results = objects.map((object) => {
     // if (path2.isA(object)) return path2.transform(matrix, object)
     // if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return scissionGeom3(object)
+    if (Array.isArray(object)) return scission(...object)
     return object
   })
   return results.length === 1 ? results[0] : results
 }
-
-module.exports = scission

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

@@ -1,10 +1,12 @@
-const test = require('ava')
+import test from 'ava'
 
-const { geom3 } = require('../../geometries')
+import { geom3 } from '../../geometries/index.js'
 
-const { cube, torus } = require('../../primitives')
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
-const { scission, union } = require('./index')
+import { cube, torus } from '../../primitives/index.js'
+
+import { scission, union } from './index.js'
 
 test('scission: scission of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = geom3.create()
@@ -42,6 +44,10 @@ test('scission: scission of complex geom3 produces expected geometry', (t) => {
   t.is(result1.length, 2)
   t.notThrows.skip(() => geom3.validate(result1[0]))
   t.notThrows.skip(() => geom3.validate(result1[1]))
+  t.is(measureArea(result1[0]), 7720.0306508548)
+  t.is(measureArea(result1[1]), 3860.0153254273987)
+  t.is(measureVolume(result1[0]), 18745.166004060953)
+  t.is(measureVolume(result1[1]), 9372.583002030477)
 
   const rc1 = geom3.toPolygons(result1[0]).length
   const rc2 = geom3.toPolygons(result1[1]).length

package/src/operations/booleans/scissionGeom3.js

@@ -1,13 +1,14 @@
-const vec3 = require('../../maths/vec3')
-const measureEpsilon = require('../../measurements/measureEpsilon')
+import * as vec3 from '../../maths/vec3/index.js'
 
-const geom3 = require('../../geometries/geom3')
+import { measureEpsilon } from '../../measurements/measureEpsilon.js'
+
+import * as geom3 from '../../geometries/geom3/index.js'
 
 // returns array numerically sorted and duplicates removed
 const sortNb = (array) => array.sort((a, b) => a - b).filter((item, pos, ary) => !pos || item !== ary[pos - 1])
 
-const insertMapping = (map, point, index) => {
-  const key = `${point}`
+const insertMapping = (map, vertex, index) => {
+  const key = `${vertex}`
   const mapping = map.get(key)
   if (mapping === undefined) {
     map.set(key, [index])
@@ -16,35 +17,35 @@ const insertMapping = (map, point, index) => {
   }
 }
 
-const findMapping = (map, point) => {
-  const key = `${point}`
+const findMapping = (map, vertex) => {
+  const key = `${vertex}`
   return map.get(key)
 }
 
-const scissionGeom3 = (geometry) => {
+export const scissionGeom3 = (geometry) => {
   // construit table de correspondance entre polygones
   // build polygons lookup table
   const eps = measureEpsilon(geometry)
   const polygons = geom3.toPolygons(geometry)
   const pl = polygons.length
 
-  const indexesPerPoint = new Map()
+  const indexesPerVertex = new Map()
   const temp = vec3.create()
   polygons.forEach((polygon, index) => {
-    polygon.vertices.forEach((point) => {
-      insertMapping(indexesPerPoint, vec3.snap(temp, point, eps), index)
+    polygon.vertices.forEach((vertex) => {
+      insertMapping(indexesPerVertex, vec3.snap(temp, vertex, eps), index)
     })
   })
 
   const indexesPerPolygon = polygons.map((polygon) => {
     let indexes = []
-    polygon.vertices.forEach((point) => {
-      indexes = indexes.concat(findMapping(indexesPerPoint, vec3.snap(temp, point, eps)))
+    polygon.vertices.forEach((vertex) => {
+      indexes = indexes.concat(findMapping(indexesPerVertex, vec3.snap(temp, vertex, eps)))
     })
     return { e: 1, d: sortNb(indexes) } // for each polygon, push the list of indexes
   })
 
-  indexesPerPoint.clear()
+  indexesPerVertex.clear()
 
   // regroupe les correspondances des polygones se touchant
   // boucle ne s'arrêtant que quand deux passages retournent le même nb de polygones
@@ -89,5 +90,3 @@ const scissionGeom3 = (geometry) => {
 
   return newgeometries
 }
-
-module.exports = scissionGeom3

package/src/operations/booleans/subtract.d.ts

@@ -1,7 +1,6 @@
-import { Geom2, Geom3 } from '../../geometries/types'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geom2 } from '../../geometries/geom2/type.d.ts'
+import type { Geom3 } from '../../geometries/geom3/type.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
-export default subtract
-
-declare function subtract(...geometries: RecursiveArray<Geom2>): Geom2
-declare function subtract(...geometries: RecursiveArray<Geom3>): Geom3
+export function subtract(...geometries: RecursiveArray<Geom2>): Geom2
+export function subtract(...geometries: RecursiveArray<Geom3>): Geom3

package/src/operations/booleans/subtract.js

@@ -1,11 +1,11 @@
-const flatten = require('../../utils/flatten')
-const areAllShapesTheSameType = require('../../utils/areAllShapesTheSameType')
+import { areAllShapesTheSameType } from '../../utils/areAllShapesTheSameType.js'
+import { coalesce } from '../../utils/coalesce.js'
 
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
 
-const subtractGeom2 = require('./subtractGeom2')
-const subtractGeom3 = require('./subtractGeom3')
+import { subtractGeom2 } from './subtractGeom2.js'
+import { subtractGeom3 } from './subtractGeom3.js'
 
 /**
  * Return a new geometry representing space in the first geometry but
@@ -13,7 +13,7 @@ const subtractGeom3 = require('./subtractGeom3')
  * The given geometries should be of the same type, either geom2 or geom3.
  *
  * @param {...Object} geometries - list of geometries
- * @returns {geom2|geom3} a new geometry
+ * @returns {Geom2|Geom3} a new geometry
  * @alias module:modeling/booleans.subtract
  *
  * @example
@@ -29,19 +29,17 @@ const subtractGeom3 = require('./subtractGeom3')
  *      |       |
  *      +-------+
  */
-const subtract = (...geometries) => {
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
+export const subtract = (...geometries) => {
+  geometries = coalesce(geometries)
 
+  if (geometries.length === 0) return undefined
   if (!areAllShapesTheSameType(geometries)) {
-    throw new Error('only subtract of the types are supported')
+    throw new Error('subtract arguments must be the same geometry type')
   }
 
   const geometry = geometries[0]
-  // if (path.isA(geometry)) return pathsubtract(matrix, geometries)
+  // if (path.isA(geometry)) return subtractPath(matrix, geometries)
   if (geom2.isA(geometry)) return subtractGeom2(geometries)
   if (geom3.isA(geometry)) return subtractGeom3(geometries)
-  return geometry
+  throw new Error('subtract unsupported geometry type')
 }
-
-module.exports = subtract

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

@@ -0,0 +1,24 @@
+import test from 'ava'
+
+import { geom2, geom3 } from '../../geometries/index.js'
+
+import { subtract } from './index.js'
+
+test('subtract empty arguments', (t) => {
+  t.is(subtract(), undefined)
+  t.is(subtract([]), undefined)
+  t.is(subtract([[], []]), undefined)
+  t.is(subtract(null, null), undefined)
+})
+
+test('subtract error different geometry types', (t) => {
+  const message = 'subtract arguments must be the same geometry type'
+  t.throws(() => subtract(geom2.create(), geom3.create()), { message })
+})
+
+test('subtract error non-geometries', (t) => {
+  const message = 'subtract unsupported geometry type'
+  t.throws(() => subtract([1, 2, 3], [4, 5, 6]), { message })
+  t.throws(() => subtract([], [123]), { message })
+  t.throws(() => subtract('one', 'two'), { message })
+})

package/src/operations/booleans/subtractGeom2.js

@@ -1,27 +1,17 @@
-const flatten = require('../../utils/flatten')
-
-const geom3 = require('../../geometries/geom3')
-
-const measureEpsilon = require('../../measurements/measureEpsilon')
-
-const fromFakePolygons = require('./fromFakePolygons')
-const to3DWalls = require('./to3DWalls')
-const subtractGeom3 = require('./subtractGeom3')
+import { DIFFERENCE } from './martinez/operation.js'
+import { boolean } from './martinez/index.js'
 
 /*
  * Return a new 2D geometry representing space in the first geometry but
  * not in the subsequent geometries. None of the given geometries are modified.
- * @param {...geom2} geometries - list of geometries
- * @returns {geom2} new 2D geometry
+ * @param {Geom2[]} geometries - a flat list of 2D geometries
+ * @returns {Geom2} new 2D geometry
  */
-const subtract = (...geometries) => {
-  geometries = flatten(geometries)
-  const newgeometries = geometries.map((geometry) => to3DWalls({ z0: -1, z1: 1 }, geometry))
+export const subtractGeom2 = (geometries) => {
+  let newGeometry = geometries.shift()
+  geometries.forEach((geometry) => {
+    newGeometry = boolean(newGeometry, geometry, DIFFERENCE)
+  })
 
-  const newgeom3 = subtractGeom3(newgeometries)
-  const epsilon = measureEpsilon(newgeom3)
-
-  return fromFakePolygons(epsilon, geom3.toPolygons(newgeom3))
+  return newGeometry
 }
-
-module.exports = subtract

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

@@ -1,14 +1,16 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePoints } = require('../../../test/helpers')
+import { comparePoints } from '../../../test/helpers/index.js'
 
-const { geom2 } = require('../../geometries')
+import { geom2 } from '../../geometries/index.js'
 
-const { circle, rectangle } = require('../../primitives')
+import { measureArea } from '../../measurements/index.js'
 
-const { subtract } = require('./index')
+import { circle, rectangle, square } from '../../primitives/index.js'
 
-const { center } = require('../transforms/center')
+import { center } from '../transforms/index.js'
+
+import { subtract } from './index.js'
 
 test('subtract: subtract of one or more geom2 objects produces expected geometry', (t) => {
   const geometry1 = circle({ radius: 2, segments: 8 })
@@ -18,15 +20,16 @@ test('subtract: subtract of one or more geom2 objects produces expected geometry
   let obs = geom2.toPoints(result1)
   let exp = [
     [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
+    [1.4142135623730951, 1.414213562373095],
     [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
+    [-1.414213562373095, 1.4142135623730951],
     [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
+    [-1.4142135623730954, -1.414213562373095],
     [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
+    [1.4142135623730947, -1.4142135623730954]
   ]
   t.notThrows(() => geom2.validate(result1))
+  t.is(measureArea(result1), 11.31370849898476)
   t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 
@@ -37,15 +40,16 @@ test('subtract: subtract of one or more geom2 objects produces expected geometry
   obs = geom2.toPoints(result2)
   exp = [
     [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
+    [1.4142135623730951, 1.414213562373095],
     [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
+    [-1.414213562373095, 1.4142135623730951],
     [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
+    [-1.4142135623730954, -1.414213562373095],
     [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
+    [1.4142135623730947, -1.4142135623730954]
   ]
   t.notThrows(() => geom2.validate(result2))
+  t.is(measureArea(result2), 11.31370849898476)
   t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 
@@ -55,18 +59,43 @@ test('subtract: subtract of one or more geom2 objects produces expected geometry
   const result3 = subtract(geometry2, geometry3)
   obs = geom2.toPoints(result3)
   exp = [
-    [12, 12], [9, 9], [8, 9], [8, 12], [9, 8], [12, 8]
+    [8, 9], [9, 9], [9, 8], [12, 8], [12, 12], [8, 12]
   ]
   t.notThrows(() => geom2.validate(result3))
+  t.is(measureArea(result3), 15)
   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 = [
-  ]
+  exp = []
   t.notThrows(() => geom2.validate(result4))
+  t.is(measureArea(result4), 0)
   t.is(obs.length, 0)
   t.deepEqual(obs, exp)
 })
+
+test('subtract with undefined/null values', (t) => {
+  const square1 = square({ size: 8 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 4 })
+  const geometries = [square1, undefined, square2, null, square3]
+
+  const obs = subtract(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 8)
+})
+
+test('subtract of nested arrays', (t) => {
+  const square1 = square({ size: 8 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 4 })
+  const geometries = [square1, [square2, [square3]]]
+
+  const obs = subtract(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 8)
+})