@jbroll/jscad-modeling 2.12.7

package/src/geometries/path2/toPoints.js

@@ -0,0 +1,15 @@
+const applyTransforms = require('./applyTransforms')
+
+/**
+ * Produces an array of points from the given geometry.
+ * The returned array should not be modified as the data is shared with the geometry.
+ * @param {path2} geometry - the geometry
+ * @returns {Array} an array of points
+ * @alias module:modeling/geometries/path2.toPoints
+ *
+ * @example
+ * let sharedpoints = toPoints(geometry)
+ */
+const toPoints = (geometry) => applyTransforms(geometry).points
+
+module.exports = toPoints

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

@@ -0,0 +1,13 @@
+const test = require('ava')
+
+const vec2 = require('../../maths/vec2')
+
+const { toPoints, fromPoints } = require('./index')
+
+test('toPoints: An empty path produces an empty point array', (t) => {
+  t.deepEqual(toPoints(fromPoints({}, [])), [])
+})
+
+test('toPoints: An non-empty open path produces a matching point array', (t) => {
+  t.deepEqual(toPoints(fromPoints({}, [[1, 1]])), [vec2.fromValues(1, 1)])
+})

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

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

package/src/geometries/path2/toString.js

@@ -0,0 +1,24 @@
+const vec2 = require('../../maths/vec2')
+
+const toPoints = require('./toPoints')
+
+/**
+ * Create a string representing the contents of the given path.
+ * @param {path2} geometry - the path
+ * @returns {String} a representative string
+ * @alias module:modeling/geometries/path2.toString
+ *
+ * @example
+ * console.out(toString(path))
+ */
+const toString = (geometry) => {
+  const points = toPoints(geometry)
+  let result = 'path (' + points.length + ' points, ' + geometry.isClosed + '):\n[\n'
+  points.forEach((point) => {
+    result += '  ' + vec2.toString(point) + ',\n'
+  })
+  result += ']\n'
+  return result
+}
+
+module.exports = toString

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

@@ -0,0 +1,6 @@
+import Path2 from './type'
+import Mat4 from '../../maths/mat4/type'
+
+export default transform
+
+declare function transform(matrix: Mat4, geometry: Path2): Path2

package/src/geometries/path2/transform.js

@@ -0,0 +1,20 @@
+const mat4 = require('../../maths/mat4')
+
+/**
+ * Transform the given geometry using the given matrix.
+ * This is a lazy transform of the points, as this function only adjusts the transforms.
+ * The transforms are applied when accessing the points via toPoints().
+ * @param {mat4} matrix - the matrix to transform with
+ * @param {path2} geometry - the geometry to transform
+ * @returns {path2} a new path
+ * @alias module:modeling/geometries/path2.transform
+ *
+ * @example
+ * let newpath = transform(fromZRotation(TAU / 8), path)
+ */
+const transform = (matrix, geometry) => {
+  const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  return Object.assign({}, geometry, { transforms })
+}
+
+module.exports = transform

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

@@ -0,0 +1,50 @@
+const test = require('ava')
+
+const mat4 = require('../../maths/mat4')
+
+const { transform, fromPoints, toPoints } = require('./index')
+
+const { comparePoints, compareVectors } = require('../../../test/helpers/')
+
+test('transform: adjusts the transforms of path', (t) => {
+  const points = [[0, 0], [1, 0], [0, 1]]
+  const rotation = 90 * 0.017453292519943295
+  const rotate90 = mat4.fromZRotation(mat4.create(), rotation)
+
+  // continue with typical user scenario, several iterations of transforms and access
+
+  // expect lazy transform, i.e. only the transforms change
+  const expected = {
+    points: [[0, 0], [1, 0], [0, 1]],
+    isClosed: false,
+    transforms: [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+  }
+  const geometry = fromPoints({}, points)
+  let another = transform(rotate90, geometry)
+  t.not(geometry, another)
+  t.true(comparePoints(another.points, expected.points))
+  t.false(another.isClosed)
+  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.points, expected.points))
+  t.false(another.isClosed)
+  t.true(compareVectors(another.transforms, expected.transforms))
+
+  // expect application of the transforms to the sides
+  expected.points = [[5, 10], [5, 11], [4, 10]]
+  expected.transforms = mat4.create()
+  toPoints(another)
+  t.true(comparePoints(another.points, expected.points))
+  t.false(another.isClosed)
+  t.true(compareVectors(another.transforms, expected.transforms))
+
+  // 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 = transform(mat4.fromTranslation(mat4.create(), [5, 10, 15]), another)
+  t.true(comparePoints(another.points, expected.points))
+  t.false(another.isClosed)
+  t.true(compareVectors(another.transforms, expected.transforms))
+})

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

