@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/operations/booleans/intersectGeom3.js

@@ -1,25 +1,23 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const retessellate = require('../modifiers/retessellate')
+import { retessellate } from '../modifiers/retessellate.js'
 
-const intersectSub = require('./intersectGeom3Sub')
+import { intersectGeom3Sub } from './intersectGeom3Sub.js'
 
 /*
  * Return a new 3D geometry representing space in both the first geometry and
  * in the subsequent geometries. None of the given geometries are modified.
  * @param {...geom3} geometries - list of 3D geometries
- * @returns {geom3} new 3D geometry
+ * @returns {Geom3} new 3D geometry
  */
-const intersect = (...geometries) => {
+export const intersectGeom3 = (...geometries) => {
   geometries = flatten(geometries)
 
-  let newgeometry = geometries.shift()
+  let newGeometry = geometries.shift()
   geometries.forEach((geometry) => {
-    newgeometry = intersectSub(newgeometry, geometry)
+    newGeometry = intersectGeom3Sub(newGeometry, geometry)
   })
 
-  newgeometry = retessellate(newgeometry)
-  return newgeometry
+  newGeometry = retessellate(newGeometry)
+  return newGeometry
 }
-
-module.exports = intersect

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

@@ -1,14 +1,16 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePolygonsAsPoints } = require('../../../test/helpers')
+import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
-const { geom3 } = require('../../geometries')
+import { geom3 } from '../../geometries/index.js'
 
-const { sphere, cuboid } = require('../../primitives')
+import { measureVolume } from '../../measurements/index.js'
 
-const { intersect } = require('./index')
+import { sphere, cuboid } from '../../primitives/index.js'
 
-const { center } = require('../transforms/center')
+import { intersect } from './index.js'
+
+import { center } from '../transforms/index.js'
 
 test('intersect: intersect of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
@@ -67,6 +69,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
     [[8.65956056235493e-17, 8.659560562354935e-17, 2], [1.4142135623730951, 3.4638242249419736e-16, 1.414213562373095], [0.9999999999999998, 1.0000000000000002, 1.414213562373095]]
   ]
   t.notThrows.skip(() => geom3.validate(result1))
+  t.is(measureVolume(result1), 25.751611331979678)
   t.is(obs.length, 32)
   t.true(comparePolygonsAsPoints(obs, exp))
 
@@ -76,6 +79,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   const result2 = intersect(geometry1, geometry2)
   obs = geom3.toPoints(result2)
   t.notThrows(() => geom3.validate(result2))
+  t.is(measureVolume(result2), 0)
   t.is(obs.length, 0)
 
   // intersect of two partially overlapping objects
@@ -84,17 +88,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   const result3 = intersect(geometry2, geometry3)
   obs = geom3.toPoints(result3)
 
-  // the order changes based on the bestplane chosen in Node.js
-  /*
-  exp = [
-    [[9, 9, 8], [9, 9, 9], [9, 8, 9], [9, 8, 8]],
-    [[8, 9, 9], [9, 9, 9], [9, 9, 8], [8, 9, 8]],
-    [[9, 8, 9], [9, 9, 9], [8, 9, 9], [8, 8, 9]],
-    [[8, 9, 9], [8, 9, 8], [8, 8, 8], [8, 8, 9]],
-    [[8, 8, 9], [8, 8, 8], [9, 8, 8], [9, 8, 9]],
-    [[9, 9, 8], [9, 8, 8], [8, 8, 8], [8, 9, 8]]
-  ]
-*/
+  // the order changes based on the best plane chosen in Node.js
   exp = [
     [[9, 9, 8], [9, 9, 9], [9, 8, 9], [9, 8, 8]],
     [[8, 9, 9], [9, 9, 9], [9, 9, 8], [8, 9, 8]],
@@ -105,6 +99,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   ]
 
   t.notThrows(() => geom3.validate(result3))
+  t.is(measureVolume(result3), 1.0000000000000009)
   t.is(obs.length, 6)
   t.true(comparePolygonsAsPoints(obs, exp))
 
@@ -112,5 +107,6 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   const result4 = intersect(geometry1, geometry3)
   obs = geom3.toPoints(result4)
   t.notThrows.skip(() => geom3.validate(result4))
+  t.is(measureVolume(result4), 25.751611331979678)
   t.is(obs.length, 32)
 })

package/src/operations/booleans/intersectGeom3Sub.js

@@ -1,16 +1,17 @@
-const geom3 = require('../../geometries/geom3')
+import * as geom3 from '../../geometries/geom3/index.js'
 
