@jscad/modeling 2.12.0 → 3.0.0-alpha.0

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
+}

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

@@ -0,0 +1,154 @@
+/*
+ * Implementation of the Martinez 2D polygon clipping algorithm.
+ * Copyright (c) 2018 Alexander Milevski
+ * https://github.com/w8r/martinez
+ *
+ * Adapted for JSCAD by @platypii
+ */
+
+import { subdivideSegments } from './subdivideSegments.js'
+import { connectEdges } from './connectEdges.js'
+import { fillQueue } from './fillQueue.js'
+import {
+  INTERSECTION,
+  DIFFERENCE,
+  UNION,
+  XOR
+} from './operation.js'
+import * as geom2 from '../../../geometries/geom2/index.js'
+import * as vec2 from '../../../maths/vec2/index.js'
+
+const EMPTY = []
+
+/*
+ * Fast path for trivial operations like intersection with empty geometry
+ * Returns null if operation is non-trivial
+ */
+const trivialOperation = (subject, clipping, operation) => {
+  let result = null
+  if (subject.length * clipping.length === 0) {
+    if (operation === INTERSECTION) {
+      return EMPTY
+    } else if (operation === DIFFERENCE) {
+      result = subject
+    } else if (operation === UNION ||
+               operation === XOR) {
+      result = (subject.length === 0) ? clipping : subject
+    }
+  }
+  if (result === EMPTY) {
+    return geom2.create()
+  } else if (result) {
+    return fromOutlines(result.flat())
+  } else {
+    return null
+  }
+}
+
+/*
+ * Fast path for non-intersecting subjects
+ * Returns null if operation is non-trivial
+ */
+const compareBBoxes = (subject, clipping, sbbox, cbbox, operation) => {
+  let result = null
+  if (sbbox[0] > cbbox[2] ||
+      cbbox[0] > sbbox[2] ||
+      sbbox[1] > cbbox[3] ||
+      cbbox[1] > sbbox[3]) {
+    if (operation === INTERSECTION) {
+      result = EMPTY
+    } else if (operation === DIFFERENCE) {
+      result = subject
+    } else if (operation === UNION ||
+               operation === XOR) {
+      result = subject.concat(clipping)
+    }
+  }
+  if (result === EMPTY) {
+    return geom2.create()
+  } else if (result) {
+    return fromOutlines(result.flat())
+  } else {
+    return null
+  }
+}
+
+/*
+ * Convert from geom2 to martinez data structure
+ */
+const toMartinez = (geometry) => {
+  const outlines = []
+  geom2.toOutlines(geometry).forEach((outline) => {
+    // Martinez expects first point == last point
+    if (vec2.equals(outline[0], outline[outline.length - 1])) {
+      outlines.push(outline)
+    } else {
+      outlines.push([...outline, outline[0]])
+    }
+  })
+  return [outlines]
+}
+
+/*
+ * Convert martinez data structure to geom2
+ */
+const fromOutlines = (outlines) => {
+  outlines.forEach((outline) => {
+    if (vec2.equals(outline[0], outline[outline.length - 1])) {
+      outline.pop() // first == last point
+    }
+  })
+  // Martinez sometime returns empty outlines, filter them out
+  outlines = outlines.filter((o) => o.length >= 3)
+  return geom2.create(outlines)
+}
+
+export const boolean = (subjectGeom, clippingGeom, operation) => {
+  // Convert from geom2 to outlines
+  const subject = toMartinez(subjectGeom)
+  const clipping = toMartinez(clippingGeom)
+
+  let trivial = trivialOperation(subject, clipping, operation)
+  if (trivial) {
+    return trivial
+  }
+  const sbbox = [Infinity, Infinity, -Infinity, -Infinity]
+  const cbbox = [Infinity, Infinity, -Infinity, -Infinity]
+
+  const eventQueue = fillQueue(subject, clipping, sbbox, cbbox, operation)
+
+  trivial = compareBBoxes(subject, clipping, sbbox, cbbox, operation)
+  if (trivial) {
+    return trivial
+  }
+  const sortedEvents = subdivideSegments(eventQueue, subject, clipping, sbbox, cbbox, operation)
+
+  const contours = connectEdges(sortedEvents, operation)
+
+  // Convert contours to geom2
+  const polygons = []
+  for (let i = 0; i < contours.length; i++) {
+    const contour = contours[i]
+    if (contour.isExterior()) {
+      // The exterior ring goes first
+      const rings = [contour.points]
+      // Followed by holes if any
+      for (let j = 0; j < contour.holeIds.length; j++) {
+        const holeId = contour.holeIds[j]
+        const holePoints = contours[holeId].points
+        const hole = []
+        for (let k = holePoints.length - 2; k >= 0; k--) {
+          hole.push(holePoints[k])
+        }
+        rings.push(hole)
+      }
+      polygons.push(rings)
+    }
+  }
+
+  if (polygons) {
+    return fromOutlines(polygons.flat())
+  } else {
+    return geom2.create()
+  }
+}

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

