@jscad/modeling 3.0.1-alpha.0 → 3.0.3-alpha.0

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

@@ -21,163 +21,80 @@ class Node {
 /**
  * Simple top down splay, not requiring i to be in the tree t.
  */
-const splay = (i, t, comparator) => {
+const splay = (key, t, comparator) => {
   const N = new Node(null, null)
-  let l = N
-  let r = N
+  let left = N
+  let right = N
 
   while (true) {
-    const cmp = comparator(i, t.key)
-    // if (i < t.key) {
+    const cmp = comparator(key, t.key)
     if (cmp < 0) {
       if (t.left === null) break
-      // if (i < t.left.key) {
-      if (comparator(i, t.left.key) < 0) {
+      if (comparator(key, t.left.key) < 0) {
         const y = t.left /* rotate right */
         t.left = y.right
         y.right = t
         t = y
         if (t.left === null) break
       }
-      r.left = t /* link right */
-      r = t
+      right.left = t /* link right */
+      right = t
       t = t.left
-    // } else if (i > t.key) {
     } else if (cmp > 0) {
       if (t.right === null) break
-      // if (i > t.right.key) {
-      if (comparator(i, t.right.key) > 0) {
+      if (comparator(key, t.right.key) > 0) {
         const y = t.right /* rotate left */
         t.right = y.left
         y.left = t
         t = y
         if (t.right === null) break
       }
-      l.right = t /* link left */
-      l = t
+      left.right = t /* link left */
+      left = t
       t = t.right
     } else break
   }
   /* assemble */
-  l.right = t.left
-  r.left = t.right
+  left.right = t.left
+  right.left = t.right
+
   t.left = N.right
   t.right = N.left
   return t
 }
 
-const insert = (i, data, t, comparator) => {
-  const node = new Node(i, data)
+const insert = (key, data, root, comparator) => {
+  const node = new Node(key, data)
 
-  if (t === null) {
-    node.left = node.right = null
+  if (root === null) {
     return node
   }
 
-  t = splay(i, t, comparator)
-  const cmp = comparator(i, t.key)
+  root = splay(key, root, comparator)
+  const cmp = comparator(key, root.key)
   if (cmp < 0) {
-    node.left = t.left
-    node.right = t
-    t.left = null
+    node.left = root.left
+    node.right = root
+    root.left = null
   } else if (cmp >= 0) {
-    node.right = t.right
-    node.left = t
-    t.right = null
+    node.right = root.right
+    node.left = root
+    root.right = null
   }
   return node
 }
 
-const split = (key, v, comparator) => {
-  let left = null
-  let right = null
-  if (v) {
-    v = splay(key, v, comparator)
-
-    const cmp = comparator(v.key, key)
-    if (cmp === 0) {
-      left = v.left
-      right = v.right
-    } else if (cmp < 0) {
-      right = v.right
-      v.right = null
-      left = v
-    } else {
-      left = v.left
-      v.left = null
-      right = v
-    }
-  }
-  return { left, right }
-}
-
-const merge = (left, right, comparator) => {
-  if (right === null) return left
-  if (left === null) return right
-
-  right = splay(left.key, right, comparator)
-  right.left = left
-  return right
-}
-
-/**
- * Prints level of the tree
- */
-const printRow = (root, prefix, isTail, out, printNode) => {
-  if (root) {
-    out(`${prefix}${isTail ? '└── ' : '├── '}${printNode(root)}\n`)
-    const indent = prefix + (isTail ? '    ' : '│   ')
-    if (root.left) printRow(root.left, indent, false, out, printNode)
-    if (root.right) printRow(root.right, indent, true, out, printNode)
-  }
-}
-
 export class Tree {
   constructor (comparator = DEFAULT_COMPARE) {
-    this._comparator = comparator
+    this.comparator = comparator
     this._root = null
-    this._size = 0
   }
 
   /**
    * Inserts a key, allows duplicates
    */
   insert (key, data) {
-    this._size++
-    this._root = insert(key, data, this._root, this._comparator)
-    return this._root
-  }
-
-  /**
-   * Adds a key, if it is not present in the tree
-   */
-  add (key, data) {
-    const node = new Node(key, data)
-
-    if (this._root === null) {
-      node.left = node.right = null
-      this._size++
-      this._root = node
-    }
-
-    const comparator = this._comparator
-    const t = splay(key, this._root, comparator)
-    const cmp = comparator(key, t.key)
-    if (cmp === 0) this._root = t
-    else {
-      if (cmp < 0) {
-        node.left = t.left
-        node.right = t
-        t.left = null
-      } else if (cmp > 0) {
-        node.right = t.right
-        node.left = t
-        t.right = null
-      }
-      this._size++
-      this._root = node
-    }
-
+    this._root = insert(key, data, this._root, this.comparator)
     return this._root
   }
 
@@ -186,155 +103,38 @@ export class Tree {
    * @return {Node|null}
    */
   remove (key) {
-    this._root = this._remove(key, this._root, this._comparator)
+    this._root = this._remove(key)
   }
 
   /**
    * Deletes i from the tree if it's there
    */
-  _remove (i, t, comparator) {
+  _remove (key) {
+    if (this._root === null) return null
+
     let x
-    if (t === null) return null
-    t = splay(i, t, comparator)
-    const cmp = comparator(i, t.key)
+    const t = splay(key, this._root, this.comparator)
+    const cmp = this.comparator(key, t.key)
     if (cmp === 0) { /* found it */
       if (t.left === null) {
         x = t.right
       } else {
-        x = splay(i, t.left, comparator)
+        x = splay(key, t.left, this.comparator)
         x.right = t.right
       }
-      this._size--
       return x
     }
     return t /* It wasn't there */
   }
 
-  /**
-   * Removes and returns the node with smallest key
-   */
-  pop () {
-    let node = this._root
-    if (node) {
-      while (node.left) node = node.left
-      this._root = splay(node.key, this._root, this._comparator)
-      this._root = this._remove(node.key, this._root, this._comparator)
-      return { key: node.key, data: node.data }
-    }
-    return null
-  }
-
-  /**
-   * Find without splaying
-   */
-  findStatic (key) {
-    let current = this._root
-    const compare = this._comparator
-    while (current) {
-      const cmp = compare(key, current.key)
-      if (cmp === 0) return current
-      else if (cmp < 0) current = current.left
-      else current = current.right
-    }
-    return null
-  }
-
   find (key) {
     if (this._root) {
-      this._root = splay(key, this._root, this._comparator)
-      if (this._comparator(key, this._root.key) !== 0) return null
+      this._root = splay(key, this._root, this.comparator)
+      if (this.comparator(key, this._root.key) !== 0) return null
     }
     return this._root
   }
 
-  contains (key) {
-    let current = this._root
-    const compare = this._comparator
-    while (current) {
-      const cmp = compare(key, current.key)
-      if (cmp === 0) return true
-      else if (cmp < 0) current = current.left
-      else current = current.right
-    }
-    return false
-  }
-
-  forEach (visitor, ctx) {
-    let current = this._root
-    const Q = [] /* Initialize stack s */
-    let done = false
-
-    while (!done) {
-      if (current !== null) {
-        Q.push(current)
-        current = current.left
-      } else {
-        if (Q.length !== 0) {
-          current = Q.pop()
-          visitor.call(ctx, current)
-
-          current = current.right
-        } else done = true
-      }
-    }
-    return this
-  }
-
-  /**
-   * Walk key range from `low` to `high`. Stops if `fn` returns a value.
-   */
-  range (low, high, fn, ctx) {
-    const Q = []
-    const compare = this._comparator
-    let node = this._root
-    let cmp
-
-    while (Q.length !== 0 || node) {
-      if (node) {
-        Q.push(node)
-        node = node.left
-      } else {
-        node = Q.pop()
-        cmp = compare(node.key, high)
-        if (cmp > 0) {
-          break
-        } else if (compare(node.key, low) >= 0) {
-          if (fn.call(ctx, node)) return this // stop if smth is returned
-        }
-        node = node.right
-      }
-    }
-    return this
-  }
-
-  /**
-   * Returns array of keys
-   */
-  keys () {
-    const keys = []
-    this.forEach(({ key }) => keys.push(key))
-    return keys
-  }
-
-  /**
-   * Returns array of all the data in the nodes
-   */
-  values () {
-    const values = []
-    this.forEach(({ data }) => values.push(data))
-    return values
-  }
-
-  min () {
-    if (this._root) return this.minNode(this._root).key
-    return null
-  }
-
-  max () {
-    if (this._root) return this.maxNode(this._root).key
-    return null
-  }
-
   minNode (t = this._root) {
     if (t) while (t.left) t = t.left
     return t
@@ -345,255 +145,57 @@ export class Tree {
     return t
   }
 
-  /**
-   * Returns node at given index
+  /*
+   * Return next node from the given.
    */
-  at (index) {
-    let current = this._root
-    let done = false
-    let i = 0
-    const Q = []
-
-    while (!done) {
-      if (current) {
-        Q.push(current)
-        current = current.left
-      } else {
-        if (Q.length > 0) {
-          current = Q.pop()
-          if (i === index) return current
-          i++
-          current = current.right
-        } else done = true
-      }
-    }
-    return null
-  }
-
-  next (d) {
-    let root = this._root
+  next (node) {
     let successor = null
 
-    if (d.right) {
-      successor = d.right
+    if (node.right) {
+      successor = node.right
       while (successor.left) successor = successor.left
       return successor
     }
 
-    const comparator = this._comparator
+    let root = this._root
     while (root) {
-      const cmp = comparator(d.key, root.key)
+      const cmp = this.comparator(node.key, root.key)
       if (cmp === 0) break
-      else if (cmp < 0) {
+
+      if (cmp < 0) {
         successor = root
         root = root.left
-      } else root = root.right
+      } else {
+        root = root.right
+      }
     }
-
     return successor
   }
 
-  prev (d) {
-    let root = this._root
+  /*
+   * Return previous node from the given.
+   */
+  prev (node) {
     let predecessor = null
 
-    if (d.left !== null) {
-      predecessor = d.left
+    if (node.left) {
+      predecessor = node.left
       while (predecessor.right) predecessor = predecessor.right
       return predecessor
     }
 
-    const comparator = this._comparator
+    let root = this._root
     while (root) {
-      const cmp = comparator(d.key, root.key)
+      const cmp = this.comparator(node.key, root.key)
       if (cmp === 0) break
-      else if (cmp < 0) root = root.left
-      else {
+
+      if (cmp < 0) {
+        root = root.left
+      } else {
         predecessor = root
         root = root.right
       }
     }
     return predecessor
   }
-
-  clear () {
-    this._root = null
-    this._size = 0
-    return this
-  }
-
-  toList () {
-    return toList(this._root)
-  }
-
-  /**
-   * Bulk-load items. Both array have to be same size
-   */
-  load (keys, values = [], presort = false) {
-    let size = keys.length
-    const comparator = this._comparator
-
-    // sort if needed
-    if (presort) sort(keys, values, 0, size - 1, comparator)
-
-    if (this._root === null) { // empty tree
-      this._root = loadRecursive(keys, values, 0, size)
-      this._size = size
-    } else { // that re-builds the whole tree from two in-order traversals
-      const mergedList = mergeLists(this.toList(), createList(keys, values), comparator)
-      size = this._size + size
-      this._root = sortedListToBST({ head: mergedList }, 0, size)
-    }
-    return this
-  }
-
-  isEmpty () { return this._root === null }
-
-  size () { return this._size }
-  root () { return this._root }
-
-  toString (printNode = (n) => String(n.key)) {
-    const out = []
-    printRow(this._root, '', true, (v) => out.push(v), printNode)
-    return out.join('')
-  }
-
-  update (key, newKey, newData) {
-    const comparator = this._comparator
-    let { left, right } = split(key, this._root, comparator)
-    if (comparator(key, newKey) < 0) {
-      right = insert(newKey, newData, right, comparator)
-    } else {
-      left = insert(newKey, newData, left, comparator)
-    }
-    this._root = merge(left, right, comparator)
-  }
-
-  split (key) {
-    return split(key, this._root, this._comparator)
-  }
-
-  * [Symbol.iterator] () {
-    let n = this.minNode()
-    while (n) {
-      yield n
-      n = this.next(n)
-    }
-  }
-}
-
-const loadRecursive = (keys, values, start, end) => {
-  const size = end - start
-  if (size > 0) {
-    const middle = start + Math.floor(size / 2)
-    const key = keys[middle]
-    const data = values[middle]
-    const node = new Node(key, data)
-    node.left = loadRecursive(keys, values, start, middle)
-    node.right = loadRecursive(keys, values, middle + 1, end)
-    return node
-  }
-  return null
-}
-
-const createList = (keys, values) => {
-  const head = new Node(null, null)
-  let p = head
-  for (let i = 0; i < keys.length; i++) {
-    p = p.next = new Node(keys[i], values[i])
-  }
-  p.next = null
-  return head.next
-}
-
-const toList = (root) => {
-  let current = root
-  const Q = []
-  let done = false
-
-  const head = new Node(null, null)
-  let p = head
-
-  while (!done) {
-    if (current) {
-      Q.push(current)
-      current = current.left
-    } else {
-      if (Q.length > 0) {
-        current = p = p.next = Q.pop()
-        current = current.right
-      } else done = true
-    }
-  }
-  p.next = null // that'll work even if the tree was empty
-  return head.next
-}
-
-const sortedListToBST = (list, start, end) => {
-  const size = end - start
-  if (size > 0) {
-    const middle = start + Math.floor(size / 2)
-    const left = sortedListToBST(list, start, middle)
-
-    const root = list.head
-    root.left = left
-
-    list.head = list.head.next
-
-    root.right = sortedListToBST(list, middle + 1, end)
-    return root
-  }
-  return null
-}
-
-const mergeLists = (l1, l2, compare) => {
-  const head = new Node(null, null) // dummy
-  let p = head
-
-  let p1 = l1
-  let p2 = l2
-
-  while (p1 !== null && p2 !== null) {
-    if (compare(p1.key, p2.key) < 0) {
-      p.next = p1
-      p1 = p1.next
-    } else {
-      p.next = p2
-      p2 = p2.next
-    }
-    p = p.next
-  }
-
-  if (p1 !== null) {
-    p.next = p1
-  } else if (p2 !== null) {
-    p.next = p2
-  }
-
-  return head.next
-}
-
-const sort = (keys, values, left, right, compare) => {
-  if (left >= right) return
-
-  const pivot = keys[(left + right) >> 1]
-  let i = left - 1
-  let j = right + 1
-
-  while (true) {
-    do i++; while (compare(keys[i], pivot) < 0)
-    do j--; while (compare(keys[j], pivot) > 0)
-    if (i >= j) break
-
-    let tmp = keys[i]
-    keys[i] = keys[j]
-    keys[j] = tmp
-
-    tmp = values[i]
-    values[i] = values[j]
-    values[j] = tmp
-  }
-
-  sort(keys, values, left, j, compare)
-  sort(keys, values, j + 1, right, compare)
 }

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

@@ -22,7 +22,7 @@ export const subdivideSegments = (eventQueue, subject, clipping, sbbox, cbbox, o
   let prev, next, begin
 
   while (eventQueue.length !== 0) {
-    let event = eventQueue.pop()
+    const event = eventQueue.pop()
     sortedEvents.push(event)
 
     // optimization by bboxes for intersection and difference goes here
@@ -62,15 +62,15 @@ export const subdivideSegments = (eventQueue, subject, clipping, sbbox, cbbox, o
         }
       }
     } else {
-      event = event.otherEvent
-      next = prev = sweepLine.find(event)
+      next = prev = sweepLine.find(event.otherEvent)
 
       if (prev && next) {
+        // FIXME is this correct? begin is assigned if event.left, not every iterration
         if (prev !== begin) prev = sweepLine.prev(prev)
         else prev = null
 
         next = sweepLine.next(next)
-        sweepLine.remove(event)
+        sweepLine.remove(event.otherEvent)
 
         if (next && prev) {
           possibleIntersection(prev.key, next.key, eventQueue)

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

@@ -9,9 +9,9 @@ export class SweepEvent {
    * @param {boolean} left
    * @param {SweepEvent=} otherEvent
    * @param {boolean} isSubject
-   * @param {number} edgeType
+   * @param {number} type OPTIONAL
    */
-  constructor (point, left, otherEvent, isSubject, edgeType) {
+  constructor (point, left, otherEvent, isSubject, type = NORMAL) {
     /**
      * Is left endpoint?
      * @type {Boolean}
@@ -39,7 +39,7 @@ export class SweepEvent {
      * Edge contribution type
      * @type {Number}
      */
-    this.type = edgeType || NORMAL
+    this.type = type
 
     /**
      * In-out transition for the sweepline crossing polygon
@@ -115,18 +115,4 @@ export class SweepEvent {
   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
-  }
 }