-const mayOverlap = require('./mayOverlap')
-const { Tree } = require('./trees')
+import { Tree } from './trees/index.js'
+
+import { mayOverlap } from './mayOverlap.js'
 
 /*
  * Return a new 3D geometry representing the space in both the first geometry and
  * the second geometry. None of the given geometries are modified.
- * @param {geom3} geometry1 - a geometry
- * @param {geom3} geometry2 - a geometry
- * @returns {geom3} new 3D geometry
+ * @param {Geom3} geometry1 - a geometry
+ * @param {Geom3} geometry2 - a geometry
+ * @returns {Geom3} new 3D geometry
  */
-const intersectGeom3Sub = (geometry1, geometry2) => {
+export const intersectGeom3Sub = (geometry1, geometry2) => {
   if (!mayOverlap(geometry1, geometry2)) {
     return geom3.create() // empty geometry
   }
@@ -26,8 +27,6 @@ const intersectGeom3Sub = (geometry1, geometry2) => {
   a.addPolygons(b.allPolygons())
   a.invert()
 
-  const newpolygons = a.allPolygons()
-  return geom3.create(newpolygons)
+  const newPolygons = a.allPolygons()
+  return geom3.create(newPolygons)
 }
-
-module.exports = intersectGeom3Sub

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

@@ -0,0 +1,45 @@
+/*
+ * Implementation of the Martinez 2D polygon clipping algorithm
+ * Copyright (c) 2018 Alexander Milevski
+ * https://github.com/w8r/martinez
+ */
+
+import { signedArea } from './signedArea.js'
+
+/**
+ * @param {SweepEvent} e1
+ * @param {SweepEvent} e2
+ * @return {number}
+ */
+export const compareEvents = (e1, e2) => {
+  const p1 = e1.point
+  const p2 = e2.point
+
+  // Different x-coordinate
+  if (p1[0] > p2[0]) return 1
+  if (p1[0] < p2[0]) return -1
+
+  // Different points, but same x-coordinate
+  // 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
+    return (!e1.isBelow(e2.otherEvent.point)) ? 1 : -1
+  }
+
+  return (!e1.isSubject && e2.isSubject) ? 1 : -1
+}

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

@@ -0,0 +1,51 @@
+/*
+ * Implementation of the Martinez 2D polygon clipping algorithm
+ * Copyright (c) 2018 Alexander Milevski
+ * https://github.com/w8r/martinez
+ */
+
+import { equals } from '../../../maths/vec2/index.js'
+import { compareEvents } from './compareEvents.js'
+import { signedArea } from './signedArea.js'
+
+/**
+ * @param {SweepEvent} le1
+ * @param {SweepEvent} le2
+ * @return {number}
+ */
+export const compareSegments = (le1, le2) => {
+  if (le1 === le2) return 0
+
+  // Segments are not collinear
+  if (signedArea(le1.point, le1.otherEvent.point, le2.point) !== 0 ||
+    signedArea(le1.point, le1.otherEvent.point, le2.otherEvent.point) !== 0) {
+    // If they share their left endpoint use the right endpoint to sort
+    if (equals(le1.point, le2.point)) return le1.isBelow(le2.otherEvent.point) ? -1 : 1
+
+    // Different left endpoint: use the left endpoint to sort
+    if (le1.point[0] === le2.point[0]) return le1.point[1] < le2.point[1] ? -1 : 1
+
+    // has the line segment associated to e1 been inserted
+    // into S after the line segment associated to e2 ?
+    if (compareEvents(le1, le2) === 1) return le2.isAbove(le1.point) ? -1 : 1
+
+    // The line segment associated to e2 has been inserted
+    // into S after the line segment associated to e1
+    return le1.isBelow(le2.point) ? -1 : 1
+  }
+
+  if (le1.isSubject === le2.isSubject) { // same polygon
+    let p1 = le1.point
+    let p2 = le2.point
+    if (p1[0] === p2[0] && p1[1] === p2[1]/* equals(le1.point, le2.point) */) {
+      p1 = le1.otherEvent.point
+      p2 = le2.otherEvent.point
+      if (p1[0] === p2[0] && p1[1] === p2[1]) return 0
+      else return le1.contourId > le2.contourId ? 1 : -1
+    }
+  } else { // Segments are collinear, but belong to separate polygons
+    return le1.isSubject ? -1 : 1
+  }
+
+  return compareEvents(le1, le2) === 1 ? 1 : -1
+}

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

@@ -0,0 +1,109 @@
+/*
+ * Implementation of the Martinez 2D polygon clipping algorithm
+ * Copyright (c) 2018 Alexander Milevski
+ * https://github.com/w8r/martinez
+ */
+
+import {
+  NORMAL,
+  SAME_TRANSITION,
+  DIFFERENT_TRANSITION,
+  NON_CONTRIBUTING
+} from './edgeType.js'
+import {
+  INTERSECTION,
+  UNION,
+  DIFFERENCE,
+  XOR
+} from './operation.js'
+
+/**
+ * @param {SweepEvent} event
+ * @param {SweepEvent} prev
+ * @param {Operation} operation
+ */
+export const computeFields = (event, prev, operation) => {
+  // compute inOut and otherInOut fields
+  if (prev === null) {
+    event.inOut = false
+    event.otherInOut = true
+
+  // previous line segment in sweepline belongs to the same polygon
+  } else {
+    if (event.isSubject === prev.isSubject) {
+      event.inOut = !prev.inOut
+      event.otherInOut = prev.otherInOut
+
+    // previous line segment in sweepline belongs to the clipping polygon
+    } else {
+      event.inOut = !prev.otherInOut
+      event.otherInOut = prev.isVertical() ? !prev.inOut : prev.inOut
+    }
+
+    // compute prevInResult field
+    if (prev) {
+      event.prevInResult = (!inResult(prev, operation) || prev.isVertical()) ? prev.prevInResult : prev
+    }
+  }
+
+  // check if the line segment belongs to the Boolean operation
+  const isInResult = inResult(event, operation)
+  if (isInResult) {
+    event.resultTransition = determineResultTransition(event, operation)
+  } else {
+    event.resultTransition = 0
+  }
+}
+
+const inResult = (event, operation) => {
+  switch (event.type) {
+    case NORMAL:
+      switch (operation) {
+        case INTERSECTION:
+          return !event.otherInOut
+        case UNION:
+          return event.otherInOut
+        case DIFFERENCE:
+          // return (event.isSubject && !event.otherInOut) ||
+          //         (!event.isSubject && event.otherInOut)
+          return (event.isSubject && event.otherInOut) ||
+                  (!event.isSubject && !event.otherInOut)
+        case XOR:
+          return true
+      }
+      break
+    case SAME_TRANSITION:
+      return operation === INTERSECTION || operation === UNION
+    case DIFFERENT_TRANSITION:
+      return operation === DIFFERENCE
+    case NON_CONTRIBUTING:
+      return false
+  }
+  return false
+}
+
+const determineResultTransition = (event, operation) => {
+  const thisIn = !event.inOut
+  const thatIn = !event.otherInOut
+
+  let isIn
+  switch (operation) {
+    case INTERSECTION:
+      isIn = thisIn && thatIn
+      break
+    case UNION:
+      isIn = thisIn || thatIn
+      break
+    case XOR:
+      isIn = thisIn ^ thatIn
+      break
+    case DIFFERENCE:
+      if (event.isSubject) {
+        isIn = thisIn && !thatIn
+      } else {
+        isIn = thatIn && !thisIn
+      }
+      break
+  }
+  return isIn ? +1 : -1
+}

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

@@ -0,0 +1,189 @@
+/*
+ * Implementation of the Martinez 2D polygon clipping algorithm
+ * Copyright (c) 2018 Alexander Milevski
+ * https://github.com/w8r/martinez
+ */
+
+import { compareEvents } from './compareEvents.js'
+import { Contour } from './contour.js'
+
+/**
+ * @param {SweepEvent[]} sortedEvents
+ * @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)
+    }
+  }
+  // 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++) {
+      if ((i + 1) < len &&
+        compareEvents(resultEvents[i], resultEvents[i + 1]) === 1) {
+        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
+  }
+
+  // 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
+    }
+  }
+
+  return resultEvents
+}
+
+/**
+ * @param {number} pos
+ * @param {SweepEvent[]} resultEvents
+ * @param {object} processed
+ * @return {number}
+ */
+const nextPos = (pos, resultEvents, processed, origPos) => {
+  let newPos = pos + 1
+  const p = resultEvents[pos].point
+  let p1
+  const length = resultEvents.length
+
+  if (newPos < length) { p1 = resultEvents[newPos].point }
+
+  while (newPos < length && p1[0] === p[0] && p1[1] === p[1]) {
+    if (!processed[newPos]) {
+      return newPos
+    } else {
+      newPos++
+    }
+    if (newPos < length) {
+      p1 = resultEvents[newPos].point
+    }
+  }
+
+  newPos = pos - 1
+
+  while (processed[newPos] && newPos > origPos) {
+    newPos--
+  }
+
+  return newPos
+}
+
+const initializeContourFromContext = (event, contours, contourId) => {
+  const contour = new Contour()
+  if (event.prevInResult != null) {
+    const prevInResult = event.prevInResult
+    // Note that it is valid to query the "previous in result" for its output contour id,
+    // because we must have already processed it (i.e., assigned an output contour id)
+    // in an earlier iteration, otherwise it wouldn't be possible that it is "previous in
+    // result".
+    const lowerContourId = prevInResult.outputContourId
+    const lowerResultTransition = prevInResult.resultTransition
+    if (lowerContourId < 0) {
+      contour.holeOf = null
+      contour.depth = 0
+    } else if (lowerResultTransition > 0) {
+      // We are inside. Now we have to check if the thing below us is another hole or
+      // an exterior contour.
+      const lowerContour = contours[lowerContourId]
+      if (lowerContour.holeOf != null) {
+        // The lower contour is a hole => Connect the new contour as a hole to its parent,
+        // and use same depth.
+        const parentContourId = lowerContour.holeOf
+        contours[parentContourId].holeIds.push(contourId)
+        contour.holeOf = parentContourId
+        contour.depth = contours[lowerContourId].depth
+      } else {
+        // The lower contour is an exterior contour => Connect the new contour as a hole,
+        // and increment depth.
+        contours[lowerContourId].holeIds.push(contourId)
+        contour.holeOf = lowerContourId
+        contour.depth = contours[lowerContourId].depth + 1
+      }
+    } 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
+ */
+export const connectEdges = (sortedEvents) => {
+  const resultEvents = orderEvents(sortedEvents)
+  const len = resultEvents.length
+
+  // "false"-filled array
+  const processed = {}
+  const contours = []
+
+  for (let i = 0; i < len; i++) {
+    if (processed[i]) {
+      continue
+    }
+
+    const contourId = contours.length
+    const contour = initializeContourFromContext(resultEvents[i], contours, contourId)
+
+    // 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]) {
+        resultEvents[pos].outputContourId = contourId
+      }
+    }
+
+    let pos = i
+    const origPos = i
+
+    const initial = resultEvents[i].point
+    contour.points.push(initial)
+
+    while (true) {
+      markAsProcessed(pos)
+
+      pos = resultEvents[pos].otherPos
+
+      markAsProcessed(pos)
+      contour.points.push(resultEvents[pos].point)
+
+      pos = nextPos(pos, resultEvents, processed, origPos)
+
+      if (pos === origPos || pos >= resultEvents.length || !resultEvents[pos]) {
+        break
+      }
+    }
+
+    contours.push(contour)
+  }
+
+  return contours
+}

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

@@ -0,0 +1,12 @@
+export class Contour {
+  constructor () {
+    this.points = []
+    this.holeIds = []
+    this.holeOf = null
+    this.depth = null
+  }
+
+  isExterior () {
+    return this.holeOf == null
+  }
+}

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

@@ -0,0 +1,32 @@
+import { SweepEvent } from './sweepEvent.js'
+import { compareEvents } from './compareEvents.js'
+
+/**
+ * @param {SweepEvent} se
+ * @param {Array.<Number>} p
+ * @param {Queue} queue
+ * @return {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)
+
+  r.contourId = l.contourId = se.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
+    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
+
+  queue.push(l)
+  queue.push(r)
+
+  return queue
+}

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

@@ -0,0 +1,4 @@
+export const NORMAL = 0
+export const NON_CONTRIBUTING = 1
+export const SAME_TRANSITION = 2
+export const DIFFERENT_TRANSITION = 3

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

@@ -0,0 +1,80 @@
+/*
+ * Implementation of the Martinez 2D polygon clipping algorithm
+ * Copyright (c) 2018 Alexander Milevski
+ * https://github.com/w8r/martinez
+ */
+
+import { compareEvents } from './compareEvents.js'
+import { DIFFERENCE } from './operation.js'
+import { SweepEvent } from './sweepEvent.js'
+import { Queue } from './tinyqueue.js'
+
+const max = Math.max
+const min = Math.min
+
+let contourId = 0
+
+const processPolygon = (contourOrHole, isSubject, depth, 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)
+    e1.otherEvent = e2
+
+    if (s1[0] === s2[0] && s1[1] === s2[1]) {
+      continue // skip collapsed edges, or it breaks
+    }
+
+    e1.contourId = e2.contourId = depth
+    if (!isExteriorRing) {
+      e1.isExteriorRing = false
+      e2.isExteriorRing = false
+    }
+    if (compareEvents(e1, e2) > 0) {
+      e2.left = true
+    } else {
+      e1.left = true
+    }
+
+    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)
+
+    // Pushing it so the queue is sorted from left to right,
+    // with object on the left having the highest priority.
+    queue.push(e1)
+    queue.push(e2)
+  }
+}
+
+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 (i = 0, ii = clipping.length; i < ii; i++) {
+    polygonSet = clipping[i]
+    for (j = 0, jj = polygonSet.length; j < jj; j++) {
+      isExteriorRing = j === 0
+      if (operation === DIFFERENCE) isExteriorRing = false
+      if (isExteriorRing) contourId++
+      processPolygon(polygonSet[j], false, contourId, eventQueue, cbbox, isExteriorRing)
+    }
+  }
+
+  return eventQueue
+}