@jbroll/jscad-modeling 2.12.7

package/src/operations/hulls/quickhull/Vertex.js

@@ -0,0 +1,21 @@
+/*
+ * Original source from quickhull3d (https://github.com/mauriciopoppe/quickhull3d)
+ * Copyright (c) 2015 Mauricio Poppe
+ *
+ * Adapted to JSCAD by Jeff Gay
+ */
+
+class Vertex {
+  constructor (point, index) {
+    this.point = point
+    // index in the input array
+    this.index = index
+    // vertex is a double linked list node
+    this.next = null
+    this.prev = null
+    // the face that is able to see this point
+    this.face = null
+  }
+}
+
+module.exports = Vertex

package/src/operations/hulls/quickhull/VertexList.js

@@ -0,0 +1,146 @@
+/*
+ * Original source from quickhull3d (https://github.com/mauriciopoppe/quickhull3d)
+ * Copyright (c) 2015 Mauricio Poppe
+ *
+ * Adapted to JSCAD by Jeff Gay
+ */
+
+class VertexList {
+  constructor () {
+    this.head = null
+    this.tail = null
+  }
+
+  clear () {
+    this.head = this.tail = null
+  }
+
+  /**
+   * Inserts a `node` before `target`, it's assumed that
+   * `target` belongs to this doubly linked list
+   *
+   * @param {*} target
+   * @param {*} node
+   */
+  insertBefore (target, node) {
+    node.prev = target.prev
+    node.next = target
+    if (!node.prev) {
+      this.head = node
+    } else {
+      node.prev.next = node
+    }
+    target.prev = node
+  }
+
+  /**
+   * Inserts a `node` after `target`, it's assumed that
+   * `target` belongs to this doubly linked list
+   *
+   * @param {Vertex} target
+   * @param {Vertex} node
+   */
+  insertAfter (target, node) {
+    node.prev = target
+    node.next = target.next
+    if (!node.next) {
+      this.tail = node
+    } else {
+      node.next.prev = node
+    }
+    target.next = node
+  }
+
+  /**
+   * Appends a `node` to the end of this doubly linked list
+   * Note: `node.next` will be unlinked from `node`
+   * Note: if `node` is part of another linked list call `addAll` instead
+   *
+   * @param {*} node
+   */
+  add (node) {
+    if (!this.head) {
+      this.head = node
+    } else {
+      this.tail.next = node
+    }
+    node.prev = this.tail
+    // since node is the new end it doesn't have a next node
+    node.next = null
+    this.tail = node
+  }
+
+  /**
+   * Appends a chain of nodes where `node` is the head,
+   * the difference with `add` is that it correctly sets the position
+   * of the node list `tail` property
+   *
+   * @param {*} node
+   */
+  addAll (node) {
+    if (!this.head) {
+      this.head = node
+    } else {
+      this.tail.next = node
+    }
+    node.prev = this.tail
+
+    // find the end of the list
+    while (node.next) {
+      node = node.next
+    }
+    this.tail = node
+  }
+
+  /**
+   * Deletes a `node` from this linked list, it's assumed that `node` is a
+   * member of this linked list
+   *
+   * @param {*} node
+   */
+  remove (node) {
+    if (!node.prev) {
+      this.head = node.next
+    } else {
+      node.prev.next = node.next
+    }
+
+    if (!node.next) {
+      this.tail = node.prev
+    } else {
+      node.next.prev = node.prev
+    }
+  }
+
+  /**
+   * Removes a chain of nodes whose head is `a` and whose tail is `b`,
+   * it's assumed that `a` and `b` belong to this list and also that `a`
+   * comes before `b` in the linked list
+   *
+   * @param {*} a
+   * @param {*} b
+   */
+  removeChain (a, b) {
+    if (!a.prev) {
+      this.head = b.next
+    } else {
+      a.prev.next = b.next
+    }
+
+    if (!b.next) {
+      this.tail = a.prev
+    } else {
+      b.next.prev = a.prev
+    }
+  }
+
+  first () {
+    return this.head
+  }
+
+  isEmpty () {
+    return !this.head
+  }
+}
+
+module.exports = VertexList

package/src/operations/hulls/quickhull/get-plane-normal.js

