@jscad/modeling 2.12.0 → 3.0.0-alpha.0

package/src/measurements/measureEpsilon.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { geom2, geom3, path2 } = require('../geometries')
+import { geom2, geom3, path2, slice } from '../geometries/index.js'
 
-const { line, rectangle, cuboid } = require('../primitives')
+import { line, rectangle, cuboid } from '../primitives/index.js'
 
-const { measureEpsilon } = require('./index')
+import { measureEpsilon } from './measureEpsilon.js'
 
 test('measureEpsilon (single objects)', (t) => {
   const aline = line([[10, 10], [15, 15]])
@@ -14,6 +14,7 @@ test('measureEpsilon (single objects)', (t) => {
   const apath2 = path2.create()
   const ageom2 = geom2.create()
   const ageom3 = geom3.create()
+  const aslice = slice.create()
 
   const n = null
   const o = {}
@@ -26,6 +27,7 @@ test('measureEpsilon (single objects)', (t) => {
   const p2epsilon = measureEpsilon(apath2)
   const g2epsilon = measureEpsilon(ageom2)
   const g3epsilon = measureEpsilon(ageom3)
+  const slepsilon = measureEpsilon(aslice)
 
   const nepsilon = measureEpsilon(n)
   const oepsilon = measureEpsilon(o)
@@ -38,6 +40,7 @@ test('measureEpsilon (single objects)', (t) => {
   t.is(p2epsilon, 0)
   t.is(g2epsilon, 0)
   t.is(g3epsilon, 0)
+  t.is(slepsilon, 0)
 
   t.is(nepsilon, 0)
   t.is(oepsilon, 0)

package/src/measurements/measureVolume.d.ts

@@ -1,8 +1,6 @@
-import { Geometry } from '../geometries/types'
-import RecursiveArray from '../utils/recursiveArray'
+import type { Geometry } from '../geometries/types.d.ts'
+import type { RecursiveArray } from '../utils/recursiveArray.d.ts'
 
-export default measureVolume
-
-declare function measureVolume(geometry: Geometry): number
-declare function measureVolume(geometry: any): 0
-declare function measureVolume(...geometries: RecursiveArray<Geometry | any>): Array<number>
+export function measureVolume(geometry: Geometry): number
+export function measureVolume(geometry: any): 0
+export function measureVolume(...geometries: RecursiveArray<Geometry | any>): Array<number>

package/src/measurements/measureVolume.js

@@ -1,35 +1,15 @@
-const flatten = require('../utils/flatten')
+import { flatten } from '../utils/flatten.js'
 
-const geom2 = require('../geometries/geom2')
-const geom3 = require('../geometries/geom3')
-const path2 = require('../geometries/path2')
-const poly3 = require('../geometries/poly3')
+import * as geom3 from '../geometries/geom3/index.js'
+import * as poly3 from '../geometries/poly3/index.js'
 
 const cache = new WeakMap()
 
-/*
- * Measure the volume of the given geometry.
- * NOTE: paths are infinitely narrow and do not have an volume
- *
- * @param {Path2} geometry - geometry to measure
- * @returns {Number} volume of the geometry
- */
-const measureVolumeOfPath2 = () => 0
-
-/*
- * Measure the volume of the given geometry.
- * NOTE: 2D geometry are infinitely thin and do not have an volume
- *
- * @param {Geom2} geometry - 2D geometry to measure
- * @returns {Number} volume of the geometry
- */
-const measureVolumeOfGeom2 = () => 0
-
 /*
  * Measure the volume of the given geometry.
  *
  * @param {Geom3} geometry - 3D geometry to measure
- * @returns {Number} volume of the geometry
+ * @returns {number} volume of the geometry
  */
 const measureVolumeOfGeom3 = (geometry) => {
   let volume = cache.get(geometry)
@@ -46,23 +26,20 @@ const measureVolumeOfGeom3 = (geometry) => {
 /**
  * Measure the volume of the given geometries.
  * @param {...Object} geometries - the geometries to measure
- * @return {Number|Array} the volume, or a list of volumes for each geometry
+ * @return {number|Array} the volume, or a list of volumes for each geometry
  * @alias module:modeling/measurements.measureVolume
  *
  * @example
  * let volume = measureVolume(sphere())
  */
-const measureVolume = (...geometries) => {
+export const measureVolume = (...geometries) => {
   geometries = flatten(geometries)
   if (geometries.length === 0) throw new Error('wrong number of arguments')
 
   const results = geometries.map((geometry) => {
-    if (path2.isA(geometry)) return measureVolumeOfPath2(geometry)
-    if (geom2.isA(geometry)) return measureVolumeOfGeom2(geometry)
     if (geom3.isA(geometry)) return measureVolumeOfGeom3(geometry)
+    // 2D geometry, paths, and slices are infinitely thin and do not have a volume
     return 0
   })
   return results.length === 1 ? results[0] : results
 }
-
-module.exports = measureVolume

package/src/measurements/measureVolume.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { geom2, geom3, path2 } = require('../geometries')
+import { geom2, geom3, path2, slice } from '../geometries/index.js'
 
-const { line, rectangle, cuboid } = require('../primitives')
+import { line, rectangle, cuboid } from '../primitives/index.js'
 
-const { measureVolume } = require('./index')
+import { measureVolume } from './index.js'
 
 test('measureVolume: single objects', (t) => {
   const aline = line([[10, 10], [15, 15]])
@@ -14,6 +14,7 @@ test('measureVolume: single objects', (t) => {
   const apath2 = path2.create()
   const ageom2 = geom2.create()
   const ageom3 = geom3.create()
+  const aslice = slice.create()
 
   const n = null
   const o = {}
@@ -26,6 +27,7 @@ test('measureVolume: single objects', (t) => {
   const p2volume = measureVolume(apath2)
   const g2volume = measureVolume(ageom2)
   const g3volume = measureVolume(ageom3)
+  const slvolume = measureVolume(aslice)
 
   const nvolume = measureVolume(n)
   const ovolume = measureVolume(o)
@@ -38,6 +40,7 @@ test('measureVolume: single objects', (t) => {
   t.is(p2volume, 0)
   t.is(g2volume, 0)
   t.is(g3volume, 0)
+  t.is(slvolume, 0)
 
   t.is(nvolume, 0)
   t.is(ovolume, 0)

package/src/measurements/types.d.ts

@@ -1,3 +1,4 @@
-import Vec3 from '../maths/vec3/type'
+import type { Vec3 } from '../maths/vec3/type.d.ts'
 
 export type BoundingBox = [Vec3, Vec3]
+export type BoundingSphere = [Vec3, number]

package/src/operations/booleans/index.d.ts

@@ -1,5 +1,3 @@
-export { default as intersect } from './intersect'
-export { default as subtract } from './subtract'
-export { default as union } from './union'
-
-export as namespace booleans
+export { intersect } from './intersect.js'
+export { subtract } from './subtract.js'
+export { union } from './union.js'

package/src/operations/booleans/index.js

@@ -4,11 +4,9 @@
  * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/booleans
  * @example
- * const { intersect, subtract, union } = require('@jscad/modeling').booleans
+ * import { intersect, scission, subtract, union } from '@jscad/modeling'
  */
-module.exports = {
-  intersect: require('./intersect'),
-  scission: require('./scission'),
-  subtract: require('./subtract'),
-  union: require('./union')
-}
+export { intersect } from './intersect.js'
+export { scission } from './scission.js'
+export { subtract } from './subtract.js'
+export { union } from './union.js'

package/src/operations/booleans/intersect.d.ts

@@ -1,7 +1,6 @@
-import { Geom2, Geom3 } from '../../geometries/types'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geom2 } from '../../geometries/geom2/type.d.ts'
+import type { Geom3 } from '../../geometries/geom3/type.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
-export default intersect
-
-declare function intersect(...geometries: RecursiveArray<Geom2>): Geom2
-declare function intersect(...geometries: RecursiveArray<Geom3>): Geom3
+export function intersect(...geometries: RecursiveArray<Geom2>): Geom2
+export function intersect(...geometries: RecursiveArray<Geom3>): Geom3

package/src/operations/booleans/intersect.js

@@ -1,11 +1,11 @@
-const flatten = require('../../utils/flatten')
-const areAllShapesTheSameType = require('../../utils/areAllShapesTheSameType')
+import { areAllShapesTheSameType } from '../../utils/areAllShapesTheSameType.js'
+import { flatten } from '../../utils/flatten.js'
 
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
 
-const intersectGeom2 = require('./intersectGeom2')
-const intersectGeom3 = require('./intersectGeom3')
+import { intersectGeom2 } from './intersectGeom2.js'
+import { intersectGeom3 } from './intersectGeom3.js'
 
 /**
  * Return a new geometry representing space in both the first geometry and
@@ -13,7 +13,7 @@ const intersectGeom3 = require('./intersectGeom3')
  * The given geometries should be of the same type, either geom2 or geom3.
  *
  * @param {...Object} geometries - list of geometries
- * @returns {geom2|geom3} a new geometry
+ * @returns {Geom2|geom3} a new geometry
  * @alias module:modeling/booleans.intersect
  *
  * @example
@@ -29,19 +29,17 @@ const intersectGeom3 = require('./intersectGeom3')
  *      |       |
  *      +-------+
  */
-const intersect = (...geometries) => {
+export const intersect = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
+  if (geometries.length === 0) throw new Error('intersect wrong number of arguments')
 
   if (!areAllShapesTheSameType(geometries)) {
-    throw new Error('only intersect of the types are supported')
+    throw new Error('intersect arguments must be the same geometry type')
   }
 
   const geometry = geometries[0]
-  // if (path.isA(geometry)) return pathintersect(matrix, geometries)
+  // if (path.isA(geometry)) return intersectPath(matrix, geometries)
   if (geom2.isA(geometry)) return intersectGeom2(geometries)
   if (geom3.isA(geometry)) return intersectGeom3(geometries)
-  return geometry
+  throw new Error('intersect unsupported geometry type')
 }
-
-module.exports = intersect

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

@@ -0,0 +1,25 @@
+import test from 'ava'
+
+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 error different geometry types', (t) => {
+  const message = 'intersect arguments must be the same geometry type'
+  t.throws(() => intersect(geom2.create(), geom3.create()), { message })
+})
+
+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 })
+})

package/src/operations/booleans/intersectGeom2.js

@@ -1,27 +1,21 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const geom3 = require('../../geometries/geom3')
-
-const measureEpsilon = require('../../measurements/measureEpsilon')
-
-const fromFakePolygons = require('./fromFakePolygons')
-const to3DWalls = require('./to3DWalls')
-const intersectGeom3 = require('./intersectGeom3')
+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
- * @returns {geom2} new 2D geometry
+ * @returns {Geom2} new 2D geometry
  */
-const intersect = (...geometries) => {
+export const intersectGeom2 = (...geometries) => {
   geometries = flatten(geometries)
-  const newgeometries = geometries.map((geometry) => to3DWalls({ z0: -1, z1: 1 }, geometry))
 
-  const newgeom3 = intersectGeom3(newgeometries)
-  const epsilon = measureEpsilon(newgeom3)
+  let newGeometry = geometries.shift()
+  geometries.forEach((geometry) => {
+    newGeometry = boolean(newGeometry, geometry, INTERSECTION)
+  })
 
-  return fromFakePolygons(epsilon, geom3.toPolygons(newgeom3))
+  return newGeometry
 }
-
-module.exports = intersect

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

@@ -1,14 +1,16 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePoints } = require('../../../test/helpers')
+import { comparePoints } from '../../../test/helpers/index.js'
 
-const { geom2 } = require('../../geometries')
+import { geom2 } from '../../geometries/index.js'
 
-const { circle, rectangle } = require('../../primitives')
+import { measureArea } from '../../measurements/index.js'
 
-const { intersect } = require('./index')
+import { circle, rectangle } 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 geom2 objects produces expected geometry', (t) => {
   const geometry1 = circle({ radius: 2, segments: 8 })
@@ -18,15 +20,16 @@ test('intersect: intersect of one or more geom2 objects produces expected geomet
   let obs = geom2.toPoints(result1)
   let exp = [
     [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
+    [1.4142135623730951, 1.414213562373095],
     [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
+    [-1.414213562373095, 1.4142135623730951],
     [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
+    [-1.4142135623730954, -1.414213562373095],
     [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
+    [1.4142135623730947, -1.4142135623730954]
   ]
   t.notThrows(() => geom2.validate(result1))
+  t.is(measureArea(result1), 11.31370849898476)
   t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 
@@ -36,6 +39,7 @@ test('intersect: intersect of one or more geom2 objects produces expected geomet
   const result2 = intersect(geometry1, geometry2)
   obs = geom2.toPoints(result2)
   t.notThrows(() => geom2.validate(result2))
+  t.is(measureArea(result2), 0)
   t.is(obs.length, 0)
 
   // intersect of two partially overlapping objects
@@ -44,9 +48,10 @@ test('intersect: intersect of one or more geom2 objects produces expected geomet
   const result3 = intersect(geometry2, geometry3)
   obs = geom2.toPoints(result3)
   exp = [
-    [9, 9], [8, 9], [8, 8], [9, 8]
+    [8, 8], [9, 8], [9, 9], [8, 9]
   ]
   t.notThrows(() => geom2.validate(result3))
+  t.is(measureArea(result3), 1)
   t.is(obs.length, 4)
   t.true(comparePoints(obs, exp))
 
@@ -54,16 +59,17 @@ test('intersect: intersect of one or more geom2 objects produces expected geomet
   const result4 = intersect(geometry1, geometry3)
   obs = geom2.toPoints(result4)
   exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
     [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
+    [-1.4142135623730954, -1.414213562373095],
     [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
+    [1.4142135623730947, -1.4142135623730954],
+    [2, 0],
+    [1.4142135623730951, 1.414213562373095],
+    [0, 2],
+    [-1.414213562373095, 1.4142135623730951]
   ]
   t.notThrows(() => geom2.validate(result4))
+  t.is(measureArea(result4), 11.31370849898476)
   t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 })

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