@jbroll/jscad-modeling 2.12.7

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

@@ -0,0 +1,122 @@
+const test = require('ava')
+
+const { fromCompactBinary, toCompactBinary, create } = require('./index')
+
+test('toCompactBinary: converts geom2 into a compact form', (t) => {
+  const geometry1 = create()
+  const compacted1 = toCompactBinary(geometry1)
+  const expected1 = new Float32Array([
+    0, // type flag
+    1, 0, 0, 0, // transforms
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1,
+    -1, -1, -1, -1 // color
+  ])
+  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 compacted2 = toCompactBinary(geometry2)
+  const expected2 = new Float32Array([
+    0, // type flag
+    1, 0, 0, 0, // transforms
+    0, 1, 0, 0,
+    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
+  ])
+  t.deepEqual(compacted2, expected2)
+
+  // test color as well
+  geometry2.color = [1, 2, 3, 4]
+  const compacted3 = toCompactBinary(geometry2)
+  const expected3 = new Float32Array([
+    0, // type flag
+    1, 0, 0, 0, // transforms
+    0, 1, 0, 0,
+    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
+  ])
+  t.deepEqual(compacted3, expected3)
+})
+
+test('fromCompactBinary: convert a compact form into a geom2', (t) => {
+  const compacted1 = [
+    0, // type flag
+    1, 0, 0, 0, // transforms
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1,
+    -1, -1, -1, -1 // color
+  ]
+  const expected1 = create()
+  const geometry1 = fromCompactBinary(compacted1)
+
+  t.deepEqual(geometry1, expected1)
+
+  // geometry with a hole
+  const compacted2 = [
+    0, // type flag
+    1, 0, 0, 0, // transforms
+    0, 1, 0, 0,
+    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
+  ]
+  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]]
+  ])
+  const geometry2 = fromCompactBinary(compacted2)
+
+  t.deepEqual(geometry2, expected2)
+
+  // test color as well
+  const compacted3 = [
+    0, // type flag
+    1, 0, 0, 0, // transforms
+    0, 1, 0, 0,
+    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
+  ]
+  expected2.color = [4, 5, 6, 7]
+  const geometry3 = fromCompactBinary(compacted3)
+
+  t.deepEqual(geometry3, expected2)
+})

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

@@ -0,0 +1,16 @@
+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 { default as Geom2 } from './type'
+export as namespace geom2

package/src/geometries/geom2/index.js

@@ -0,0 +1,30 @@
+/**
+ * Represents a 2D geometry consisting of a list of sides.
+ * @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]
+ * }
+ */
+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')
+}

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

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

package/src/geometries/geom2/isA.js

@@ -0,0 +1,18 @@
+/**
+ * Determine if the given object is a 2D geometry.
+ * @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) => {
+  if (object && typeof object === 'object') {
+    if ('sides' in object && 'transforms' in object) {
+      if (Array.isArray(object.sides) && 'length' in object.transforms) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+module.exports = isA

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

@@ -0,0 +1,19 @@
+const test = require('ava')
+
+const { isA, create, fromPoints } = require('./index')
+
+test('isA: identifies created geom2', (t) => {
+  const p1 = create()
+  const p2 = fromPoints([[0, 0], [1, 0], [1, 1]])
+  t.true(isA(p1))
+  t.true(isA(p2))
+})
+
+test('isA: identifies non geom2', (t) => {
+  const p1 = null
+  const p2 = {}
+  const p3 = { sides: 1, transforms: 1 }
+  t.false(isA(p1))
+  t.false(isA(p2))
+  t.false(isA(p3))
+})

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

@@ -0,0 +1,5 @@
+import Geom2 from './type'
+
+export default reverse
+
+declare function reverse(geometry: Geom2): Geom2

package/src/geometries/geom2/reverse.js

@@ -0,0 +1,22 @@
+const create = require('./create')
+const toSides = require('./toSides')
+
+/**
+ * Reverses the given geometry so that the sides 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
+ * @alias module:modeling/geometries/geom2.reverse
+ *
+ * @example
+ * 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)
+}
+
+module.exports = reverse

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

@@ -0,0 +1,20 @@
+const test = require('ava')
+
+const { reverse, fromPoints } = require('./index')
+
+const { comparePoints, compareVectors } = require('../../../test/helpers/')
+
+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]]],
+    transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+  }
+  const geometry = fromPoints(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(compareVectors(another.transforms, expected.transforms))
+})

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

@@ -0,0 +1,5 @@
+import Geom2 from './type'
+
+export default toCompactBinary
+
+declare function toCompactBinary(geom: Geom2): Float32Array

package/src/geometries/geom2/toCompactBinary.js

@@ -0,0 +1,53 @@
+/**
+ * Produces a compact binary representation from the given geometry.
+ * @param {geom2} geometry - the geometry
+ * @returns {TypedArray} compact binary representation
+ * @alias module:modeling/geometries/geom2.toCompactBinary
+ */
+const toCompactBinary = (geometry) => {
+  const sides = geometry.sides
+  const transforms = geometry.transforms
+  let color = [-1, -1, -1, -1]
+  if (geometry.color) color = geometry.color
+
+  // FIXME why Float32Array?
+  const compacted = new Float32Array(1 + 16 + 4 + (sides.length * 4)) // type + transforms + color + sides data
+
+  compacted[0] = 0 // type code: 0 => geom2, 1 => geom3 , 2 => path2
+
+  compacted[1] = transforms[0]
+  compacted[2] = transforms[1]
+  compacted[3] = transforms[2]
+  compacted[4] = transforms[3]
+  compacted[5] = transforms[4]
+  compacted[6] = transforms[5]
+  compacted[7] = transforms[6]
+  compacted[8] = transforms[7]
+  compacted[9] = transforms[8]
+  compacted[10] = transforms[9]
+  compacted[11] = transforms[10]
+  compacted[12] = transforms[11]
+  compacted[13] = transforms[12]
+  compacted[14] = transforms[13]
+  compacted[15] = transforms[14]
+  compacted[16] = transforms[15]
+
+  compacted[17] = color[0]
+  compacted[18] = color[1]
+  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]
+  }
+  // TODO: how about custom properties or fields ?
+  return compacted
+}
+
+module.exports = toCompactBinary

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

