@jbroll/jscad-modeling 2.12.7

package/src/geometries/path2/concat.js

@@ -0,0 +1,36 @@
+const fromPoints = require('./fromPoints')
+const toPoints = require('./toPoints')
+
+const { equals } = require('../../maths/vec2')
+
+/**
+ * Concatenate the given paths.
+ *
+ * If both contain the same point at the junction, merge it into one.
+ * A concatenation of zero paths is an empty, open path.
+ * A concatenation of one closed path to a series of open paths produces a closed path.
+ * A concatenation of a path to a closed path is an error.
+ * @param {...path2} paths - the paths to concatenate
+ * @returns {path2} a new path
+ * @alias module:modeling/geometries/path2.concat
+ *
+ * @example
+ * let newpath = concat(fromPoints({}, [[1, 2]]), fromPoints({}, [[3, 4]]))
+ */
+const concat = (...paths) => {
+  // Only the last path can be closed, producing a closed path.
+  let isClosed = false
+  let newpoints = []
+  paths.forEach((path, i) => {
+    const tmp = toPoints(path).slice()
+    if (newpoints.length > 0 && tmp.length > 0 && equals(tmp[0], newpoints[newpoints.length - 1])) tmp.shift()
+    if (tmp.length > 0 && isClosed) {
+      throw new Error(`Cannot concatenate to a closed path; check the ${i}th path`)
+    }
+    isClosed = path.isClosed
+    newpoints = newpoints.concat(tmp)
+  })
+  return fromPoints({ closed: isClosed }, newpoints)
+}
+
+module.exports = concat

package/src/geometries/path2/concat.test.js

@@ -0,0 +1,35 @@
+const test = require('ava')
+
+const { concat, equals, fromPoints } = require('./index')
+
+test('concat: No paths produces an empty open path', (t) => {
+  t.true(equals(concat(), fromPoints({ closed: false }, [])))
+})
+
+test('concat: empty paths produces an empty open path', (t) => {
+  t.true(equals(concat(fromPoints({}, []), fromPoints({}, [])), fromPoints({ closed: false }, [])))
+})
+
+test('concat: many open paths produces a open path', (t) => {
+  const p1 = fromPoints({ closed: false }, [[0, 0]])
+  const p2 = fromPoints({ closed: false }, [[1, 1]])
+  const p3 = fromPoints({ closed: false }, [[1, 1], [3, 3]])
+
+  const result = concat(p1, p2, p3)
+  t.true(equals(result, fromPoints({}, [[0, 0], [1, 1], [3, 3]])))
+  t.is(p1.points.length, 1)
+  t.is(p2.points.length, 1)
+  t.is(p3.points.length, 2)
+})
+
+test('concat: An open path and a closed path produces a closed path', (t) => {
+  t.true(equals(concat(fromPoints({ closed: false }, [[0, 0]]),
+    fromPoints({ closed: true }, [[1, 1]])),
+  fromPoints({ closed: true }, [[0, 0], [1, 1]])))
+})
+
+test('concat: A closed path and an open path throws an error', (t) => {
+  const p1 = fromPoints({ closed: true }, [[0, 0]])
+  const p2 = fromPoints({ closed: false }, [[1, 1]])
+  t.throws(() => concat(p1, p2), { message: 'Cannot concatenate to a closed path; check the 1th path' })
+})

package/src/geometries/path2/create.d.ts

@@ -0,0 +1,6 @@
+import Path2 from './type'
+import Vec2 from '../../maths/vec2/type'
+
+export default create
+
+declare function create(points?: Array<Vec2>): Path2

package/src/geometries/path2/create.js

@@ -0,0 +1,30 @@
+const mat4 = require('../../maths/mat4')
+
+/**
+ * Represents a 2D geometry consisting of a list of ordered points.
+ * @typedef {Object} path2
+ * @property {Array} points - list of ordered points
+ * @property {Boolean} isClosed - true if the path is closed where start and end points are the same
+ * @property {mat4} transforms - transforms to apply to the points, see transform()
+ */
+
+/**
+ * Create an empty, open path.
+ * @returns {path2} a new path
+ * @alias module:modeling/geometries/path2.create
+ *
+ * @example
+ * let newpath = create()
+ */
+const create = (points) => {
+  if (points === undefined) {
+    points = []
+  }
+  return {
+    points: points,
+    isClosed: false,
+    transforms: mat4.create()
+  }
+}
+
+module.exports = create