@@ -0,0 +1,12 @@
+import Vec2 from '../../maths/vec2/type'
+import Mat4 from '../../maths/mat4/type'
+import { Color } from '../types'
+
+export default Path2
+
+declare interface Path2 {
+  points: Array<Vec2>
+  isClosed: boolean
+  transforms: Mat4
+  color?: Color
+}

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

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

package/src/geometries/path2/validate.js

@@ -0,0 +1,41 @@
+const vec2 = require('../../maths/vec2')
+const isA = require('./isA')
+
+/**
+ * Determine if the given object is a valid path2.
+ * Checks for valid data points, and duplicate points.
+ *
+ * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
+ *
+ * @param {Object} object - the object to interrogate
+ * @throws {Error} error if the geometry is not valid
+ * @alias module:modeling/geometries/path2.validate
+ */
+const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid path2 structure')
+  }
+
+  // check for duplicate points
+  if (object.points.length > 1) {
+    for (let i = 0; i < object.points.length; i++) {
+      if (vec2.equals(object.points[i], object.points[(i + 1) % object.points.length])) {
+        throw new Error(`path2 duplicate points ${object.points[i]}`)
+      }
+    }
+  }
+
+  // check for infinity, nan
+  object.points.forEach((point) => {
+    if (!point.every(Number.isFinite)) {
+      throw new Error(`path2 invalid point ${point}`)
+    }
+  })
+
+  // check transforms
+  if (!object.transforms.every(Number.isFinite)) {
+    throw new Error(`path2 invalid transforms ${object.transforms}`)
+  }
+}
+
+module.exports = validate

package/src/geometries/poly2/arePointsInside.d.ts

@@ -0,0 +1,6 @@
+import Poly2 from './type'
+import Vec2 from '../../maths/vec2/type'
+
+export default arePointsInside
+
+declare function arePointsInside(points: Array<Vec2>, polygon: Poly2): number

package/src/geometries/poly2/arePointsInside.js

@@ -0,0 +1,83 @@
+const measureArea = require('./measureArea')
+const flip = require('./flip')
+
+/**
+ * Determine if the given points are inside the given polygon.
+ *
+ * @param {Array} points - a list of points, where each point is an array with X and Y values
+ * @param {poly2} polygon - a 2D polygon
+ * @return {Integer} 1 if all points are inside, 0 if some or none are inside
+ * @alias module:modeling/geometries/poly2.arePointsInside
+ */
+const arePointsInside = (points, polygon) => {
+  if (points.length === 0) return 0 // nothing to check
+
+  const vertices = polygon.vertices
+  if (vertices.length < 3) return 0 // nothing can be inside an empty polygon
+
+  if (measureArea(polygon) < 0) {
+    polygon = flip(polygon) // CCW is required
+  }
+
+  const sum = points.reduce((acc, point) => acc + isPointInside(point, vertices), 0)
+  return sum === points.length ? 1 : 0
+}
+
+/*
+ * Determine if the given point is inside the polygon.
+ *
+ * @see http://erich.realtimerendering.com/ptinpoly/ (Crossings Test)
+ * @param {Array} point - an array with X and Y values
+ * @param {Array} polygon - a list of points, where each point is an array with X and Y values
+ * @return {Integer} 1 if the point is inside, 0 if outside
+ */
+const isPointInside = (point, polygon) => {
+  const numverts = polygon.length
+
+  const tx = point[0]
+  const ty = point[1]
+
+  let vtx0 = polygon[numverts - 1]
+  let vtx1 = polygon[0]
+
+  let yflag0 = (vtx0[1] > ty)
+
+  let insideFlag = 0
+
+  let i = 0
+  for (let j = (numverts + 1); --j;) {
+    /*
+     * check if Y endpoints straddle (are on opposite sides) of point's Y
+     * if so, +X ray could intersect this edge.
+     */
+    const yflag1 = (vtx1[1] > ty)
+    if (yflag0 !== yflag1) {
+      /*
+       * check if X endpoints are on same side of the point's X
+       * if so, it's easy to test if edge hits or misses.
+       */
+      const xflag0 = (vtx0[0] > tx)
+      const xflag1 = (vtx1[0] > tx)
+      if (xflag0 && xflag1) {
+        /* if edge's X values are both right of the point, then the point must be inside */
+        insideFlag = !insideFlag
+      } else {
+        /*
+         * if X endpoints straddle the point, then
+         * the compute intersection of polygon edge with +X ray
+         * if intersection >= point's X then the +X ray hits it.
+         */
+        if ((vtx1[0] - (vtx1[1] - ty) * (vtx0[0] - vtx1[0]) / (vtx0[1] - vtx1[1])) >= tx) {
+          insideFlag = !insideFlag
+        }
+      }
+    }
+    /* move to next pair of vertices, retaining info as possible */
+    yflag0 = yflag1
+    vtx0 = vtx1
+    vtx1 = polygon[++i]
+  }
+  return insideFlag
+}
+
+module.exports = arePointsInside