@@ -0,0 +1,20 @@
+const cross = require('../../../maths/vec3/cross')
+const normalize = require('../../../maths/vec3/normalize')
+const subtract = require('../../../maths/vec3/subtract')
+
+/*
+ * Original source from quickhull3d (https://github.com/mauriciopoppe/quickhull3d)
+ * Copyright (c) 2015 Mauricio Poppe
+ *
+ * Adapted to JSCAD by Jeff Gay
+ */
+
+const planeNormal = (out, point1, point2, point3) => {
+  const tmp = [0, 0, 0]
+  subtract(out, point1, point2)
+  subtract(tmp, point2, point3)
+  cross(out, out, tmp)
+  return normalize(out, out)
+}
+
+module.exports = planeNormal

package/src/operations/hulls/quickhull/index.js

@@ -0,0 +1,16 @@
+const QuickHull = require('./QuickHull')
+
+/*
+ * Original source from quickhull3d (https://github.com/mauriciopoppe/quickhull3d)
+ * Copyright (c) 2015 Mauricio Poppe
+ *
+ * Adapted to JSCAD by Jeff Gay
+ */
+
+const runner = (points, options = {}) => {
+  const instance = new QuickHull(points)
+  instance.build()
+  return instance.collectFaces(options.skipTriangulation)
+}
+
+module.exports = runner

package/src/operations/hulls/quickhull/point-line-distance.js

@@ -0,0 +1,42 @@
+const cross = require('../../../maths/vec3/cross')
+const subtract = require('../../../maths/vec3/subtract')
+const squaredLength = require('../../../maths/vec3/squaredLength')
+
+/*
+ * Original source from quickhull3d (https://github.com/mauriciopoppe/quickhull3d)
+ * Copyright (c) 2015 Mauricio Poppe
+ *
+ * Adapted to JSCAD by Jeff Gay
+ */
+
+const distanceSquared = (p, a, b) => {
+  // == parallelogram solution
+  //
+  //            s
+  //      __a________b__
+  //       /   |    /
+  //      /   h|   /
+  //     /_____|__/
+  //    p
+  //
+  //  s = b - a
+  //  area = s * h
+  //  |ap x s| = s * h
+  //  h = |ap x s| / s
+  //
+  const ab = []
+  const ap = []
+  const cr = []
+  subtract(ab, b, a)
+  subtract(ap, p, a)
+  const area = squaredLength(cross(cr, ap, ab))
+  const s = squaredLength(ab)
+  if (s === 0) {
+    throw Error('a and b are the same point')
+  }
+  return area / s
+}
+
+const pointLineDistance = (point, a, b) => Math.sqrt(distanceSquared(point, a, b))
+
+module.exports = pointLineDistance

package/src/operations/hulls/toUniquePoints.js

@@ -0,0 +1,34 @@
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const path2 = require('../../geometries/path2')
+
+/*
+ * Return the unique vertices of a geometry
+ */
+const toUniquePoints = (geometries) => {
+  const found = new Set()
+  const uniquePoints = []
+
+  const addPoint = (point) => {
+    const key = point.toString()
+    if (!found.has(key)) {
+      uniquePoints.push(point)
+      found.add(key)
+    }
+  }
+
+  geometries.forEach((geometry) => {
+    if (geom2.isA(geometry)) {
+      geom2.toPoints(geometry).forEach(addPoint)
+    } else if (geom3.isA(geometry)) {
+      // points are grouped by polygon
+      geom3.toPoints(geometry).forEach((points) => points.forEach(addPoint))
+    } else if (path2.isA(geometry)) {
+      path2.toPoints(geometry).forEach(addPoint)
+    }
+  })
+
+  return uniquePoints
+}
+
+module.exports = toUniquePoints

package/src/operations/modifiers/generalize.d.ts

@@ -0,0 +1,12 @@
+import { Geometry } from '../../geometries/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export interface GeneralizeOptions {
+  snap?: boolean
+  simplify?: boolean
+  triangulate?: boolean
+}
+
+export function generalize<T extends Geometry>(options: GeneralizeOptions, geometry: T): T
+export function generalize<T extends Geometry>(options: GeneralizeOptions, ...geometries: RecursiveArray<T>): Array<T>
+export function generalize(options: GeneralizeOptions, ...geometries: RecursiveArray<Geometry>): Array<Geometry>

package/src/operations/modifiers/generalize.js