package/src/geometries/path2/create.test.js

@@ -0,0 +1,7 @@
+const test = require('ava')
+
+const { create, equals, fromPoints } = require('./index')
+
+test('create: Creates an empty path', (t) => {
+  t.true(equals(create(), fromPoints({ closed: false }, [])))
+})

package/src/geometries/path2/equals.d.ts

@@ -0,0 +1,5 @@
+import Path2 from './type'
+
+export default equals
+
+declare function equals(a: Path2, b: Path2): boolean

package/src/geometries/path2/equals.js

@@ -0,0 +1,47 @@
+const vec2 = require('../../maths/vec2')
+
+const toPoints = require('./toPoints')
+
+/**
+  * Determine if the given paths are equal.
+  * For closed paths, this includes equality under point order rotation.
+  * @param {path2} a - the first path to compare
+  * @param {path2} b - the second path to compare
+  * @returns {Boolean}
+  * @alias module:modeling/geometries/path2.equals
+  */
+const equals = (a, b) => {
+  if (a.isClosed !== b.isClosed) {
+    return false
+  }
+  if (a.points.length !== b.points.length) {
+    return false
+  }
+
+  const apoints = toPoints(a)
+  const bpoints = toPoints(b)
+
+  // closed paths might be equal under graph rotation
+  // so try comparison by rotating across all points
+  const length = apoints.length
+  let offset = 0
+  do {
+    let unequal = false
+    for (let i = 0; i < length; i++) {
+      if (!vec2.equals(apoints[i], bpoints[(i + offset) % length])) {
+        unequal = true
+        break
+      }
+    }
+    if (unequal === false) {
+      return true
+    }
+    // unequal open paths should only be compared once, never rotated
+    if (!a.isClosed) {
+      return false
+    }
+  } while (++offset < length)
+  return false
+}
+
+module.exports = equals

package/src/geometries/path2/equals.test.js

@@ -0,0 +1,38 @@
+const test = require('ava')
+
+const { equals, fromPoints } = require('./index')
+
+test('equals: two paths with different points are not equal', (t) => {
+  const p1 = fromPoints({ closed: false }, [[0, 0], [2, 0], [2, 1]])
+  const p2 = fromPoints({ closed: false }, [[0, 0], [2, 0], [2, 1], [0, 1]])
+  t.false(equals(p1, p2))
+
+  const p3 = fromPoints({ closed: true }, [[2, 0], [2, 1], [0, 1], [1, 0]])
+  const p4 = fromPoints({ closed: true }, [[0, 0], [2, 0], [2, 1], [0, 1]])
+  t.false(equals(p3, p4))
+})
+
+test('equals: two open paths with the same points are equal', (t) => {
+  const p1 = fromPoints({ closed: false }, [[0, 0], [2, 0], [2, 1], [0, 1]])
+  const p2 = fromPoints({ closed: false }, [[0, 0], [2, 0], [2, 1], [0, 1]])
+  t.true(equals(p1, p2))
+})
+
+test('equals: two open paths with the same points rotated are unequal', (t) => {
+  t.false(equals(fromPoints({ closed: false }, [[0, 0], [2, 0], [2, 1], [0, 1]]),
+    fromPoints({ closed: false }, [[2, 0], [2, 1], [0, 1], [0, 0]])))
+})
+
+test('equals: two closed paths with the same points are equal', (t) => {
+  t.true(equals(fromPoints({ closed: true }, [[0, 0], [2, 0], [2, 1], [0, 1]]),
+    fromPoints({ closed: true }, [[0, 0], [2, 0], [2, 1], [0, 1]])))
+
+  // rotated
+  t.true(equals(fromPoints({ closed: true }, [[0, 0], [2, 0], [2, 1], [0, 1]]),
+    fromPoints({ closed: true }, [[2, 0], [2, 1], [0, 1], [0, 0]])))
+})
+
+test('equals: closed path and open path with the same points are unequal', (t) => {
+  t.false(equals(fromPoints({ closed: true }, [[0, 0], [2, 0], [2, 1], [0, 1]]),
+    fromPoints({ closed: false }, [[0, 0], [2, 0], [2, 1], [0, 1]])))
+})