package/src/geometries/poly2/arePointsInside.test.js

@@ -0,0 +1,77 @@
+const test = require('ava')
+
+const { arePointsInside, create } = require('./index')
+
+test('poly2: arePointsInside() should return proper values', (t) => {
+  let polygon = create()
+  let obs = arePointsInside([], polygon)
+  t.is(obs, 0)
+
+  polygon = create([[1, 1], [2, 2], [3, 3]])
+  obs = arePointsInside([], polygon)
+  t.is(obs, 0)
+
+  polygon = create([[0, 0], [5, 0], [5, 5], [0, 5]])
+  // points overlapping points
+  obs = arePointsInside([[0, 0]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[5, 0]], polygon)
+  // t.is(obs, 0) // FAILS
+  obs = arePointsInside([[5, 5]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[0, 5]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[0, 0], [5, 0], [5, 5], [0, 5]], polygon)
+  t.is(obs, 0)
+
+  // points inside
+  obs = arePointsInside([[1, 1]], polygon)
+  t.is(obs, 1)
+  obs = arePointsInside([[2, 2]], polygon)
+  t.is(obs, 1)
+  obs = arePointsInside([[3, 3]], polygon)
+  t.is(obs, 1)
+  obs = arePointsInside([[4, 4]], polygon)
+  t.is(obs, 1)
+  obs = arePointsInside([[1, 1], [2, 2], [3, 3], [4, 4]], polygon)
+  t.is(obs, 1)
+
+  // points on edges
+  obs = arePointsInside([[1, 0], [2, 0], [3, 5], [4, 5]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[5, 1], [5, 2], [5, 3], [5, 4]], polygon)
+  // t.is(obs, 0) // FAILS
+  obs = arePointsInside([[1, 5], [2, 5], [3, 5], [4, 5]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[0, 1], [0, 2], [0, 3], [0, 4]], polygon)
+  t.is(obs, 0)
+
+  // points outside
+  obs = arePointsInside([[-1, 0]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[-1, 1]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[0, -1]], polygon)
+  t.is(obs, 0)
+
+  obs = arePointsInside([[6, 0]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[5, -1]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[6, -1]], polygon)
+  t.is(obs, 0)
+
+  obs = arePointsInside([[6, 5]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[5, 6]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[6, 6]], polygon)
+  t.is(obs, 0)
+
+  obs = arePointsInside([[-1, 5]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[0, 6]], polygon)
+  t.is(obs, 0)
+  obs = arePointsInside([[-1, 6]], polygon)
+  t.is(obs, 0)
+})

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

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

package/src/geometries/poly2/create.js

@@ -0,0 +1,24 @@
+/**
+ * Represents a convex 2D polygon consisting of a list of ordered vertices.
+ * @typedef {Object} poly2
+ * @property {Array} vertices - list of ordered vertices (2D)
+ */
+
+/**
+ * Creates a new polygon with initial values.
+ *
+ * @param {Array} [vertices] - list of vertices (2D)
+ * @returns {poly2} a new polygon
+ * @alias module:modeling/geometries/poly2.create
+ *
+ * @example
+ * let polygon = create()
+ */
+const create = (vertices) => {
+  if (vertices === undefined || vertices.length < 3) {
+    vertices = [] // empty contents
+  }
+  return { vertices: vertices }
+}
+
+module.exports = create

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

