perf(modeling): rework martinez for performance as well as modernizing code

Author: z3dev

packages/modeling/src/operations/booleans/martinez/compareEvents.js

@@ -23,23 +23,18 @@ export const compareEvents = (e1, e2) => {
   // 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
+    // the event associate to the lowest segment is processed first
     return (!e1.isBelow(e2.otherEvent.point)) ? 1 : -1
   }
 
+  // Same coordinates, subject events are processed first
   return (!e1.isSubject && e2.isSubject) ? 1 : -1
 }

packages/modeling/src/operations/booleans/martinez/connectEdges.js

@@ -12,45 +12,39 @@ import { Contour } from './contour.js'
  * @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)
+  sortedEvents.forEach((e) => {
+    if ((e.left && e.inResult) || (!e.left && e.otherEvent.inResult)) {
+      resultEvents.push(e)
     }
-  }
+  })
   // 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++) {
+    const len = resultEvents.length
+    for (let i = 0; i < len; i++) {
       if ((i + 1) < len &&
         compareEvents(resultEvents[i], resultEvents[i + 1]) === 1) {
-        tmp = resultEvents[i]
+        const 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
-  }
+  // and index
+  resultEvents.forEach((e, i) => { e.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
+  resultEvents.forEach((e) => {
+    if (!e.left) {
+      const otherPos = e.otherPos
+      e.otherPos = e.otherEvent.otherPos
+      e.otherEvent.otherPos = otherPos
     }
-  }
+  })
 
   return resultEvents
 }
@@ -62,14 +56,15 @@ const orderEvents = (sortedEvents) => {
  * @return {number}
  */
 const nextPos = (pos, resultEvents, processed, origPos) => {
-  let newPos = pos + 1
-  const p = resultEvents[pos].point
-  let p1
   const length = resultEvents.length
 
+  const p0 = resultEvents[pos].point
+
+  let newPos = pos + 1
+  let p1
   if (newPos < length) { p1 = resultEvents[newPos].point }
 
-  while (newPos < length && p1[0] === p[0] && p1[1] === p[1]) {
+  while (newPos < length && p1[0] === p0[0] && p1[1] === p0[1]) {
     if (!processed[newPos]) {
       return newPos
     } else {
@@ -81,7 +76,6 @@ const nextPos = (pos, resultEvents, processed, origPos) => {
   }
 
   newPos = pos - 1
-
   while (processed[newPos] && newPos > origPos) {
     newPos--
   }
@@ -90,7 +84,8 @@ const nextPos = (pos, resultEvents, processed, origPos) => {
 }
 
 const initializeContourFromContext = (event, contours, contourId) => {
-  const contour = new Contour()
+  const contour = new Contour() // default is exterior contour of depth 0
+
   if (event.prevInResult != null) {
     const prevInResult = event.prevInResult
     // Note that it is valid to query the "previous in result" for its output contour id,
@@ -99,6 +94,7 @@ const initializeContourFromContext = (event, contours, contourId) => {
     // result".
     const lowerContourId = prevInResult.outputContourId
     const lowerResultTransition = prevInResult.resultTransition
+
     if (lowerContourId < 0) {
       contour.holeOf = null
       contour.depth = 0
@@ -122,30 +118,24 @@ const initializeContourFromContext = (event, contours, contourId) => {
       }
     } 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
+ * @return array of Contour
  */
 export const connectEdges = (sortedEvents) => {
   const resultEvents = orderEvents(sortedEvents)
-  const len = resultEvents.length
+  const evlen = resultEvents.length
 
-  // "false"-filled array
-  const processed = {}
+  const processed = []
   const contours = []
 
-  for (let i = 0; i < len; i++) {
+  for (let i = 0; i < evlen; i++) {
     if (processed[i]) {
       continue
     }
@@ -156,16 +146,15 @@ export const connectEdges = (sortedEvents) => {
     // 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]) {
+      if (pos < evlen) {
         resultEvents[pos].outputContourId = contourId
       }
     }
 
     let pos = i
     const origPos = i
 
-    const initial = resultEvents[i].point
-    contour.points.push(initial)
+    contour.points.push(resultEvents[pos].point)
 
     while (true) {
       markAsProcessed(pos)
@@ -177,7 +166,7 @@ export const connectEdges = (sortedEvents) => {
 
       pos = nextPos(pos, resultEvents, processed, origPos)
 
-      if (pos === origPos || pos >= resultEvents.length || !resultEvents[pos]) {
+      if (pos === origPos || pos >= evlen) {
         break
       }
     }

packages/modeling/src/operations/booleans/martinez/contour.js

@@ -3,7 +3,7 @@ export class Contour {
     this.points = []
     this.holeIds = []
     this.holeOf = null
-    this.depth = null
+    this.depth = 0
   }
 
   isExterior () {

packages/modeling/src/operations/booleans/martinez/divideSegment.js

@@ -2,28 +2,29 @@ import { SweepEvent } from './sweepEvent.js'
 import { compareEvents } from './compareEvents.js'
 
 /**
- * @param {SweepEvent} se
- * @param {Array.<Number>} p
+ * Divide the given segment at the given point, push the parts on the given queue.
+ * @param {SweepEvent} segment
+ * @param {Array.<Number>} point
  * @param {Queue} queue
- * @return {Queue}
+ * @return {Queue} given 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)
+export const divideSegment = (segment, point, queue) => {
+  const r = new SweepEvent(point, false, segment, segment.isSubject)
+  const l = new SweepEvent(point, true, segment.otherEvent, segment.isSubject)
 
-  r.contourId = l.contourId = se.contourId
+  r.contourId = l.contourId = segment.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
+  if (compareEvents(l, segment.otherEvent) > 0) {
+    segment.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
+  segment.otherEvent.otherEvent = l
+  segment.otherEvent = r
 
   queue.push(l)
   queue.push(r)

packages/modeling/src/operations/booleans/martinez/fillQueue.js

@@ -9,26 +9,23 @@ import { DIFFERENCE } from './operation.js'
 import { SweepEvent } from './sweepEvent.js'
 import { Queue } from './tinyqueue.js'
 
-const max = Math.max
-const min = Math.min
+let externalRingId = 0
 
-let contourId = 0
-
-const processPolygon = (contourOrHole, isSubject, depth, queue, bbox, isExteriorRing) => {
+const processPolygon = (contourOrHole, isSubject, ringId, 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)
+    const s1 = contourOrHole[i]
+    const s2 = contourOrHole[i + 1]
+    const e1 = new SweepEvent(s1, false, undefined, isSubject)
+    const 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
+    e1.contourId = e2.contourId = ringId
     if (!isExteriorRing) {
       e1.isExteriorRing = false
       e2.isExteriorRing = false
@@ -41,10 +38,10 @@ const processPolygon = (contourOrHole, isSubject, depth, queue, bbox, isExterior
 
     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)
+    bbox[0] = Math.min(bbox[0], x)
+    bbox[1] = Math.min(bbox[1], y)
+    bbox[2] = Math.max(bbox[2], x)
+    bbox[3] = Math.max(bbox[3], y)
 
     // Pushing it so the queue is sorted from left to right,
     // with object on the left having the highest priority.
@@ -55,24 +52,23 @@ const processPolygon = (contourOrHole, isSubject, depth, queue, bbox, isExterior
 
 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 (let i = 0; i < subject.length; i++) {
+    const polygonSet = subject[i]
+    for (let j = 0; j < polygonSet.length; j++) {
+      const isExteriorRing = j === 0
+      if (isExteriorRing) externalRingId++
+      processPolygon(polygonSet[j], true, externalRingId, 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
+  for (let i = 0; i < clipping.length; i++) {
+    const polygonSet = clipping[i]
+    for (let j = 0; j < polygonSet.length; j++) {
+      let isExteriorRing = j === 0
       if (operation === DIFFERENCE) isExteriorRing = false
-      if (isExteriorRing) contourId++
-      processPolygon(polygonSet[j], false, contourId, eventQueue, cbbox, isExteriorRing)
+      if (isExteriorRing) externalRingId++
+      processPolygon(polygonSet[j], false, externalRingId, eventQueue, cbbox, isExteriorRing)
     }
   }
 

packages/modeling/src/operations/booleans/martinez/index.js

@@ -135,6 +135,7 @@ export const boolean = (subjectGeom, clippingGeom, operation) => {
       // Followed by holes if any
       for (let j = 0; j < contour.holeIds.length; j++) {
         const holeId = contour.holeIds[j]
+        // Reverse the order of points for holes
         const holePoints = contours[holeId].points
         const hole = []
         for (let k = holePoints.length - 2; k >= 0; k--) {
@@ -146,7 +147,7 @@ export const boolean = (subjectGeom, clippingGeom, operation) => {
     }
   }
 
-  if (polygons) {
+  if (polygons.length) {
     return fromOutlines(polygons.flat())
   } else {
     return geom2.create()