@@ -0,0 +1,4 @@
+export const INTERSECTION = 0
+export const UNION = 1
+export const DIFFERENCE = 2
+export const XOR = 3

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

@@ -0,0 +1,113 @@
+/*
+ * 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 { divideSegment } from './divideSegment.js'
+import { segmentIntersection } from './segmentIntersection.js'
+import { compareEvents } from './compareEvents.js'
+import {
+  NON_CONTRIBUTING,
+  SAME_TRANSITION,
+  DIFFERENT_TRANSITION
+} from './edgeType.js'
+
+/**
+ * @param {SweepEvent} se1
+ * @param {SweepEvent} se2
+ * @param {Queue} queue
+ * @return {number}
+ */
+export const possibleIntersection = (se1, se2, queue) => {
+  // that disallows self-intersecting polygons,
+  // did cost us half a day, so I'll leave it
+  // out of respect
+  // if (se1.isSubject === se2.isSubject) return
+  const inter = segmentIntersection(
+    se1.point, se1.otherEvent.point,
+    se2.point, se2.otherEvent.point
+  )
+
+  const nIntersections = inter ? inter.length : 0
+  if (nIntersections === 0) return 0 // no intersection
+
+  // the line segments intersect at an endpoint of both line segments
+  if ((nIntersections === 1) &&
+      (equals(se1.point, se2.point) ||
+       equals(se1.otherEvent.point, se2.otherEvent.point))) {
+    return 0
+  }
+
+  if (nIntersections === 2 && se1.isSubject === se2.isSubject) {
+    return 0
+  }
+
+  // The line segments associated to se1 and se2 intersect
+  if (nIntersections === 1) {
+    // if the intersection point is not an endpoint of se1
+    if (!equals(se1.point, inter[0]) && !equals(se1.otherEvent.point, inter[0])) {
+      divideSegment(se1, inter[0], queue)
+    }
+
+    // if the intersection point is not an endpoint of se2
+    if (!equals(se2.point, inter[0]) && !equals(se2.otherEvent.point, inter[0])) {
+      divideSegment(se2, inter[0], queue)
+    }
+    return 1
+  }
+
+  // The line segments associated to se1 and se2 overlap
+  const events = []
+  let leftCoincide = false
+  let rightCoincide = false
+
+  if (equals(se1.point, se2.point)) {
+    leftCoincide = true // linked
+  } else if (compareEvents(se1, se2) === 1) {
+    events.push(se2, se1)
+  } else {
+    events.push(se1, se2)
+  }
+
+  if (equals(se1.otherEvent.point, se2.otherEvent.point)) {
+    rightCoincide = true
+  } else if (compareEvents(se1.otherEvent, se2.otherEvent) === 1) {
+    events.push(se2.otherEvent, se1.otherEvent)
+  } else {
+    events.push(se1.otherEvent, se2.otherEvent)
+  }
+
+  if ((leftCoincide && rightCoincide) || leftCoincide) {
+    // both line segments are equal or share the left endpoint
+    se2.type = NON_CONTRIBUTING
+    se1.type = (se2.inOut === se1.inOut) ? SAME_TRANSITION : DIFFERENT_TRANSITION
+
+    if (leftCoincide && !rightCoincide) {
+      // honestly no idea, but changing events selection from [2, 1]
+      // to [0, 1] fixes the overlapping self-intersecting polygons issue
+      divideSegment(events[1].otherEvent, events[0].point, queue)
+    }
+    return 2
+  }
+
+  // the line segments share the right endpoint
+  if (rightCoincide) {
+    divideSegment(events[0], events[1].point, queue)
+    return 3
+  }
+
+  // no line segment includes totally the other one
+  if (events[0] !== events[3].otherEvent) {
+    divideSegment(events[0], events[1].point, queue)
+    divideSegment(events[1], events[2].point, queue)
+    return 3
+  }
+
+  // one line segment includes the other one
+  divideSegment(events[0], events[1].point, queue)
+  divideSegment(events[3].otherEvent, events[2].point, queue)
+
+  return 3
+}