package/src/geometries/path2/fromCompactBinary.d.ts

@@ -0,0 +1,5 @@
+import Path2 from './type'
+
+export default fromCompactBinary
+
+declare function fromCompactBinary(data: Array<number> | Float32Array | Float64Array): Path2

package/src/geometries/path2/fromCompactBinary.js

@@ -0,0 +1,33 @@
+const mat4 = require('../../maths/mat4')
+const vec2 = require('../../maths/vec2')
+
+const create = require('./create')
+
+/**
+ * Create a new path from the given compact binary data.
+ * @param {TypedArray} data - compact binary data
+ * @returns {path2} a new path
+ * @alias module:modeling/geometries/path2.fromCompactBinary
+ */
+const fromCompactBinary = (data) => {
+  if (data[0] !== 2) throw new Error('invalid compact binary data')
+
+  const created = create()
+
+  created.transforms = mat4.clone(data.slice(1, 17))
+
+  created.isClosed = !!data[17]
+
+  for (let i = 22; i < data.length; i += 2) {
+    const point = vec2.fromValues(data[i], data[i + 1])
+    created.points.push(point)
+  }
+  // transfer known properties, i.e. color
+  if (data[18] >= 0) {
+    created.color = [data[18], data[19], data[20], data[21]]
+  }
+  // TODO: how about custom properties or fields ?
+  return created
+}
+
+module.exports = fromCompactBinary

package/src/geometries/path2/fromPoints.d.ts

@@ -0,0 +1,10 @@
+import Path2 from './type'
+import Vec2 from '../../maths/vec2/type'
+
+export default fromPoints
+
+export interface FromPointsOptions {
+  closed?: boolean
+}
+
+declare function fromPoints(options: FromPointsOptions, points: Array<Vec2>): Path2

package/src/geometries/path2/fromPoints.js

@@ -0,0 +1,42 @@
+const { EPS } = require('../../maths/constants')
+
+const vec2 = require('../../maths/vec2')
+
+const close = require('./close')
+const create = require('./create')
+
+/**
+ * Create a new path from the given points.
+ * The points must be provided an array of points,
+ * where each point is an array of two numbers.
+ * @param {Object} options - options for construction
+ * @param {Boolean} [options.closed=false] - if the path should be open or closed
+ * @param {Array} points - array of points (2D) from which to create the path
+ * @returns {path2} a new path
+ * @alias module:modeling/geometries/path2.fromPoints
+ *
+ * @example:
+ * my newpath = fromPoints({closed: true}, [[10, 10], [-10, 10]])
+ */
+const fromPoints = (options, points) => {
+  const defaults = { closed: false }
+  let { closed } = Object.assign({}, defaults, options)
+
+  let created = create()
+  created.points = points.map((point) => vec2.clone(point))
+
+  // check if first and last points are equal
+  if (created.points.length > 1) {
+    const p0 = created.points[0]
+    const pn = created.points[created.points.length - 1]
+    if (vec2.distance(p0, pn) < (EPS * EPS)) {
+      // and close automatically
+      closed = true
+    }
+  }
+  if (closed === true) created = close(created)
+
+  return created
+}
+
+module.exports = fromPoints

package/src/geometries/path2/fromPoints.test.js

@@ -0,0 +1,33 @@
+const test = require('ava')
+
+const vec2 = require('../../maths/vec2')
+
+const { fromPoints, toPoints, toString } = require('./index')
+
+test('fromPoints: creating a path from no points produces an open, empty non-canonical path', (t) => {
+  const created = fromPoints({}, [])
+  t.false(created.isClosed)
+  t.deepEqual(toPoints(created), [])
+})
+
+test('fromPoints: creating a path from one point produces a open, non-canonical path', (t) => {
+  const created = fromPoints({}, [[1, 1]])
+  toString(created)
+
+  t.false(created.isClosed)
+  t.deepEqual(toPoints(created), [vec2.fromValues(1, 1)])
+})
+
+test('fromPoints: creating a closed path from one point produces a closed, non-canonical path', (t) => {
+  const created = fromPoints({ closed: true }, [[1, 1]])
+  t.true(created.isClosed)
+  t.deepEqual(toPoints(created), [vec2.fromValues(1, 1)])
+
+  toString(created)
+})
+
+test('fromPoints: creating a path from a closed set of points creates a closed, non-canonical path', (t) => {
+  const created = fromPoints({ closed: false }, [[0, 0], [1, 0], [1, 1], [0, 0]])
+  t.true(created.isClosed)
+  t.is(3, created.points.length) // the last given point is dropped
+})

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