@@ -0,0 +1,13 @@
+const test = require('ava')
+
+const { create } = require('./index')
+
+test('poly2: create() should return a poly2 with initial values', (t) => {
+  let obs = create()
+  let exp = { vertices: [] }
+  t.deepEqual(obs, exp)
+
+  obs = create([[1, 1], [2, 2], [3, 3]])
+  exp = { vertices: [[1, 1], [2, 2], [3, 3]] }
+  t.deepEqual(obs, exp)
+})

package/src/geometries/poly2/flip.d.ts

@@ -0,0 +1,5 @@
+import Poly2 from './type'
+
+export default flip
+
+declare function flip(polygon: Poly2): Poly2

package/src/geometries/poly2/flip.js

@@ -0,0 +1,15 @@
+const create = require('./create')
+
+/**
+ * Flip the give polygon, rotating the opposite direction.
+ *
+ * @param {poly2} polygon - the polygon to flip
+ * @returns {poly2} a new polygon
+ * @alias module:modeling/geometries/poly2.flip
+ */
+const flip = (polygon) => {
+  const vertices = polygon.vertices.slice().reverse()
+  return create(vertices)
+}
+
+module.exports = flip

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

@@ -0,0 +1,7 @@
+export { default as arePointsInside } from './arePointsInside'
+export { default as create } from './create'
+export { default as flip } from './flip'
+export { default as measureArea } from './measureArea'
+
+export { default as Poly2 } from './type'
+export as namespace poly2

package/src/geometries/poly2/index.js

@@ -0,0 +1,17 @@
+/**
+ * Represents a 2D polygon consisting of a list of ordered vertices.
+ * @see {@link poly2} for data structure information.
+ * @module modeling/geometries/poly2
+ *
+ * @example
+ * poly2.create([[0,0], [4,0], [4,3]])
+ *
+ * @example
+ * {"vertices": [[0,0], [4,0], [4,3]]}
+ */
+module.exports = {
+  arePointsInside: require('./arePointsInside'),
+  create: require('./create'),
+  flip: require('./flip'),
+  measureArea: require('./measureArea')
+}

package/src/geometries/poly2/measureArea.d.ts

@@ -0,0 +1,5 @@
+import Poly2 from './type'
+
+export default measureArea
+
+declare function measureArea(polygon: Poly2): number

package/src/geometries/poly2/measureArea.js

@@ -0,0 +1,12 @@
+/**
+ * Measure the area under the given polygon.
+ *
+ * @param {poly2} polygon - the polygon to measure
+ * @return {Number} the area of the polygon
+ * @alias module:modeling/geometries/poly2.measureArea
+ */
+const area = require('../../maths/utils/area')
+
+const measureArea = (polygon) => area(polygon.vertices)
+
+module.exports = measureArea

package/src/geometries/poly2/measureArea.test.js

@@ -0,0 +1,44 @@
+const test = require('ava')
+
+const { measureArea, create } = require('./index')
+
+test('poly2: measureArea() should return correct values', (t) => {
+  const ply1 = create()
+  const ret1 = measureArea(ply1)
+  t.is(ret1, 0.0)
+
+  // simple triangle
+  let ply2 = create([[0, 0], [10, 0], [10, 10]])
+  let ret2 = measureArea(ply2)
+  t.is(ret2, 50.0)
+
+  ply2 = create([[10, 10], [10, 0], [0, 0]])
+  ret2 = measureArea(ply2)
+  t.is(ret2, -50.0)
+
+  // simple square
+  let ply3 = create([[0, 0], [10, 0], [10, 10], [0, 10]])
+  let ret3 = measureArea(ply3)
+  t.is(ret3, 100.0)
+
+  ply3 = create([[0, 10], [10, 10], [10, 0], [0, 0]])
+  ret3 = measureArea(ply3)
+  t.is(ret3, -100.0)
+
+  // V-shape
+  const points = [
+    [3, 0],
+    [5, 0],
+    [8, 2],
+    [6, 5],
+    [8, 6],
+    [5, 6],
+    [5, 2],
+    [2, 5],
+    [1, 3],
+    [3, 3]
+  ]
+  const ply4 = create(points)
+  const ret4 = measureArea(ply4)
+  t.is(ret4, 19.5)
+})

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

