@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/geometries/geom2/toOutlines.js

@@ -1,47 +1,8 @@
-const vec2 = require('../../maths/vec2')
-
-const toSides = require('./toSides')
-
-/*
- * Create a list of edges which SHARE vertices.
- * This allows the edges to be traversed in order.
- */
-const toSharedVertices = (sides) => {
-  const unique = new Map() // {key: vertex}
-  const getUniqueVertex = (vertex) => {
-    const key = vertex.toString()
-    if (unique.has(key)) {
-      return unique.get(key)
-    } else {
-      unique.set(key, vertex)
-      return vertex
-    }
-  }
-
-  return sides.map((side) => side.map(getUniqueVertex))
-}
-
-/*
- * Convert a list of sides into a map from vertex to edges.
- */
-const toVertexMap = (sides) => {
-  const vertexMap = new Map()
-  // first map to edges with shared vertices
-  const edges = toSharedVertices(sides)
-  // construct adjacent edges map
-  edges.forEach((edge) => {
-    if (vertexMap.has(edge[0])) {
-      vertexMap.get(edge[0]).push(edge)
-    } else {
-      vertexMap.set(edge[0], [edge])
-    }
-  })
-  return vertexMap
-}
+import { applyTransforms } from './applyTransforms.js'
 
 /**
  * Create the outline(s) of the given geometry.
- * @param {geom2} geometry - geometry to create outlines from
+ * @param {Geom2} geometry - geometry to create outlines from
  * @returns {Array} an array of outlines, where each outline is an array of ordered points
  * @alias module:modeling/geometries/geom2.toOutlines
  *
@@ -49,71 +10,4 @@ const toVertexMap = (sides) => {
  * let geometry = subtract(rectangle({size: [5, 5]}), rectangle({size: [3, 3]}))
  * let outlines = toOutlines(geometry) // returns two outlines
  */
-const toOutlines = (geometry) => {
-  const vertexMap = toVertexMap(toSides(geometry)) // {vertex: [edges]}
-  const outlines = []
-  while (true) {
-    let startSide
-    for (const [vertex, edges] of vertexMap) {
-      startSide = edges.shift()
-      if (!startSide) {
-        vertexMap.delete(vertex)
-        continue
-      }
-      break
-    }
-    if (startSide === undefined) break // all starting sides have been visited
-
-    const connectedVertexPoints = []
-    const startVertex = startSide[0]
-    while (true) {
-      connectedVertexPoints.push(startSide[0])
-      const nextVertex = startSide[1]
-      if (nextVertex === startVertex) break // the outline has been closed
-      const nextPossibleSides = vertexMap.get(nextVertex)
-      if (!nextPossibleSides) {
-        throw new Error(`geometry is not closed at vertex ${nextVertex}`)
-      }
-      const nextSide = popNextSide(startSide, nextPossibleSides)
-      if (nextPossibleSides.length === 0) {
-        vertexMap.delete(nextVertex)
-      }
-      startSide = nextSide
-    } // inner loop
-
-    // due to the logic of fromPoints()
-    // move the first point to the last
-    if (connectedVertexPoints.length > 0) {
-      connectedVertexPoints.push(connectedVertexPoints.shift())
-    }
-    outlines.push(connectedVertexPoints)
-  } // outer loop
-  vertexMap.clear()
-  return outlines
-}
-
-// find the first counter-clockwise edge from startSide and pop from nextSides
-const popNextSide = (startSide, nextSides) => {
-  if (nextSides.length === 1) {
-    return nextSides.pop()
-  }
-  const v0 = vec2.create()
-  const startAngle = vec2.angleDegrees(vec2.subtract(v0, startSide[1], startSide[0]))
-  let bestAngle
-  let bestIndex
-  nextSides.forEach((nextSide, index) => {
-    const nextAngle = vec2.angleDegrees(vec2.subtract(v0, nextSide[1], nextSide[0]))
-    let angle = nextAngle - startAngle
-    if (angle < -180) angle += 360
-    if (angle >= 180) angle -= 360
-    if (bestIndex === undefined || angle > bestAngle) {
-      bestIndex = index
-      bestAngle = angle
-    }
-  })
-  const nextSide = nextSides[bestIndex]
-  nextSides.splice(bestIndex, 1) // remove side from list
-  return nextSide
-}
-
-module.exports = toOutlines
+export const toOutlines = (geometry) => applyTransforms(geometry).outlines