@@ -0,0 +1,114 @@
+const test = require('ava')
+
+const { fromCompactBinary, toCompactBinary, create, fromPoints } = require('./index')
+
+test('toCompactBinary: converts path2 into a compact form', (t) => {
+  const geometry1 = create()
+  const compacted1 = toCompactBinary(geometry1)
+  const expected1 = new Float32Array(
+    [
+      2, // type
+      1, 0, 0, 0, // transforms
+      0, 1, 0, 0,
+      0, 0, 1, 0,
+      0, 0, 0, 1,
+      0, // isClosed
+      -1, -1, -1, -1 // color
+    ]
+  )
+
+  t.deepEqual(compacted1, expected1)
+
+  const points = [[0, 0], [1, 0], [0, 1]]
+  const geometry2 = fromPoints({ closed: true }, points)
+  const compacted2 = toCompactBinary(geometry2)
+  const expected2 = new Float32Array(
+    [
+      2, // type
+      1, 0, 0, 0, // transforms
+      0, 1, 0, 0,
+      0, 0, 1, 0,
+      0, 0, 0, 1,
+      1, // closed/open flag
+      -1, -1, -1, -1, // color
+      0, 0, // points
+      1, 0,
+      0, 1
+    ]
+  )
+
+  t.deepEqual(compacted2, expected2)
+
+  // test color as well
+  geometry2.color = [1, 2, 3, 4]
+  const compacted3 = toCompactBinary(geometry2)
+  const expected3 = new Float32Array(
+    [
+      2, // type
+      1, 0, 0, 0, // transforms
+      0, 1, 0, 0,
+      0, 0, 1, 0,
+      0, 0, 0, 1,
+      1, // closed/open flag
+      1, 2, 3, 4, // color
+      0, 0, // points
+      1, 0,
+      0, 1
+    ]
+  )
+
+  t.deepEqual(compacted3, expected3)
+})
+
+test('fromCompactBinary: convert a compact form into a path2', (t) => {
+  const compacted1 = [
+    2, // type
+    1, 0, 0, 0, // transforms
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1,
+    0, // isClosed
+    -1, -1, -1, -1 // color
+  ]
+  const expected1 = create()
+  const geometry1 = fromCompactBinary(compacted1)
+
+  t.deepEqual(geometry1, expected1)
+
+  const compacted2 = [
+    2, // type
+    1, 0, 0, 0, // transforms
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1,
+    1, // closed/open flag
+    -1, -1, -1, -1, // color
+    0, 0, // points
+    1, 0,
+    0, 1
+  ]
+  const points = [[0, 0], [1, 0], [0, 1]]
+  const expected2 = fromPoints({ closed: true }, points)
+  const geometry2 = fromCompactBinary(compacted2)
+
+  t.deepEqual(geometry2, expected2)
+
+  // test color as well
+  const compacted3 = [
+    2, // type
+    1, 0, 0, 0, // transforms
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1,
+    1, // closed/open flag
+    5, 6, 7, 8, // color
+    0, 0, // points
+    1, 0,
+    0, 1
+  ]
+  const expected3 = fromPoints({ closed: true }, points)
+  expected3.color = [5, 6, 7, 8]
+  const geometry3 = fromCompactBinary(compacted3)
+
+  t.deepEqual(geometry3, expected3)
+})

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

@@ -0,0 +1,20 @@
+export { default as appendArc, AppendArcOptions } from './appendArc'
+export { default as appendBezier, AppendBezierOptions } from './appendBezier'
+export { default as appendPoints } from './appendPoints'
+export { default as clone } from './clone'
+export { default as close } from './close'
+export { default as concat } from './concat'
+export { default as create } from './create'
+export { default as equals } from './equals'
+export { default as fromPoints, FromPointsOptions } from './fromPoints'
+export { default as fromCompactBinary } from './fromCompactBinary'
+export { default as isA } from './isA'
+export { default as reverse } from './reverse'
+export { default as toPoints } from './toPoints'
+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 Path2 } from './type'
+export as namespace path2