@@ -0,0 +1,82 @@
+const flatten = require('../../utils/flatten')
+
+const measureEpsilon = require('../../measurements/measureEpsilon')
+
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const path2 = require('../../geometries/path2')
+
+const snapPolygons = require('./snapPolygons')
+const mergePolygons = require('./mergePolygons')
+const insertTjunctions = require('./insertTjunctions')
+const triangulatePolygons = require('./triangulatePolygons')
+
+/*
+ */
+const generalizePath2 = (options, geometry) => geometry
+
+/*
+ */
+const generalizeGeom2 = (options, geometry) => geometry
+
+/*
+ */
+const generalizeGeom3 = (options, geometry) => {
+  const defaults = {
+    snap: false,
+    simplify: false,
+    triangulate: false
+  }
+  const { snap, simplify, triangulate } = Object.assign({}, defaults, options)
+
+  const epsilon = measureEpsilon(geometry)
+  let polygons = geom3.toPolygons(geometry)
+
+  // snap the given geometry if requested
+  if (snap) {
+    polygons = snapPolygons(epsilon, polygons)
+  }
+
+  // simplify the polygons if requested
+  if (simplify) {
+    // TODO implement some mesh decimations
+    polygons = mergePolygons(epsilon, polygons)
+  }
+
+  // triangulate the polygons if requested
+  if (triangulate) {
+    polygons = insertTjunctions(polygons)
+    polygons = triangulatePolygons(epsilon, polygons)
+  }
+
+  // FIXME replace with geom3.cloneShallow() when available
+  const clone = Object.assign({}, geometry)
+  clone.polygons = polygons
+
+  return clone
+}
+
+/**
+ * Apply various modifications in proper order to produce a generalized geometry.
+ * @param {Object} options - options for modifications
+ * @param {Boolean} [options.snap=false] the geometries should be snapped to epsilons
+ * @param {Boolean} [options.simplify=false] the geometries should be simplified
+ * @param {Boolean} [options.triangulate=false] the geometries should be triangulated
+ * @param {...Object} geometries - the geometries to generalize
+ * @return {Object|Array} the modified geometry, or a list of modified geometries
+ * @alias module:modeling/modifiers.generalize
+ */
+const generalize = (options, ...geometries) => {
+  geometries = flatten(geometries)
+  if (geometries.length === 0) throw new Error('wrong number of arguments')
+
+  const results = geometries.map((geometry) => {
+    if (path2.isA(geometry)) return generalizePath2(options, geometry)
+    if (geom2.isA(geometry)) return generalizeGeom2(options, geometry)
+    if (geom3.isA(geometry)) return generalizeGeom3(options, geometry)
+    throw new Error('invalid geometry')
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = generalize

package/src/operations/modifiers/generalize.test.js

@@ -0,0 +1,170 @@
+const test = require('ava')
+
+const { comparePolygonsAsPoints } = require('../../../test/helpers')
+
+const { TAU } = require('../../maths/constants')
+
+const { geom3 } = require('../../geometries')
+
+const { cuboid } = require('../../primitives')
+
+const { generalize } = require('./index')
+
+test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
+  const geometry1 = cuboid({ size: [TAU / 2, TAU / 4, TAU] })
+
+  // apply no modifications
+  let result = generalize({}, geometry1)
+  let pts = geom3.toPoints(result)
+  let exp = [
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, -0.7853981633974483, 3.141592653589793],
+      [-1.5707963267948966, 0.7853981633974483, 3.141592653589793], [-1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
+    [[1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, 0.7853981633974483, -3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, 3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, -0.7853981633974483, -3.141592653589793],
+      [1.5707963267948966, -0.7853981633974483, 3.141592653589793], [-1.5707963267948966, -0.7853981633974483, 3.141592653589793]],
+    [[-1.5707963267948966, 0.7853981633974483, -3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, 3.141592653589793], [1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, 0.7853981633974483, -3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, -3.141592653589793], [1.5707963267948966, -0.7853981633974483, -3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, 3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]]
+  ]
+  t.notThrows(() => geom3.validate(result))
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  // apply snap only
+  result = generalize({ snap: true }, geometry1)
+  pts = geom3.toPoints(result)
+  exp = [
+    [[-1.5707910908071407, -0.7854138713607164, -3.1415821816142815], [-1.5707910908071407, -0.7854138713607164, 3.1415821816142815],
+      [-1.5707910908071407, 0.7854138713607164, 3.1415821816142815], [-1.5707910908071407, 0.7854138713607164, -3.1415821816142815]],
+    [[1.5707910908071407, -0.7854138713607164, -3.1415821816142815], [1.5707910908071407, 0.7854138713607164, -3.1415821816142815],
+      [1.5707910908071407, 0.7854138713607164, 3.1415821816142815], [1.5707910908071407, -0.7854138713607164, 3.1415821816142815]],
+    [[-1.5707910908071407, -0.7854138713607164, -3.1415821816142815], [1.5707910908071407, -0.7854138713607164, -3.1415821816142815],
+      [1.5707910908071407, -0.7854138713607164, 3.1415821816142815], [-1.5707910908071407, -0.7854138713607164, 3.1415821816142815]],
+    [[-1.5707910908071407, 0.7854138713607164, -3.1415821816142815], [-1.5707910908071407, 0.7854138713607164, 3.1415821816142815],
+      [1.5707910908071407, 0.7854138713607164, 3.1415821816142815], [1.5707910908071407, 0.7854138713607164, -3.1415821816142815]],
+    [[-1.5707910908071407, -0.7854138713607164, -3.1415821816142815], [-1.5707910908071407, 0.7854138713607164, -3.1415821816142815],
+      [1.5707910908071407, 0.7854138713607164, -3.1415821816142815], [1.5707910908071407, -0.7854138713607164, -3.1415821816142815]],
+    [[-1.5707910908071407, -0.7854138713607164, 3.1415821816142815], [1.5707910908071407, -0.7854138713607164, 3.1415821816142815],
+      [1.5707910908071407, 0.7854138713607164, 3.1415821816142815], [-1.5707910908071407, 0.7854138713607164, 3.1415821816142815]]
+  ]
+  t.notThrows(() => geom3.validate(result))
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  // apply triangulate only
+  result = generalize({ triangulate: true }, geometry1)
+  pts = geom3.toPoints(result)
+  exp = [
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, -0.7853981633974483, 3.141592653589793],
+      [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793],
+      [-1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
+    [[1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, 0.7853981633974483, -3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, 3.141592653589793]],
+    [[1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, 0.7853981633974483, 3.141592653589793],
+      [1.5707963267948966, -0.7853981633974483, 3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, -0.7853981633974483, -3.141592653589793],
+      [1.5707963267948966, -0.7853981633974483, 3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793],
+      [-1.5707963267948966, -0.7853981633974483, 3.141592653589793]],
+    [[-1.5707963267948966, 0.7853981633974483, -3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, 3.141592653589793]],
+    [[-1.5707963267948966, 0.7853981633974483, -3.141592653589793], [1.5707963267948966, 0.7853981633974483, 3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, 0.7853981633974483, -3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, 0.7853981633974483, -3.141592653589793],
+      [1.5707963267948966, -0.7853981633974483, -3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, 3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, 0.7853981633974483, 3.141592653589793],
+      [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]]
+  ]
+  t.notThrows(() => geom3.validate(result))
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  const geometry2 = result // save the triangles for another test
+
+  // apply simplify only (triangles => quads)
+  result = generalize({ simplify: true }, geometry2)
+  pts = geom3.toPoints(result)
+  exp = [
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, -0.7853981633974483, 3.141592653589793],
+      [-1.5707963267948966, 0.7853981633974483, 3.141592653589793], [-1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
+    [[1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, 0.7853981633974483, -3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, 3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, -0.7853981633974483, -3.141592653589793],
+      [1.5707963267948966, -0.7853981633974483, 3.141592653589793], [-1.5707963267948966, -0.7853981633974483, 3.141592653589793]],
+    [[-1.5707963267948966, 0.7853981633974483, -3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, 3.141592653589793], [1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, 0.7853981633974483, -3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, -3.141592653589793], [1.5707963267948966, -0.7853981633974483, -3.141592653589793]],
+    [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793],
+      [1.5707963267948966, 0.7853981633974483, 3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]]
+  ]
+  t.notThrows(() => geom3.validate(result))
+  t.true(comparePolygonsAsPoints(pts, exp))
+})
+
+test('generalize: generalize of a geom3 with T junctions produces an expected geom3', (t) => {
+  const geometry1 = geom3.fromPoints(
+    [
+      [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
+      [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],
+      [[-1, -1, -1], [1, -1, -1], [1, -1, 1], [-1, -1, 1]],
+      [[-1, 1, -1], [-1, 1, 1], [1, 1, 1], [1, 1, -1]],
+      [[-1, -1, -1], [-1, 1, -1], [1, 1, -1], [1, -1, -1]],
+      // T junctions
+      [[-1, -1, 1], [0, -1, 1], [0, 0, 1]],
+      [[-1, 0, 1], [-1, -1, 1], [0, 0, 1]],
+
+      [[0, -1, 1], [1, -1, 1], [0, 0, 1]],
+      [[1, -1, 1], [1, 0, 1], [0, 0, 1]],
+
+      [[1, 0, 1], [1, 1, 1], [0, 0, 1]],
+      [[1, 1, 1], [0, 1, 1], [0, 0, 1]],
+
+      [[0, 1, 1], [-1, 1, 1], [0, 0, 1]],
+      [[-1, 1, 1], [-1, 0, 1], [0, 0, 1]]
+    ]
+  )
+
+  const result = generalize({ snap: true, triangulate: true }, geometry1)
+  const pts = geom3.toPoints(result)
+  const exp = [
+    [[-1, 0, 0.2], [-1, -1, -1], [-1, -1, 1]],
+    [[-1, 0, 0.2], [-1, -1, 1], [-1, 0, 1]],
+    [[-1, 0, 0.2], [-1, 0, 1], [-1, 1, 1]],
+    [[-1, 0, 0.2], [-1, 1, 1], [-1, 1, -1]],
+    [[-1, 0, 0.2], [-1, 1, -1], [-1, -1, -1]],
+    [[1, 0, 0.2], [1, -1, -1], [1, 1, -1]],
+    [[1, 0, 0.2], [1, 1, -1], [1, 1, 1]],
+    [[1, 0, 0.2], [1, 1, 1], [1, 0, 1]],
+    [[1, 0, 0.2], [1, 0, 1], [1, -1, 1]],
+    [[1, 0, 0.2], [1, -1, 1], [1, -1, -1]],
+    [[0, -1, 0.2], [-1, -1, -1], [1, -1, -1]],
+    [[0, -1, 0.2], [1, -1, -1], [1, -1, 1]],
+    [[0, -1, 0.2], [1, -1, 1], [0, -1, 1]],
+    [[0, -1, 0.2], [0, -1, 1], [-1, -1, 1]],
+    [[0, -1, 0.2], [-1, -1, 1], [-1, -1, -1]],
+    [[0, 1, 0.2], [-1, 1, -1], [-1, 1, 1]],
+    [[0, 1, 0.2], [-1, 1, 1], [0, 1, 1]],
+    [[0, 1, 0.2], [0, 1, 1], [1, 1, 1]],
+    [[0, 1, 0.2], [1, 1, 1], [1, 1, -1]],
+    [[0, 1, 0.2], [1, 1, -1], [-1, 1, -1]],
+    [[-1, -1, -1], [-1, 1, -1], [1, 1, -1]],
+    [[-1, -1, -1], [1, 1, -1], [1, -1, -1]],
+    [[-1, -1, 1], [0, -1, 1], [0, 0, 1]],
+    [[-1, 0, 1], [-1, -1, 1], [0, 0, 1]],
+    [[0, -1, 1], [1, -1, 1], [0, 0, 1]],
+    [[1, -1, 1], [1, 0, 1], [0, 0, 1]],
+    [[1, 0, 1], [1, 1, 1], [0, 0, 1]],
+    [[1, 1, 1], [0, 1, 1], [0, 0, 1]],
+    [[0, 1, 1], [-1, 1, 1], [0, 0, 1]],
+    [[-1, 1, 1], [-1, 0, 1], [0, 0, 1]]
+  ]
+  t.notThrows(() => geom3.validate(result))
+  t.true(comparePolygonsAsPoints(pts, exp))
+})

package/src/operations/modifiers/index.d.ts

@@ -0,0 +1,3 @@
+export { default as generalize } from './generalize'
+export { default as snap } from './snap'
+export { default as retessellate } from './retessellate'

package/src/operations/modifiers/index.js

@@ -0,0 +1,12 @@
+/**
+ * All shapes (primitives or the results of operations) can be modified to correct issues, etc.
+ * In all cases, these functions returns the results, and never changes the original geometry.
+ * @module modeling/modifiers
+ * @example
+ * const { generalize, snap, retessellate } = require('@jscad/modeling').modifiers
+ */
+module.exports = {
+  generalize: require('./generalize'),
+  snap: require('./snap'),
+  retessellate: require('./retessellate')
+}