@@ -0,0 +1,6 @@
+import Geom2 from './type'
+import Vec2 from '../../maths/vec2/type'
+
+export default toOutlines
+
+declare function toOutlines(geometry: Geom2): Array<Array<Vec2>>

package/src/geometries/geom2/toOutlines.js

@@ -0,0 +1,119 @@
+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
+}
+
+/**
+ * Create the outline(s) of the given geometry.
+ * @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
+ *
+ * @example
+ * 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

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

@@ -0,0 +1,122 @@
+const test = require('ava')
+
+const { create } = require('./index')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const toOutlines = require('./toOutlines')
+
+test('geom2: toOutlines() should return no outlines for empty geom2', (t) => {
+  const shp1 = create()
+  const exp1 = []
+  const ret1 = toOutlines(shp1)
+  t.true(comparePoints(exp1, ret1))
+})
+
+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 ret1 = toOutlines(shp1)
+  const exp1 = [
+    [[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 ret2 = toOutlines(shp2)
+  const exp2 = [
+    [[1, -1], [1, 1], [-1, -1]],
+    [[6, 4], [6, 6], [4, 4]]
+  ]
+  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 ret1 = toOutlines(shp1)
+  const exp1 = [
+    [[-10, -10], [10, -10], [10, 10]],
+    [[6, -4], [6, -5], [5, -5]]
+  ]
+  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 ret2 = toOutlines(shp2)
+  const exp2 = [
+    [[5, -5], [6, -5], [6, -4]],
+    [[-10, -10], [10, -10], [10, 10]],
+    [[8, 6], [8, -8], [-6, -8]]
+  ]
+  t.true(comparePoints(ret2[0], exp2[0]))
+  t.true(comparePoints(ret2[1], exp2[1]))
+  t.true(comparePoints(ret2[2], exp2[2]))
+})
+
+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]]
+  ])
+  const ret1 = toOutlines(shp1)
+  const exp1 = [
+    [[5, 5], [15, 5], [15, 15], [5, 15]],
+    [[-5, 5], [-5, -5], [5, -5], [5, 5]]
+  ]
+  t.true(comparePoints(ret1[0], exp1[0]))
+  t.true(comparePoints(ret1[1], exp1[1]))
+})
+
+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]]
+  ])
+  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]]
+  ]
+  t.true(comparePoints(ret1[0], exp1[0]))
+  t.true(comparePoints(ret1[1], exp1[1]))
+  t.true(comparePoints(ret1[2], exp1[2]))
+})
+
+// touching holes

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

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

package/src/geometries/geom2/toPoints.js

@@ -0,0 +1,25 @@
+const toSides = require('./toSides')
+
+/**
+ * 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
+ * @returns {Array} an array of points
+ * @alias module:modeling/geometries/geom2.toPoints
+ *
+ * @example
+ * 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())
+  }
+  return points
+}
+
+module.exports = toPoints

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

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

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

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

package/src/geometries/geom2/toSides.js

@@ -0,0 +1,16 @@
+const applyTransforms = require('./applyTransforms')
+
+/**
+ * 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
+ * @returns {Array} an array of sides
+ * @alias module:modeling/geometries/geom2.toSides
+ *
+ * @example
+ * let sharedsides = toSides(geometry)
+ */
+const toSides = (geometry) => applyTransforms(geometry).sides
+
+module.exports = toSides

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

@@ -0,0 +1,5 @@
+import Geom2 from './type'
+
+export default toString
+
+declare function toString(geometry: Geom2): string