package/src/geometries/path2/index.js

@@ -0,0 +1,35 @@
+/**
+ * Represents a 2D geometry consisting of a list of ordered points.
+ * @see {@link path2} for data structure information.
+ * @module modeling/geometries/path2
+ *
+ * @example
+ * colorize([0,0,0,1], path2.fromPoints({ closed: true }, [[0,0], [4,0], [4,3]]))
+ *
+ * @example
+ * {
+ *   "points": [[0,0], [4,0], [4,3]],
+ *   "isClosed": true,
+ *   "transforms": [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
+ *   "color": [0,0,0,1]
+ * }
+ */
+module.exports = {
+  appendArc: require('./appendArc'),
+  appendBezier: require('./appendBezier'),
+  appendPoints: require('./appendPoints'),
+  clone: require('./clone'),
+  close: require('./close'),
+  concat: require('./concat'),
+  create: require('./create'),
+  equals: require('./equals'),
+  fromPoints: require('./fromPoints'),
+  fromCompactBinary: require('./fromCompactBinary'),
+  isA: require('./isA'),
+  reverse: require('./reverse'),
+  toPoints: require('./toPoints'),
+  toString: require('./toString'),
+  toCompactBinary: require('./toCompactBinary'),
+  transform: require('./transform'),
+  validate: require('./validate')
+}

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

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

package/src/geometries/path2/isA.js

@@ -0,0 +1,20 @@
+/**
+ * Determine if the given object is a path2 geometry.
+ * @param {Object} object - the object to interrogate
+ * @returns {Boolean} true if the object matches a path2
+ * @alias module:modeling/geometries/path2.isA
+ */
+const isA = (object) => {
+  if (object && typeof object === 'object') {
+    // see create for the required attributes and types
+    if ('points' in object && 'transforms' in object && 'isClosed' in object) {
+      // NOTE: transforms should be a TypedArray, which has a read-only length
+      if (Array.isArray(object.points) && 'length' in object.transforms) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+module.exports = isA

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

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

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

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

package/src/geometries/path2/reverse.js

@@ -0,0 +1,20 @@
+const clone = require('./clone')
+
+/**
+ * Reverses the path so that the points are in the opposite order.
+ * This swaps the left (interior) and right (exterior) edges.
+ * @param {path2} geometry - the path to reverse
+ * @returns {path2} a new path
+ * @alias module:modeling/geometries/path2.reverse
+ *
+ * @example
+ * let newpath = reverse(mypath)
+ */
+const reverse = (geometry) => {
+  // NOTE: this only updates the order of the points
+  const cloned = clone(geometry)
+  cloned.points = geometry.points.slice().reverse()
+  return cloned
+}
+
+module.exports = reverse

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

@@ -0,0 +1,9 @@
+const test = require('ava')
+
+const { reverse, equals, fromPoints } = require('./index')
+
+test('reverse: The reverse of a path has reversed points', (t) => {
+  const pointArray = [[0, 0], [1, 1]]
+  t.false(equals(reverse(fromPoints({}, pointArray)),
+    fromPoints({}, pointArray)))
+})

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

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

package/src/geometries/path2/toCompactBinary.js

@@ -0,0 +1,52 @@
+/**
+ * Produce a compact binary representation from the given path.
+ * @param {path2} geometry - the path geometry
+ * @returns {TypedArray} compact binary representation
+ * @alias module:modeling/geometries/path2.toCompactBinary
+ */
+const toCompactBinary = (geometry) => {
+  const points = geometry.points
+  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 + 1 + 4 + (points.length * 2)) // type + transforms + isClosed + color + points data
+
+  compacted[0] = 2 // 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] = geometry.isClosed ? 1 : 0
+
+  compacted[18] = color[0]
+  compacted[19] = color[1]
+  compacted[20] = color[2]
+  compacted[21] = color[3]
+
+  for (let j = 0; j < points.length; j++) {
+    const ci = j * 2 + 22
+    const point = points[j]
+    compacted[ci] = point[0]
+    compacted[ci + 1] = point[1]
+  }
+  // TODO: how about custom properties or fields ?
+  return compacted
+}
+
+module.exports = toCompactBinary

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

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