@jscad/modeling 3.0.0-alpha.0 → 3.0.2-alpha.0

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

@@ -4,11 +4,11 @@ import { geom2, geom3 } from '../../geometries/index.js'
 
 import { intersect } from './index.js'
 
-test('intersect error wrong number of arguments', (t) => {
-  const message = 'intersect wrong number of arguments'
-  t.throws(() => intersect(), { message })
-  t.throws(() => intersect([]), { message })
-  t.throws(() => intersect([[], []]), { message })
+test('intersect empty arguments', (t) => {
+  t.is(intersect(), undefined)
+  t.is(intersect([]), undefined)
+  t.is(intersect([[], []]), undefined)
+  t.is(intersect(null, null), undefined)
 })
 
 test('intersect error different geometry types', (t) => {
@@ -20,6 +20,5 @@ test('intersect error non-geometries', (t) => {
   const message = 'intersect unsupported geometry type'
   t.throws(() => intersect([1, 2, 3], [4, 5, 6]), { message })
   t.throws(() => intersect([], [123]), { message })
-  t.throws(() => intersect("one", "two"), { message })
-  t.throws(() => intersect(null, null), { message })
+  t.throws(() => intersect('one', 'two'), { message })
 })

package/src/operations/booleans/intersectGeom2.js

@@ -1,17 +1,13 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { INTERSECTION } from './martinez/operation.js'
 import { boolean } from './martinez/index.js'
 
 /*
  * Return a new 2D geometry representing space in both the first geometry and
  * in the subsequent geometries. None of the given geometries are modified.
- * @param {...geom2} geometries - list of 2D geometries
+ * @param {Geom2[]} geometries - a flat list of 2D geometries
  * @returns {Geom2} new 2D geometry
  */
-export const intersectGeom2 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const intersectGeom2 = (geometries) => {
   let newGeometry = geometries.shift()
   geometries.forEach((geometry) => {
     newGeometry = boolean(newGeometry, geometry, INTERSECTION)

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

@@ -6,7 +6,7 @@ import { geom2 } from '../../geometries/index.js'
 
 import { measureArea } from '../../measurements/index.js'
 
-import { circle, rectangle } from '../../primitives/index.js'
+import { circle, rectangle, square } from '../../primitives/index.js'
 
 import { intersect } from './index.js'
 
@@ -73,3 +73,27 @@ test('intersect: intersect of one or more geom2 objects produces expected geomet
   t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 })
+
+test('intersect 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 = intersect(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+})
+
+test('intersect 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 = intersect(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+})

package/src/operations/booleans/intersectGeom3.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { retessellate } from '../modifiers/retessellate.js'
 
 import { intersectGeom3Sub } from './intersectGeom3Sub.js'
@@ -7,12 +5,10 @@ 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
+ * @param {Geom3[]} geometries - a flat list of 3D geometries
  * @returns {Geom3} new 3D geometry
  */
-export const intersectGeom3 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const intersectGeom3 = (geometries) => {
   let newGeometry = geometries.shift()
   geometries.forEach((geometry) => {
     newGeometry = intersectGeom3Sub(newGeometry, geometry)

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

@@ -4,7 +4,7 @@ import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
 import { geom3 } from '../../geometries/index.js'
 
-import { measureVolume } from '../../measurements/index.js'
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
 import { sphere, cuboid } from '../../primitives/index.js'
 
@@ -69,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(measureArea(result1), 44.053756306589825)
   t.is(measureVolume(result1), 25.751611331979678)
   t.is(obs.length, 32)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -79,6 +80,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(measureArea(result2), 0)
   t.is(measureVolume(result2), 0)
   t.is(obs.length, 0)
 
@@ -99,6 +101,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   ]
 
   t.notThrows(() => geom3.validate(result3))
+  t.is(measureArea(result3), 6)
   t.is(measureVolume(result3), 1.0000000000000009)
   t.is(obs.length, 6)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -107,6 +110,7 @@ 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(measureArea(result4), 44.053756306589825)
   t.is(measureVolume(result4), 25.751611331979678)
   t.is(obs.length, 32)
 })

package/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
 }

package/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,7 +146,7 @@ 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
       }
     }
@@ -164,8 +154,7 @@ export const connectEdges = (sortedEvents) => {
     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
       }
     }

package/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 () {

package/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)

package/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)
     }
   }
 

package/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()

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

@@ -15,36 +15,40 @@ import {
 } from './edgeType.js'
 
 /**
+ * and split the segments if an intersection is detected.
  * @param {SweepEvent} se1
  * @param {SweepEvent} se2
  * @param {Queue} queue
- * @return {number}
+ * @return
+ *   0=no intersection
+ *   1=intersect point
+ *   2=overlap, left points cooinciding
+ *   3=overlap, right points cooinciding
+ *   4=segments overlap
+ *   5=segment within segment
  */
 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
+  // null = no intersection
+  // array[1] = point of intersection
+  // array[2] = line overlaps, segment of overlap, i.e. two points
   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
+  // no intersection of segments
+  if (nIntersections === 0) return 0
+
+  // single point of intersection, check the end points
   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
+  // single point of intersection, divide the segments
   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])) {
@@ -58,56 +62,63 @@ export const possibleIntersection = (se1, se2, queue) => {
     return 1
   }
 
-  // The line segments associated to se1 and se2 overlap
-  const events = []
+  // segments overlap, check for same subject/clipping
+  if (nIntersections === 2 && se1.isSubject === se2.isSubject) {
+    return 0
+  }
+
+  // segments overlap, determine the overlap, and divide segments
+  // FIXME eliminate this stack
+  const segmentEvents = []
   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)
+    segmentEvents.push(se2, se1)
   } else {
-    events.push(se1, se2)
+    segmentEvents.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)
+    segmentEvents.push(se2.otherEvent, se1.otherEvent)
   } else {
-    events.push(se1.otherEvent, se2.otherEvent)
+    segmentEvents.push(se1.otherEvent, se2.otherEvent)
   }
 
-  if ((leftCoincide && rightCoincide) || leftCoincide) {
+  if (leftCoincide) {
     // both line segments are equal or share the left endpoint
+    // FIXME: this setting of type should be done outside this function
     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]
+    if (!rightCoincide) {
+      // honestly no idea, but changing segmentEvents selection from [2, 1]
       // to [0, 1] fixes the overlapping self-intersecting polygons issue
-      divideSegment(events[1].otherEvent, events[0].point, queue)
+      divideSegment(segmentEvents[1].otherEvent, segmentEvents[0].point, queue)
     }
     return 2
   }
 
   // the line segments share the right endpoint
   if (rightCoincide) {
-    divideSegment(events[0], events[1].point, queue)
+    divideSegment(segmentEvents[0], segmentEvents[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
+  if (segmentEvents[0] !== segmentEvents[3].otherEvent) {
+    divideSegment(segmentEvents[0], segmentEvents[1].point, queue)
+    divideSegment(segmentEvents[1], segmentEvents[2].point, queue)
+    return 4
   }
 
   // one line segment includes the other one
-  divideSegment(events[0], events[1].point, queue)
-  divideSegment(events[3].otherEvent, events[2].point, queue)
+  divideSegment(segmentEvents[0], segmentEvents[1].point, queue)
+  divideSegment(segmentEvents[3].otherEvent, segmentEvents[2].point, queue)
 
-  return 3
+  return 5
 }