@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/geometries/geom2/fromCompactBinary.js

@@ -1,26 +1,36 @@
-const mat4 = require('../../maths/mat4')
-const vec2 = require('../../maths/vec2')
+import * as mat4 from '../../maths/mat4/index.js'
+import * as vec2 from '../../maths/vec2/index.js'
 
-const create = require('./create')
+import { create } from './create.js'
 
 /**
  * Create a new 2D geometry from the given compact binary data.
  * @param {Array} data - compact binary data
- * @returns {geom2} a new geometry
+ * @returns {Geom2} a new geometry
  * @alias module:modeling/geometries/geom2.fromCompactBinary
  */
-const fromCompactBinary = (data) => {
+export const fromCompactBinary = (data) => {
   if (data[0] !== 0) throw new Error('invalid compact binary data')
 
   const created = create()
 
   created.transforms = mat4.clone(data.slice(1, 17))
 
-  for (let i = 21; i < data.length; i += 4) {
-    const point0 = vec2.fromValues(data[i + 0], data[i + 1])
-    const point1 = vec2.fromValues(data[i + 2], data[i + 3])
-    created.sides.push([point0, point1])
+  for (let i = 21; i < data.length;) {
+    const length = data[i++] // number of points for this polygon
+    if (length < 0 || i + length * 2 > data.length) {
+      throw new Error('invalid compact binary data')
+    }
+    const outline = []
+    for (let j = 0; j < length; j++) {
+      const x = data[i + j * 2]
+      const y = data[i + j * 2 + 1]
+      outline.push(vec2.fromValues(x, y))
+    }
+    created.outlines.push(outline)
+    i += length * 2
   }
+
   // transfer known properties, i.e. color
   if (data[17] >= 0) {
     created.color = [data[17], data[18], data[19], data[20]]
@@ -28,5 +38,3 @@ const fromCompactBinary = (data) => {
   // TODO: how about custom properties or fields ?
   return created
 }
-
-module.exports = fromCompactBinary

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

@@ -0,0 +1,4 @@
+import type { Geom2 } from './type.d.ts'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
+
+export function fromSides(sides: Array<[Vec2, Vec2]>): Geom2

package/src/geometries/geom2/fromSides.js

@@ -0,0 +1,115 @@
+import * as vec2 from '../../maths/vec2/index.js'
+
+import { create } from './create.js'
+
+/*
+ * Create a list of edges which SHARE points.
+ * This allows the edges to be traversed in order.
+ */
+const toSharedPoints = (sides) => {
+  const unique = new Map() // {key: point}
+  const getUniquePoint = (point) => {
+    const key = point.toString()
+    if (unique.has(key)) {
+      return unique.get(key)
+    } else {
+      unique.set(key, point)
+      return point
+    }
+  }
+
+  return sides.map((side) => side.map(getUniquePoint))
+}
+
+/*
+ * Convert a list of sides into a map from point to edges.
+ */
+const toPointMap = (sides) => {
+  const pointMap = new Map()
+  // first map to edges with shared vertices
+  const edges = toSharedPoints(sides)
+  // construct adjacent edges map
+  edges.forEach((edge) => {
+    if (pointMap.has(edge[0])) {
+      pointMap.get(edge[0]).push(edge)
+    } else {
+      pointMap.set(edge[0], [edge])
+    }
+  })
+  return pointMap
+}
+
+/**
+ * Create a new 2D geometry from a list of sides.
+ * @param {Array} sides - list of sides to create outlines from
+ * @returns {Geom2} a new geometry
+ *
+ * @example
+ * let geometry = fromSides([[[0, 0], [1, 0]], [[1, 0], [1, 1]], [[1, 1], [0, 0]]])
+ */
+export const fromSides = (sides) => {
+  const pointMap = toPointMap(sides) // {point: [edges]}
+  const outlines = []
+  while (true) {
+    let startSide
+    for (const [point, edges] of pointMap) {
+      startSide = edges.shift()
+      if (!startSide) {
+        pointMap.delete(point)
+        continue
+      }
+      break
+    }
+    if (startSide === undefined) break // all starting sides have been visited
+
+    const connectedPoints = []
+    const startPoint = startSide[0]
+    while (true) {
+      connectedPoints.push(startSide[0])
+      const nextPoint = startSide[1]
+      if (nextPoint === startPoint) break // the outline has been closed
+      const nextPossibleSides = pointMap.get(nextPoint)
+      if (!nextPossibleSides) {
+        throw new Error(`geometry is not closed at point ${nextPoint}`)
+      }
+      const nextSide = popNextSide(startSide, nextPossibleSides)
+      if (nextPossibleSides.length === 0) {
+        pointMap.delete(nextPoint)
+      }
+      startSide = nextSide
+    } // inner loop
+
+    // due to the logic of fromPoints()
+    // move the first point to the last
+    if (connectedPoints.length > 0) {
+      connectedPoints.push(connectedPoints.shift())
+    }
+    outlines.push(connectedPoints)
+  } // outer loop
+  pointMap.clear()
+  return create(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
+}

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

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { fromCompactBinary, toCompactBinary, create } = require('./index')
+import { fromCompactBinary, toCompactBinary, create } from './index.js'
 
 test('toCompactBinary: converts geom2 into a compact form', (t) => {
   const geometry1 = create()
@@ -16,12 +16,10 @@ test('toCompactBinary: converts geom2 into a compact form', (t) => {
   t.deepEqual(compacted1, expected1)
 
   // geometry with a hole
-  const geometry2 = 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 geometry2 = create([
+    [[10, 10], [-10, -10], [10, -10]],
+    [[5, -5], [6, -4], [6, -5]]
+  ])
   const compacted2 = toCompactBinary(geometry2)
   const expected2 = new Float32Array([
     0, // type flag
@@ -30,12 +28,8 @@ test('toCompactBinary: converts geom2 into a compact form', (t) => {
     0, 0, 1, 0,
     0, 0, 0, 1,
     -1, -1, -1, -1, // color
-    10, 10, -10, -10, // sides
-    -10, -10, 10, -10,
-    10, -10, 10, 10,
-    5, -5, 6, -4,
-    6, -5, 5, -5,
-    6, -4, 6, -5
+    3, 10, 10, -10, -10, 10, -10, // poly1
+    3, 5, -5, 6, -4, 6, -5 // poly2
   ])
   t.deepEqual(compacted2, expected2)
 
@@ -49,12 +43,8 @@ test('toCompactBinary: converts geom2 into a compact form', (t) => {
     0, 0, 1, 0,
     0, 0, 0, 1,
     1, 2, 3, 4, // color
-    10, 10, -10, -10, // sides
-    -10, -10, 10, -10,
-    10, -10, 10, 10,
-    5, -5, 6, -4,
-    6, -5, 5, -5,
-    6, -4, 6, -5
+    3, 10, 10, -10, -10, 10, -10, // poly1
+    3, 5, -5, 6, -4, 6, -5 // poly2
   ])
   t.deepEqual(compacted3, expected3)
 })
@@ -81,20 +71,12 @@ test('fromCompactBinary: convert a compact form into a geom2', (t) => {
     0, 0, 1, 0,
     0, 0, 0, 1,
     -1, -1, -1, -1, // color
-    10, 10, -10, -10, // sides
-    -10, -10, 10, -10,
-    10, -10, 10, 10,
-    5, -5, 6, -4,
-    6, -5, 5, -5,
-    6, -4, 6, -5
+    3, 10, 10, -10, -10, 10, -10, // poly1
+    3, 5, -5, 6, -5, 6, -4 // poly2
   ]
   const expected2 = 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]]
+    [[10, 10], [-10, -10], [10, -10]],
+    [[5, -5], [6, -5], [6, -4]]
   ])
   const geometry2 = fromCompactBinary(compacted2)
 
@@ -108,12 +90,8 @@ test('fromCompactBinary: convert a compact form into a geom2', (t) => {
     0, 0, 1, 0,
     0, 0, 0, 1,
     4, 5, 6, 7, // color
-    10, 10, -10, -10, // sides
-    -10, -10, 10, -10,
-    10, -10, 10, 10,
-    5, -5, 6, -4,
-    6, -5, 5, -5,
-    6, -4, 6, -5
+    3, 10, 10, -10, -10, 10, -10, // poly1
+    3, 5, -5, 6, -5, 6, -4 // poly2
   ]
   expected2.color = [4, 5, 6, 7]
   const geometry3 = fromCompactBinary(compacted3)

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

@@ -1,16 +1,15 @@
-export { default as clone } from './clone'
-export { default as create } from './create'
-export { default as fromPoints } from './fromPoints'
-export { default as fromCompactBinary } from './fromCompactBinary'
-export { default as isA } from './isA'
-export { default as reverse } from './reverse'
-export { default as toOutlines } from './toOutlines'
-export { default as toPoints } from './toPoints'
-export { default as toSides } from './toSides'
-export { default as toString } from './toString'
-export { default as toCompactBinary } from './toCompactBinary'
-export { default as transform } from './transform'
-export { default as validate } from './validate'
+export { clone } from './clone.js'
+export { create } from './create.js'
+export { fromSides } from './fromSides.js'
+export { fromCompactBinary } from './fromCompactBinary.js'
+export { isA } from './isA.js'
+export { reverse } from './reverse.js'
+export { toOutlines } from './toOutlines.js'
+export { toPoints } from './toPoints.js'
+export { toSides } from './toSides.js'
+export { toString } from './toString.js'
+export { toCompactBinary } from './toCompactBinary.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'
 
-export { default as Geom2 } from './type'
-export as namespace geom2
+export type { Geom2 } from './type.d.ts'

package/src/geometries/geom2/index.js

@@ -1,30 +1,23 @@
 /**
- * Represents a 2D geometry consisting of a list of sides.
+ * Represents a 2D geometry consisting of outlines, where each outline is an ordered list of points.
+ * The outline is always closed between the first and last points.
  * @see {@link geom2} for data structure information.
  * @module modeling/geometries/geom2
  *
  * @example
- * colorize([0.5,0,1,1], square()) // purple square
- *
- * @example
- * {
- *   "sides": [[[-1,1],[-1,-1]],[[-1,-1],[1,-1]],[[1,-1],[1,1]],[[1,1],[-1,1]]],
- *   "transforms": [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
- *   "color": [0.5,0,1,1]
- * }
+ * import { geometries } from '@jscad/modeling'
+ * let myShape = geometries.geom2.create([ [[-1,-1], [1,-1], [1,1], [-1,1]] ])
  */
-module.exports = {
-  clone: require('./clone'),
-  create: require('./create'),
-  fromPoints: require('./fromPoints'),
-  fromCompactBinary: require('./fromCompactBinary'),
-  isA: require('./isA'),
-  reverse: require('./reverse'),
-  toOutlines: require('./toOutlines'),
-  toPoints: require('./toPoints'),
-  toSides: require('./toSides'),
-  toString: require('./toString'),
-  toCompactBinary: require('./toCompactBinary'),
-  transform: require('./transform'),
-  validate: require('./validate')
-}
+export { clone } from './clone.js'
+export { create } from './create.js'
+export { fromSides } from './fromSides.js'
+export { fromCompactBinary } from './fromCompactBinary.js'
+export { isA } from './isA.js'
+export { reverse } from './reverse.js'
+export { toOutlines } from './toOutlines.js'
+export { toPoints } from './toPoints.js'
+export { toSides } from './toSides.js'
+export { toString } from './toString.js'
+export { toCompactBinary } from './toCompactBinary.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'

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

@@ -1,5 +1,3 @@
-import Geom2 from './type'
+import type { Geom2 } from './type.d.ts'
 
-export default isA
-
-declare function isA(object: any): object is Geom2
+export function isA(object: any): object is Geom2

package/src/geometries/geom2/isA.js

@@ -1,18 +1,16 @@
 /**
  * Determine if the given object is a 2D geometry.
- * @param {Object} object - the object to interrogate
+ * @param {object} object - the object to interrogate
  * @returns {Boolean} true, if the object matches a geom2 based object
  * @alias module:modeling/geometries/geom2.isA
  */
-const isA = (object) => {
+export const isA = (object) => {
   if (object && typeof object === 'object') {
-    if ('sides' in object && 'transforms' in object) {
-      if (Array.isArray(object.sides) && 'length' in object.transforms) {
+    if ('outlines' in object && 'transforms' in object) {
+      if (Array.isArray(object.outlines) && 'length' in object.transforms) {
         return true
       }
     }
   }
   return false
 }
-
-module.exports = isA

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

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { isA, create, fromPoints } = require('./index')
+import { isA, create } from './index.js'
 
 test('isA: identifies created geom2', (t) => {
   const p1 = create()
-  const p2 = fromPoints([[0, 0], [1, 0], [1, 1]])
+  const p2 = create([[[0, 0], [1, 0], [1, 1]]])
   t.true(isA(p1))
   t.true(isA(p2))
 })
@@ -13,7 +13,9 @@ test('isA: identifies non geom2', (t) => {
   const p1 = null
   const p2 = {}
   const p3 = { sides: 1, transforms: 1 }
+  const p4 = { outlines: 1, transforms: 1 }
   t.false(isA(p1))
   t.false(isA(p2))
   t.false(isA(p3))
+  t.false(isA(p4))
 })

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

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

package/src/geometries/geom2/reverse.js

@@ -1,22 +1,20 @@
-const create = require('./create')
-const toSides = require('./toSides')
+import { create } from './create.js'
+import { toOutlines } from './toOutlines.js'
 
 /**
- * Reverses the given geometry so that the sides are flipped in the opposite order.
+ * Reverses the given geometry so that the outline points are flipped in the opposite order.
  * This swaps the left (interior) and right (exterior) edges.
- * @param {geom2} geometry - the geometry to reverse
- * @returns {geom2} the new reversed geometry
+ * @param {Geom2} geometry - the geometry to reverse
+ * @returns {Geom2} the new reversed geometry
  * @alias module:modeling/geometries/geom2.reverse
  *
  * @example
- * let newgeometry = reverse(geometry)
+ * let newGeometry = reverse(geometry)
  */
-const reverse = (geometry) => {
-  const oldsides = toSides(geometry)
-
-  const newsides = oldsides.map((side) => [side[1], side[0]])
-  newsides.reverse() // is this required?
-  return create(newsides)
+export const reverse = (geometry) => {
+  const outlines = toOutlines(geometry)
+    .map((outline) => outline.slice().reverse())
+  const reversed = create(outlines)
+  if (geometry.color) reversed.color = geometry.color
+  return reversed
 }
-
-module.exports = reverse

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

@@ -1,20 +1,40 @@
-const test = require('ava')
+import test from 'ava'
 
-const { reverse, fromPoints } = require('./index')
+import { colorize } from '../../colors/index.js'
 
-const { comparePoints, compareVectors } = require('../../../test/helpers/')
+import { create, reverse, toPoints } from './index.js'
 
-test('reverse: Reverses a populated geom2', (t) => {
+import { comparePoints, compareVectors } from '../../../test/helpers/index.js'
+
+test('reverse: reverses a populated geom2', (t) => {
   const points = [[0, 0], [1, 0], [0, 1]]
   const expected = {
-    sides: [[[0, 1], [1, 0]], [[1, 0], [0, 0]], [[0, 0], [0, 1]]],
+    outlines: [[[0, 1], [1, 0], [0, 0]]],
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
-  const geometry = fromPoints(points)
+  const geometry = create([points])
   const another = reverse(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))
 })
+
+test('reverse: does not modify input geometry', (t) => {
+  const points = [[0, 0], [1, 0], [0, 1]]
+  // expected:
+  const forward = [[0, 0], [1, 0], [0, 1]]
+  const backward = [[0, 1], [1, 0], [0, 0]]
+
+  const geometry = create([points])
+  const another = reverse(geometry)
+  t.not(geometry, another)
+  t.true(comparePoints(toPoints(geometry), forward))
+  t.true(comparePoints(toPoints(another), backward))
+})
+
+test('reverse: preserves color', (t) => {
+  const points = [[0, 0], [1, 0], [0, 1]]
+  const geometry = colorize([1, 0, 0], create([points]))
+  const reversed = reverse(geometry)
+  t.deepEqual(reversed.color, [1, 0, 0, 1])
+})

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

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

package/src/geometries/geom2/toCompactBinary.js

@@ -1,17 +1,22 @@
 /**
  * Produces a compact binary representation from the given geometry.
- * @param {geom2} geometry - the geometry
+ * @param {Geom2} geometry - the geometry
  * @returns {TypedArray} compact binary representation
  * @alias module:modeling/geometries/geom2.toCompactBinary
  */
-const toCompactBinary = (geometry) => {
-  const sides = geometry.sides
+export const toCompactBinary = (geometry) => {
   const transforms = geometry.transforms
   let color = [-1, -1, -1, -1]
   if (geometry.color) color = geometry.color
 
+  // Compute array size
+  let size = 21
+  geometry.outlines.forEach((outline) => {
+    size += 2 * outline.length + 1
+  })
+
   // FIXME why Float32Array?
-  const compacted = new Float32Array(1 + 16 + 4 + (sides.length * 4)) // type + transforms + color + sides data
+  const compacted = new Float32Array(size) // type + transforms + color + points
 
   compacted[0] = 0 // type code: 0 => geom2, 1 => geom3 , 2 => path2
 
@@ -37,17 +42,15 @@ const toCompactBinary = (geometry) => {
   compacted[19] = color[2]
   compacted[20] = color[3]
 
-  for (let i = 0; i < sides.length; i++) {
-    const ci = i * 4 + 21
-    const point0 = sides[i][0]
-    const point1 = sides[i][1]
-    compacted[ci + 0] = point0[0]
-    compacted[ci + 1] = point0[1]
-    compacted[ci + 2] = point1[0]
-    compacted[ci + 3] = point1[1]
-  }
+  let index = 21
+  geometry.outlines.forEach((outline) => {
+    compacted[index++] = outline.length
+    outline.forEach((point) => {
+      compacted[index++] = point[0]
+      compacted[index++] = point[1]
+    })
+  })
+
   // TODO: how about custom properties or fields ?
   return compacted
 }
-
-module.exports = toCompactBinary

package/src/geometries/geom2/toOutlines.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 toOutlines
-
-declare function toOutlines(geometry: Geom2): Array<Array<Vec2>>
+export function toOutlines(geometry: Geom2): Array<Array<Vec2>>