@@ -0,0 +1,7 @@
+import Vec2 from '../../maths/vec2/type'
+
+export default Poly2
+
+declare interface Poly2 {
+  vertices: Array<Vec2>
+}

package/src/geometries/poly3/clone.d.ts

@@ -0,0 +1,6 @@
+import Poly3 from './type'
+
+export default clone
+
+declare function clone(polygon: Poly3): Poly3
+declare function clone(out: Poly3, polygon: Poly3): Poly3

package/src/geometries/poly3/clone.js

@@ -0,0 +1,28 @@
+const create = require('./create')
+
+const vec3 = require('../../maths/vec3')
+
+/**
+ * Create a deep clone of the given polygon
+ *
+ * @param {poly3} [out] - receiving polygon
+ * @param {poly3} polygon - polygon to clone
+ * @returns {poly3} a new polygon
+ * @alias module:modeling/geometries/poly3.clone
+ */
+const clone = (...params) => {
+  let out
+  let poly3
+  if (params.length === 1) {
+    out = create()
+    poly3 = params[0]
+  } else {
+    out = params[0]
+    poly3 = params[1]
+  }
+  // deep clone of vertices
+  out.vertices = poly3.vertices.map((vec) => vec3.clone(vec))
+  return out
+}
+
+module.exports = clone

package/src/geometries/poly3/clone.test.js

@@ -0,0 +1,35 @@
+const test = require('ava')
+const { create, clone, fromPoints } = require('./index')
+
+const { comparePolygons } = require('../../../test/helpers/index')
+
+test('poly3: clone() should return a new poly3 with same values', (t) => {
+  const org1 = create()
+  const ret1 = clone(org1)
+  t.true(comparePolygons(ret1, org1))
+  t.not(ret1, org1)
+
+  const org2 = fromPoints([[1, 1, 0], [-1, 1, 0], [-1, -1, 0], [1, -1, 0]])
+  const ret2 = clone(org2)
+  t.true(comparePolygons(ret2, org2))
+  t.not(ret2, org2)
+})
+
+test('poly3: clone() with two params should update a poly3 with same values', (t) => {
+  const org1 = create()
+  const out1 = create()
+  const ret1 = clone(out1, org1)
+  t.true(comparePolygons(org1, out1))
+  t.true(comparePolygons(org1, ret1))
+  t.not(out1, org1)
+  t.not(ret1, org1)
+  t.is(ret1, out1)
+
+  const org2 = fromPoints([[1, 1, 0], [-1, 1, 0], [-1, -1, 0], [1, -1, 0]])
+  const out2 = create()
+  const ret2 = clone(out2, org2)
+  t.true(comparePolygons(ret2, org2))
+  t.not(out2, org2)
+  t.not(ret2, org2)
+  t.is(ret2, out2)
+})

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

@@ -0,0 +1,6 @@
+import Poly3 from './type'
+import Vec3 from '../../maths/vec3/type'
+
+export default create
+
+declare function create(vertices?: Array<Vec3>): Poly3

package/src/geometries/poly3/create.js

@@ -0,0 +1,24 @@
+
+/**
+ * Represents a convex 3D polygon. The vertices used to initialize a polygon must
+ * be coplanar and form a convex shape. The vertices do not have to be `vec3`
+ * instances but they must behave similarly.
+ * @typedef {Object} poly3
+ * @property {Array} vertices - list of ordered vertices (3D)
+ */
+
+/**
+ * Creates a new 3D polygon with initial values.
+ *
+ * @param {Array} [vertices] - a list of vertices (3D)
+ * @returns {poly3} a new polygon
+ * @alias module:modeling/geometries/poly3.create
+ */
+const create = (vertices) => {
+  if (vertices === undefined || vertices.length < 3) {
+    vertices = [] // empty contents
+  }
+  return { vertices }
+}
+
+module.exports = create

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

@@ -0,0 +1,9 @@
+const test = require('ava')
+
+const { create } = require('./index')
+
+test('poly3: create() should return a poly3 with initial values', (t) => {
+  const obs = create()
+  const exp = { vertices: [] }
+  t.deepEqual(obs, exp)
+})

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

@@ -0,0 +1,6 @@
+import Poly3 from './type'
+import Vec3 from '../../maths/vec3/type'
+
+export default fromPoints
+
+declare function fromPoints(points: Array<Vec3>): Poly3