package/src/geometries/geom2/toOutlines.test.js

@@ -1,10 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { create } = require('./index')
+import { create, toOutlines } from './index.js'
 
-const { comparePoints } = require('../../../test/helpers')
-
-const toOutlines = require('./toOutlines')
+import { comparePoints } from '../../../test/helpers/index.js'
 
 test('geom2: toOutlines() should return no outlines for empty geom2', (t) => {
   const shp1 = create()
@@ -14,59 +12,49 @@ test('geom2: toOutlines() should return no outlines for empty geom2', (t) => {
 })
 
 test('geom2: toOutlines() should return one or more outlines', (t) => {
-  const shp1 = create([[[-1, -1], [1, -1]],
-    [[1, -1], [1, 1]],
-    [[1, 1], [-1, -1]]])
+  const shp1 = create([[[-1, -1], [1, -1], [1, 1]]])
   const ret1 = toOutlines(shp1)
   const exp1 = [
-    [[1, -1], [1, 1], [-1, -1]]
+    [[-1, -1], [1, -1], [1, 1]]
   ]
   t.true(comparePoints(ret1[0], exp1[0]))
 
-  const shp2 = create([[[-1, -1], [1, -1]],
-    [[1, -1], [1, 1]],
-    [[1, 1], [-1, -1]],
-    [[4, 4], [6, 4]],
-    [[6, 4], [6, 6]],
-    [[6, 6], [4, 4]]])
+  const shp2 = create([
+    [[-1, -1], [1, -1], [1, 1]],
+    [[4, 4], [6, 4], [6, 6]]
+  ])
   const ret2 = toOutlines(shp2)
   const exp2 = [
-    [[1, -1], [1, 1], [-1, -1]],
-    [[6, 4], [6, 6], [4, 4]]
+    [[-1, -1], [1, -1], [1, 1]],
+    [[4, 4], [6, 4], [6, 6]]
   ]
   t.true(comparePoints(ret2[0], exp2[0]))
   t.true(comparePoints(ret2[1], exp2[1]))
 })
 
 test('geom2: toOutlines() should return outlines for holes in geom2', (t) => {
-  const shp1 = create([[[10, 10], [-10, -10]],
-    [[-10, -10], [10, -10]],
-    [[10, -10], [10, 10]],
-    [[5, -5], [6, -4]],
-    [[6, -5], [5, -5]],
-    [[6, -4], [6, -5]]])
+  const shp1 = create([
+    [[10, 10], [-10, -10], [10, -10]],
+    [[5, -5], [6, -4], [6, -4]]
+  ])
   const ret1 = toOutlines(shp1)
   const exp1 = [
-    [[-10, -10], [10, -10], [10, 10]],
-    [[6, -4], [6, -5], [5, -5]]
+    [[10, 10], [-10, -10], [10, -10]],
+    [[5, -5], [6, -4], [6, -4]]
   ]
   t.true(comparePoints(ret1[0], exp1[0]))
   t.true(comparePoints(ret1[1], exp1[1]))
 
-  const shp2 = create([[[6, -4], [5, -5]],
-    [[5, -5], [6, -5]],
-    [[6, -5], [6, -4]],
-    [[10, 10], [-10, -10]],
-    [[-10, -10], [10, -10]],
-    [[10, -10], [10, 10]],
-    [[-6, -8], [8, 6]],
-    [[8, -8], [-6, -8]],
-    [[8, 6], [8, -8]]])
+  const shp2 = create([
+    [[6, -4], [5, -5], [6, -5]],
+    [[10, 10], [-10, -10], [10, -10]],
+    [[-6, -8], [8, 6], [8, -8]]
+  ])
   const ret2 = toOutlines(shp2)
   const exp2 = [
-    [[5, -5], [6, -5], [6, -4]],
-    [[-10, -10], [10, -10], [10, 10]],
-    [[8, 6], [8, -8], [-6, -8]]
+    [[6, -4], [5, -5], [6, -5]],
+    [[10, 10], [-10, -10], [10, -10]],
+    [[-6, -8], [8, 6], [8, -8]]
   ]
   t.true(comparePoints(ret2[0], exp2[0]))
   t.true(comparePoints(ret2[1], exp2[1]))
@@ -75,18 +63,12 @@ test('geom2: toOutlines() should return outlines for holes in geom2', (t) => {
 
 test('geom2: toOutlines() should return outlines for edges that touch in geom2', (t) => {
   const shp1 = create([
-    [[5, 15], [5, 5]],
-    [[5, 5], [15, 5]],
-    [[15, 5], [15, 15]],
-    [[15, 15], [5, 15]],
-    [[-5, 5], [-5, -5]],
-    [[-5, -5], [5, -5]],
-    [[5, -5], [5, 5]],
-    [[5, 5], [-5, 5]]
+    [[5, 15], [5, 5], [15, 5], [15, 15]],
+    [[-5, 5], [-5, -5], [5, -5], [5, 5]]
   ])
   const ret1 = toOutlines(shp1)
   const exp1 = [
-    [[5, 5], [15, 5], [15, 15], [5, 15]],
+    [[5, 15], [5, 5], [15, 5], [15, 15]],
     [[-5, 5], [-5, -5], [5, -5], [5, 5]]
   ]
   t.true(comparePoints(ret1[0], exp1[0]))
@@ -95,24 +77,15 @@ test('geom2: toOutlines() should return outlines for edges that touch in geom2',
 
 test('geom2: toOutlines() should return outlines for holes that touch in geom2', (t) => {
   const shp1 = create([
-    [[-20, 20], [-20, -20]],
-    [[-20, -20], [20, -20]],
-    [[20, -20], [20, 20]],
-    [[20, 20], [-20, 20]],
-    [[5, 5], [5, 15]],
-    [[15, 5], [5, 5]],
-    [[15, 15], [15, 5]],
-    [[5, 15], [15, 15]],
-    [[-5, -5], [-5, 5]],
-    [[5, -5], [-5, -5]],
-    [[5, 5], [5, -5]],
-    [[-5, 5], [5, 5]]
+    [[-20, 20], [-20, -20], [20, -20], [20, 20]],
+    [[5, 5], [5, 15], [15, 15], [15, 5]],
+    [[-5, -5], [-5, 5], [5, 5], [5, -5]]
   ])
   const ret1 = toOutlines(shp1)
   const exp1 = [
-    [[-20, -20], [20, -20], [20, 20], [-20, 20]],
-    [[5, 15], [15, 15], [15, 5], [5, 5]],
-    [[5, -5], [-5, -5], [-5, 5], [5, 5]]
+    [[-20, 20], [-20, -20], [20, -20], [20, 20]],
+    [[5, 5], [5, 15], [15, 15], [15, 5]],
+    [[-5, -5], [-5, 5], [5, 5], [5, -5]]
   ]
   t.true(comparePoints(ret1[0], exp1[0]))
   t.true(comparePoints(ret1[1], exp1[1]))

package/src/geometries/geom2/toPoints.d.ts

@@ -1,6 +1,4 @@
-import Geom2 from './type'
-import Vec2 from '../../maths/vec2/type'
+import type { Geom2 } from './type.d.ts'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
 
-export default toPoints
-
-declare function toPoints(geometry: Geom2): Array<Vec2>
+export function toPoints(geometry: Geom2): Array<Vec2>

package/src/geometries/geom2/toPoints.js

@@ -1,25 +1,22 @@
-const toSides = require('./toSides')
+import { toOutlines } from './toOutlines.js'
 
 /**
  * Produces an array of points from the given geometry.
  * The returned array should not be modified as the points are shared with the geometry.
  * NOTE: The points returned do NOT define an order. Use toOutlines() for ordered points.
- * @param {geom2} geometry - the geometry
+ * @param {Geom2} geometry - the geometry
  * @returns {Array} an array of points
  * @alias module:modeling/geometries/geom2.toPoints
  *
  * @example
- * let sharedpoints = toPoints(geometry)
+ * let sharedPoints = toPoints(geometry)
  */
-const toPoints = (geometry) => {
-  const sides = toSides(geometry)
-  const points = sides.map((side) => side[0])
-  // due to the logic of fromPoints()
-  // move the first point to the last
-  if (points.length > 0) {
-    points.push(points.shift())
-  }
+export const toPoints = (geometry) => {
+  const points = []
+  toOutlines(geometry).forEach((outline) => {
+    outline.forEach((point) => {
+      points.push(point)
+    })
+  })
   return points
 }
-
-module.exports = toPoints

package/src/geometries/geom2/toPoints.test.js

@@ -1,24 +1,24 @@
-const test = require('ava')
+import test from 'ava'
 
-const { toPoints, create, fromPoints, toString } = require('./index')
+import { create, toPoints, toString } from './index.js'
 
-const { comparePoints } = require('../../../test/helpers/')
+import { comparePoints } from '../../../test/helpers/index.js'
 
 test('toPoints: creates an empty array of points from a unpopulated geom2', (t) => {
   const geometry = create()
-  const pointarray = toPoints(geometry)
-  t.deepEqual(pointarray, [])
+  const pointArray = toPoints(geometry)
+  t.deepEqual(pointArray, [])
 })
 
 test('toPoints: creates an array of points from a populated geom2', (t) => {
   const points = [[0, 0], [1, 0], [0, 1]]
-  const geometry = fromPoints(points)
+  const geometry = create([points])
 
   toString(geometry)
 
   const expected = [[0, 0], [1, 0], [0, 1]]
-  const pointarray = toPoints(geometry)
-  t.true(comparePoints(pointarray, expected))
+  const pointArray = toPoints(geometry)
+  t.true(comparePoints(pointArray, expected))
 
   toString(geometry)
 })

package/src/geometries/geom2/toSides.d.ts

@@ -1,6 +1,4 @@
-import Geom2 from './type'
-import Vec2 from '../../maths/vec2/type'
+import type { Geom2 } from './type.d.ts'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
 
-export default toSides
-
-declare function toSides(geometry: Geom2): Array<[Vec2, Vec2]>
+export function toSides(geometry: Geom2): Array<[Vec2, Vec2]>

package/src/geometries/geom2/toSides.js

@@ -1,16 +1,23 @@
-const applyTransforms = require('./applyTransforms')
+import { toOutlines } from './toOutlines.js'
 
 /**
  * Produces an array of sides from the given geometry.
  * The returned array should not be modified as the data is shared with the geometry.
  * NOTE: The sides returned do NOT define an order. Use toOutlines() for ordered points.
- * @param {geom2} geometry - the geometry
+ * @param {Geom2} geometry - the geometry
  * @returns {Array} an array of sides
  * @alias module:modeling/geometries/geom2.toSides
  *
  * @example
- * let sharedsides = toSides(geometry)
+ * let sharedSides = toSides(geometry)
  */
-const toSides = (geometry) => applyTransforms(geometry).sides
-
-module.exports = toSides
+export const toSides = (geometry) => {
+  const sides = []
+  toOutlines(geometry).forEach((outline) => {
+    outline.forEach((point, i) => {
+      const j = (i + 1) % outline.length
+      sides.push([point, outline[j]])
+    })
+  })
+  return sides
+}

package/src/geometries/geom2/toString.d.ts

@@ -1,5 +1,3 @@
-import Geom2 from './type'
+import type { Geom2 } from './type.d.ts'
 
-export default toString
-
-declare function toString(geometry: Geom2): string
+export function toString(geometry: Geom2): string

package/src/geometries/geom2/toString.js

@@ -1,24 +1,22 @@
-const vec2 = require('../../maths/vec2')
+import * as vec2 from '../../maths/vec2/index.js'
 
-const toSides = require('./toSides')
+import { toOutlines } from './toOutlines.js'
 
 /**
  * Create a string representing the contents of the given geometry.
- * @param {geom2} geometry - the geometry
- * @returns {String} a representative string
+ * @param {Geom2} geometry - the geometry
+ * @returns {string} a representative string
  * @alias module:modeling/geometries/geom2.toString
  *
  * @example
  * console.out(toString(geometry))
  */
-const toString = (geometry) => {
-  const sides = toSides(geometry)
-  let result = 'geom2 (' + sides.length + ' sides):\n[\n'
-  sides.forEach((side) => {
-    result += '  [' + vec2.toString(side[0]) + ', ' + vec2.toString(side[1]) + ']\n'
+export const toString = (geometry) => {
+  const outlines = toOutlines(geometry)
+  let result = 'geom2 (' + outlines.length + ' outlines):\n[\n'
+  outlines.forEach((outline) => {
+    result += '  [' + outline.map(vec2.toString).join() + ']\n'
   })
   result += ']\n'
   return result
 }
-
-module.exports = toString

package/src/geometries/geom2/toString.test.js

@@ -0,0 +1,17 @@
+import test from 'ava'
+
+import { create, toString } from './index.js'
+
+test('toString: serialize empty geom2 into a string', (t) => {
+  const geometry = create()
+  const result = toString(geometry)
+  const expected = 'geom2 (0 outlines):\n[\n]\n'
+  t.is(result, expected)
+})
+
+test('toString: serialize geom2 into a string', (t) => {
+  const geometry = create([[[0, 0], [0, 1], [2, 0]]])
+  const result = toString(geometry)
+  const expected = 'geom2 (1 outlines):\n[\n  [[0.0000000, 0.0000000],[0.0000000, 1.0000000],[2.0000000, 0.0000000]]\n]\n'
+  t.is(result, expected)
+})

package/src/geometries/geom2/transform.d.ts

@@ -1,6 +1,4 @@
-import Geom2 from './type'
-import Mat4 from '../../maths/mat4/type'
+import type { Geom2 } from './type.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
 
-export default transform
-
-declare function transform(matrix: Mat4, geometry: Geom2): Geom2
+export function transform(matrix: Mat4, geometry: Geom2): Geom2

package/src/geometries/geom2/transform.js

@@ -1,20 +1,18 @@
-const mat4 = require('../../maths/mat4')
+import * as mat4 from '../../maths/mat4/index.js'
 
 /**
  * Transform the given geometry using the given matrix.
- * This is a lazy transform of the sides, as this function only adjusts the transforms.
- * The transforms are applied when accessing the sides via toSides().
- * @param {mat4} matrix - the matrix to transform with
- * @param {geom2} geometry - the geometry to transform
- * @returns {geom2} a new geometry
+ * This is a lazy transform of the outlines, as this function only adjusts the transforms.
+ * The transforms are applied when accessing the outlines via toOutlines().
+ * @param {Mat4} matrix - the matrix to transform with
+ * @param {Geom2} geometry - the geometry to transform
+ * @returns {Geom2} a new geometry
  * @alias module:modeling/geometries/geom2.transform
  *
  * @example
- * let newgeometry = transform(fromZRotation(degToRad(90)), geometry)
+ * let newGeometry = transform(fromZRotation(TAU / 4), geometry)
  */
-const transform = (matrix, geometry) => {
+export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
   return Object.assign({}, geometry, { transforms })
 }
-
-module.exports = transform

package/src/geometries/geom2/transform.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const mat4 = require('../../maths/mat4')
+import { mat4 } from '../../maths/index.js'
 
-const { transform, fromPoints, toSides } = require('./index')
+import { create, transform, toOutlines, toSides } from './index.js'
 
-const { comparePoints, compareVectors } = require('../../../test/helpers/')
+import { comparePoints, compareVectors } from '../../../test/helpers/index.js'
 
 test('transform: adjusts the transforms of geom2', (t) => {
   const points = [[0, 0], [1, 0], [0, 1]]
@@ -15,39 +15,38 @@ test('transform: adjusts the transforms of geom2', (t) => {
 
   // expect lazy transform, i.e. only the transforms change
   const expected = {
-    sides: [[[0, 1], [0, 0]], [[0, 0], [1, 0]], [[1, 0], [0, 1]]],
+    outlines: [[[0, 0], [1, 0], [0, 1]]],
     transforms: [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
-  const geometry = fromPoints(points)
+  const geometry = create([points])
   let another = transform(rotate90, geometry)
   t.not(geometry, another)
-  t.true(comparePoints(another.sides[0], expected.sides[0]))
-  t.true(comparePoints(another.sides[1], expected.sides[1]))
-  t.true(comparePoints(another.sides[2], expected.sides[2]))
+  t.true(comparePoints(another.outlines[0], expected.outlines[0]))
   t.true(compareVectors(another.transforms, expected.transforms))
 
   // expect lazy transform, i.e. only the transforms change
   expected.transforms = [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 5, 10, 15, 1]
   another = transform(mat4.fromTranslation(mat4.create(), [5, 10, 15]), another)
-  t.true(comparePoints(another.sides[0], expected.sides[0]))
-  t.true(comparePoints(another.sides[1], expected.sides[1]))
-  t.true(comparePoints(another.sides[2], expected.sides[2]))
+  t.true(comparePoints(another.outlines[0], expected.outlines[0]))
   t.true(compareVectors(another.transforms, expected.transforms))
 
   // expect application of the transforms to the sides
-  expected.sides = [[[4, 10], [5, 10]], [[5, 10], [5, 11]], [[5, 11], [4, 10]]]
-  expected.transforms = mat4.create()
-  toSides(another)
-  t.true(comparePoints(another.sides[0], expected.sides[0]))
-  t.true(comparePoints(another.sides[1], expected.sides[1]))
-  t.true(comparePoints(another.sides[2], expected.sides[2]))
-  t.true(compareVectors(another.transforms, expected.transforms))
+  const expectedSides = [[[5, 10], [5, 11]], [[5, 11], [4, 10]], [[4, 10], [5, 10]]]
+  const sides = toSides(another)
+  t.true(comparePoints(sides[0], expectedSides[0]))
+  t.true(comparePoints(sides[1], expectedSides[1]))
+  t.true(comparePoints(sides[2], expectedSides[2]))
+
+  // expect application of the transforms to the outlines
+  const expectedOutline = [[5, 10], [5, 11], [4, 10]]
+  const outlines = toOutlines(another)
+  t.is(outlines.length, 1)
+  t.true(comparePoints(outlines[0], expectedOutline))
 
   // expect lazy transform, i.e. only the transforms change
   expected.transforms = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 5, 10, 15, 1]
+  another.outlines = [[[0, 0], [1, 0], [0, 1]]]
   another = transform(mat4.fromTranslation(mat4.create(), [5, 10, 15]), another)
-  t.true(comparePoints(another.sides[0], expected.sides[0]))
-  t.true(comparePoints(another.sides[1], expected.sides[1]))
-  t.true(comparePoints(another.sides[2], expected.sides[2]))
+  t.true(comparePoints(another.outlines[0], expected.outlines[0]))
   t.true(compareVectors(another.transforms, expected.transforms))
 })

package/src/geometries/geom2/type.d.ts

@@ -1,11 +1,9 @@
-import Vec2 from '../../maths/vec2/type'
-import Mat4 from '../../maths/mat4/type'
-import { Color } from '../types'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
+import type { Color } from '../types.d.ts'
 
-export default Geom2
-
-declare interface Geom2 {
-  sides: Array<[Vec2, Vec2]>
+export interface Geom2 {
+  outlines: Array<Array<Vec2>>
   transforms: Mat4
   color?: Color
 }

package/src/geometries/geom2/validate.d.ts

@@ -1,3 +1 @@
-export default validate
-
-declare function validate(object: any): void
+export function validate(object: any): void