@jbroll/jscad-modeling 2.12.7

package/src/operations/expansions/expandGeom2.js

@@ -0,0 +1,43 @@
+const geom2 = require('../../geometries/geom2')
+
+const offsetFromPoints = require('./offsetFromPoints')
+
+/*
+ * Expand the given geometry (geom2) using the given options (if any).
+ * @param {Object} options - options for expand
+ * @param {Number} [options.delta=1] - delta (+/-) of expansion
+ * @param {String} [options.corners='edge'] - type corner to create during of expansion; edge, chamfer, round
+ * @param {Integer} [options.segments=16] - number of segments when creating round corners
+ * @param {geom2} geometry - the geometry to expand
+ * @returns {geom2} expanded geometry
+ */
+const expandGeom2 = (options, geometry) => {
+  const defaults = {
+    delta: 1,
+    corners: 'edge',
+    segments: 16
+  }
+  const { delta, corners, segments } = Object.assign({ }, defaults, options)
+
+  if (!(corners === 'edge' || corners === 'chamfer' || corners === 'round')) {
+    throw new Error('corners must be "edge", "chamfer", or "round"')
+  }
+
+  // convert the geometry to outlines, and generate offsets from each
+  const outlines = geom2.toOutlines(geometry)
+  const newoutlines = outlines.map((outline) => {
+    options = {
+      delta,
+      corners,
+      closed: true,
+      segments
+    }
+    return offsetFromPoints(options, outline)
+  })
+
+  // create a composite geometry from the new outlines
+  const allsides = newoutlines.reduce((sides, newoutline) => sides.concat(geom2.toSides(geom2.fromPoints(newoutline))), [])
+  return geom2.create(allsides)
+}
+
+module.exports = expandGeom2

package/src/operations/expansions/expandGeom3.js

@@ -0,0 +1,36 @@
+const geom3 = require('../../geometries/geom3')
+
+const union = require('../booleans/union')
+
+const expandShell = require('./expandShell')
+
+/*
+ * Expand the given geometry (geom3) using the given options (if any).
+ * @param {Object} options - options for expand
+ * @param {Number} [options.delta=1] - delta (+/-) of expansion
+ * @param {String} [options.corners='round'] - type corner to create during of expansion; round
+ * @param {Integer} [options.segments=12] - number of segments when creating round corners
+ * @param {geom3} geometry - the geometry to expand
+ * @returns {geom3} expanded geometry
+ */
+const expandGeom3 = (options, geometry) => {
+  const defaults = {
+    delta: 1,
+    corners: 'round',
+    segments: 12
+  }
+  const { delta, corners, segments } = Object.assign({ }, defaults, options)
+
+  if (!(corners === 'round')) {
+    throw new Error('corners must be "round" for 3D geometries')
+  }
+
+  const polygons = geom3.toPolygons(geometry)
+  if (polygons.length === 0) throw new Error('the given geometry cannot be empty')
+
+  options = { delta, corners, segments }
+  const expanded = expandShell(options, geometry)
+  return union(geometry, expanded)
+}
+
+module.exports = expandGeom3

package/src/operations/expansions/expandGeom3.test.js

@@ -0,0 +1,32 @@
+const test = require('ava')
+
+const { geom3, poly3 } = require('../../geometries')
+const expandGeom3 = require('./expandGeom3')
+
+test('expandGeom3: expand completes properly, issue 876', async (t) => {
+  setTimeout(() => t.fail(), 1000)
+  const polies = [
+    poly3.create([[-19.61, -0.7999999999999986, 11.855], [-19.61, -0.8000000000000015, -11.855], [-19.61, -2.7500000000000018, -11.855], [-19.61, -2.7499999999999982, 11.855]]),
+    poly3.create([[-17.32, -2.75, 10], [-17.32, -2.7500000000000013, -10], [-17.32, -0.8000000000000014, -10], [-17.32, -0.7999999999999987, 10]]),
+    poly3.create([[-16.863040644206997, -0.8000000000000015, -10.28], [-16.863040644206997, -2.7500000000000018, -10.28], [-14.292644267871385, -2.7500000000000018, -11.855000000000016], [-14.292644267871383, -0.8000000000000015, -11.855000000000018]]),
+    poly3.create([[-17.319999999999993, -0.8000000000000015, -9.999999999999996], [-17.319999999999993, -2.7500000000000018, -9.999999999999996], [-16.87560702649131, -2.7500000000000018, -10.272299999999998], [-16.866696319053347, -0.8000000000000015, -10.277759999999997]]),
+    poly3.create([[-16.863040644207004, -2.7500000000000013, -10.280000000000001], [-16.863040644207004, -0.8000000000000014, -10.280000000000001], [-16.86669631905335, -0.8000000000000012, -10.27776], [-16.875607026491313, -2.75, -10.272300000000001]]),
+    poly3.create([[-14.107140000000015, -0.7999999999999987, 11.85500000000003], [-14.107140000000015, -2.7499999999999982, 11.85500000000003], [-17.319999999999975, -2.7499999999999982, 9.999999999999956], [-17.319999999999975, -0.7999999999999987, 9.999999999999956]]),
+    poly3.create([[-17.32, -0.7999999999999988, 9.999999999999993], [-17.32, -0.7999999999999986, 11.855], [-14.107139999999994, -0.7999999999999986, 11.855]]),
+    poly3.create([[-17.32, -0.800000000000001, -11.855], [-17.32, -0.8000000000000008, -10.000000000000078], [-14.292644267871482, -0.800000000000001, -11.855]]),
+    poly3.create([[-17.32, -0.800000000000001, -11.855], [-19.61, -0.800000000000001, -11.855], [-19.61, -0.7999999999999986, 11.855], [-17.32, -0.7999999999999986, 11.855]]),
+    poly3.create([[-17.32, -2.7500000000000013, -10.000000000000076], [-17.32, -2.7500000000000018, -11.855], [-14.292644267871482, -2.7500000000000018, -11.855]]),
+    poly3.create([[-17.32, -2.7499999999999982, 11.855], [-17.32, -2.7499999999999987, 9.999999999999996], [-14.107139999999996, -2.7499999999999982, 11.855]]),
+    poly3.create([[-17.32, -2.7499999999999982, 11.855], [-19.61, -2.7499999999999982, 11.855], [-19.61, -2.7500000000000018, -11.855], [-17.32, -2.7500000000000018, -11.855]]),
+    poly3.create([[-14.107139999999996, -0.7999999999999986, 11.855], [-19.61, -0.7999999999999986, 11.855], [-19.61, -2.7499999999999982, 11.855], [-14.107139999999994, -2.7499999999999982, 11.855]]),
+    poly3.create([[-19.61, -0.8000000000000015, -11.855], [-14.292644267871486, -0.8000000000000015, -11.855], [-14.292644267871482, -2.7500000000000018, -11.855], [-19.61, -2.7500000000000018, -11.855]])
+  ]
+
+  const sub = geom3.create(polies)
+
+  return new Promise((resolve, reject) => {
+    expandGeom3({ delta: 1.3, corners: 'round', segments: 12 }, sub)
+    t.pass()
+    resolve()
+  })
+})

package/src/operations/expansions/expandPath2.js

@@ -0,0 +1,99 @@
+const area = require('../../maths/utils/area')
+
+const vec2 = require('../../maths/vec2')
+
+const geom2 = require('../../geometries/geom2')
+const path2 = require('../../geometries/path2')
+
+const offsetFromPoints = require('./offsetFromPoints')
+
+const createGeometryFromClosedOffsets = (paths) => {
+  let { external, internal } = paths
+  if (area(external) < 0) {
+    external = external.reverse()
+  } else {
+    internal = internal.reverse()
+  }
+  // NOTE: creating path2 from the points ensures proper closure
+  const externalPath = path2.fromPoints({ closed: true }, external)
+  const internalPath = path2.fromPoints({ closed: true }, internal)
+  const externalSides = geom2.toSides(geom2.fromPoints(path2.toPoints(externalPath)))
+  const internalSides = geom2.toSides(geom2.fromPoints(path2.toPoints(internalPath)))
+  externalSides.push(...internalSides)
+  return geom2.create(externalSides)
+}
+
+const createGeometryFromExpandedOpenPath = (paths, segments, corners, delta) => {
+  const { points, external, internal } = paths
+  const capSegments = Math.floor(segments / 2) // rotation is 180 degrees
+  const e2iCap = []
+  const i2eCap = []
+  if (corners === 'round' && capSegments > 0) {
+    // added round caps to the geometry
+    const step = Math.PI / capSegments
+    const eCorner = points[points.length - 1]
+    const e2iStart = vec2.angle(vec2.subtract(vec2.create(), external[external.length - 1], eCorner))
+    const iCorner = points[0]
+    const i2eStart = vec2.angle(vec2.subtract(vec2.create(), internal[0], iCorner))
+    for (let i = 1; i < capSegments; i++) {
+      let radians = e2iStart + (step * i)
+      let point = vec2.fromAngleRadians(vec2.create(), radians)
+      vec2.scale(point, point, delta)
+      vec2.add(point, point, eCorner)
+      e2iCap.push(point)
+
+      radians = i2eStart + (step * i)
+      point = vec2.fromAngleRadians(vec2.create(), radians)
+      vec2.scale(point, point, delta)
+      vec2.add(point, point, iCorner)
+      i2eCap.push(point)
+    }
+  }
+  const allPoints = []
+  allPoints.push(...external, ...e2iCap, ...internal.reverse(), ...i2eCap)
+  return geom2.fromPoints(allPoints)
+}
+
+/*
+ * Expand the given geometry (path2) using the given options (if any).
+ * @param {Object} options - options for expand
+ * @param {Number} [options.delta=1] - delta (+) of expansion
+ * @param {String} [options.corners='edge'] - type corner to create during of expansion; edge, chamfer, round
+ * @param {Integer} [options.segments=16] - number of segments when creating round corners
+ * @param {path2} geometry - the geometry to expand
+ * @returns {geom2} expanded geometry
+ */
+const expandPath2 = (options, geometry) => {
+  const defaults = {
+    delta: 1,
+    corners: 'edge',
+    segments: 16
+  }
+
+  options = Object.assign({ }, defaults, options)
+  const { delta, corners, segments } = options
+
+  if (delta <= 0) throw new Error('the given delta must be positive for paths')
+
+  if (!(corners === 'edge' || corners === 'chamfer' || corners === 'round')) {
+    throw new Error('corners must be "edge", "chamfer", or "round"')
+  }
+
+  const closed = geometry.isClosed
+  const points = path2.toPoints(geometry)
+  if (points.length === 0) throw new Error('the given geometry cannot be empty')
+
+  const paths = {
+    points: points,
+    external: offsetFromPoints({ delta, corners, segments, closed }, points),
+    internal: offsetFromPoints({ delta: -delta, corners, segments, closed }, points)
+  }
+
+  if (geometry.isClosed) {
+    return createGeometryFromClosedOffsets(paths)
+  } else {
+    return createGeometryFromExpandedOpenPath(paths, segments, corners, delta)
+  }
+}
+
+module.exports = expandPath2

package/src/operations/expansions/expandShell.js

@@ -0,0 +1,224 @@
+const { EPS, TAU } = require('../../maths/constants')
+
+const mat4 = require('../../maths/mat4')
+const vec3 = require('../../maths/vec3')
+
+const fnNumberSort = require('../../utils/fnNumberSort')
+
+const geom3 = require('../../geometries/geom3')
+const poly3 = require('../../geometries/poly3')
+
+const sphere = require('../../primitives/sphere')
+
+const retessellate = require('../modifiers/retessellate')
+
+const unionGeom3Sub = require('../booleans/unionGeom3Sub')
+
+const extrudePolygon = require('./extrudePolygon')
+
+/*
+ * Collect all planes adjacent to each vertex
+ */
+const mapPlaneToVertex = (map, vertex, plane) => {
+  const key = vertex.toString()
+  if (!map.has(key)) {
+    const entry = [vertex, [plane]]
+    map.set(key, entry)
+  } else {
+    const planes = map.get(key)[1]
+    planes.push(plane)
+  }
+}
+
+/*
+ * Collect all planes adjacent to each edge.
+ * Combine undirected edges, no need for duplicate cylinders.
+ */
+const mapPlaneToEdge = (map, edge, plane) => {
+  const key0 = edge[0].toString()
+  const key1 = edge[1].toString()
+  // Sort keys to make edges undirected
+  const key = key0 < key1 ? `${key0},${key1}` : `${key1},${key0}`
+  if (!map.has(key)) {
+    const entry = [edge, [plane]]
+    map.set(key, entry)
+  } else {
+    const planes = map.get(key)[1]
+    planes.push(plane)
+  }
+}
+
+const addUniqueAngle = (map, angle) => {
+  const i = map.findIndex((item) => item === angle)
+  if (i < 0) {
+    map.push(angle)
+  }
+}
+
+/*
+ * Create the expanded shell of the solid:
+ * All faces are extruded to 2 times delta
+ * Cylinders are constructed around every side
+ * Spheres are placed on every vertex
+ * the result is a true expansion of the solid
+ * @param  {Number} delta
+ * @param  {Integer} segments
+ */
+const expandShell = (options, geometry) => {
+  const defaults = {
+    delta: 1,
+    segments: 12
+  }
+  const { delta, segments } = Object.assign({ }, defaults, options)
+
+  let result = geom3.create()
+  const vertices2planes = new Map() // {vertex: [vertex, [plane, ...]]}
+  const edges2planes = new Map() // {edge: [[vertex, vertex], [plane, ...]]}
+
+  const v1 = vec3.create()
+  const v2 = vec3.create()
+
+  // loop through the polygons
+  // - extruded the polygon, and add to the composite result
+  // - add the plane to the unique vertice map
+  // - add the plane to the unique edge map
+  const polygons = geom3.toPolygons(geometry)
+  polygons.forEach((polygon, index) => {
+    const extrudevector = vec3.scale(vec3.create(), poly3.plane(polygon), 2 * delta)
+    const translatedpolygon = poly3.transform(mat4.fromTranslation(mat4.create(), vec3.scale(vec3.create(), extrudevector, -0.5)), polygon)
+    const extrudedface = extrudePolygon(extrudevector, translatedpolygon)
+    result = unionGeom3Sub(result, extrudedface)
+
+    const vertices = polygon.vertices
+    for (let i = 0; i < vertices.length; i++) {
+      mapPlaneToVertex(vertices2planes, vertices[i], poly3.plane(polygon))
+      const j = (i + 1) % vertices.length
+      const edge = [vertices[i], vertices[j]]
+      mapPlaneToEdge(edges2planes, edge, poly3.plane(polygon))
+    }
+  })
+
+  // now construct a cylinder on every side
+  // The cylinder is always an approximation of a true cylinder, having polygons
+  // around the sides. We will make sure though that the cylinder will have an edge at every
+  // face that touches this side. This ensures that we will get a smooth fill even
+  // if two edges are at, say, 10 degrees and the segments is low.
+  edges2planes.forEach((item) => {
+    const edge = item[0]
+    const planes = item[1]
+    const startpoint = edge[0]
+    const endpoint = edge[1]
+
+    // our x,y and z vectors:
+    const zbase = vec3.subtract(vec3.create(), endpoint, startpoint)
+    vec3.normalize(zbase, zbase)
+    const xbase = planes[0]
+    const ybase = vec3.cross(vec3.create(), xbase, zbase)
+
+    // make a list of angles that the cylinder should traverse:
+    let angles = []
+
+    // first of all equally spaced around the cylinder:
+    for (let i = 0; i < segments; i++) {
+      addUniqueAngle(angles, (i * TAU / segments))
+    }
+
+    // and also at every normal of all touching planes:
+    for (let i = 0, iMax = planes.length; i < iMax; i++) {
+      const planenormal = planes[i]
+      const si = vec3.dot(ybase, planenormal)
+      const co = vec3.dot(xbase, planenormal)
+      let angle = Math.atan2(si, co)
+
+      if (angle < 0) angle += TAU
+      addUniqueAngle(angles, angle)
+      angle = Math.atan2(-si, -co)
+      if (angle < 0) angle += TAU
+      addUniqueAngle(angles, angle)
+    }
+
+    // this will result in some duplicate angles but we will get rid of those later.
+    angles = angles.sort(fnNumberSort)
+
+    // Now construct the cylinder by traversing all angles:
+    const numangles = angles.length
+    let prevp1
+    let prevp2
+    const startfacevertices = []
+    const endfacevertices = []
+    const polygons = []
+    for (let i = -1; i < numangles; i++) {
+      const angle = angles[(i < 0) ? (i + numangles) : i]
+      const si = Math.sin(angle)
+      const co = Math.cos(angle)
+      vec3.scale(v1, xbase, co * delta)
+      vec3.scale(v2, ybase, si * delta)
+      vec3.add(v1, v1, v2)
+      const p1 = vec3.add(vec3.create(), startpoint, v1)
+      const p2 = vec3.add(vec3.create(), endpoint, v1)
+      let skip = false
+      if (i >= 0) {
+        if (vec3.distance(p1, prevp1) < EPS) {
+          skip = true
+        }
+      }
+      if (!skip) {
+        if (i >= 0) {
+          startfacevertices.push(p1)
+          endfacevertices.push(p2)
+          const points = [prevp2, p2, p1, prevp1]
+          const polygon = poly3.create(points)
+          polygons.push(polygon)
+        }
+        prevp1 = p1
+        prevp2 = p2
+      }
+    }
+    endfacevertices.reverse()
+    polygons.push(poly3.create(startfacevertices))
+    polygons.push(poly3.create(endfacevertices))
+
+    const cylinder = geom3.create(polygons)
+    result = unionGeom3Sub(result, cylinder)
+  })
+
+  // build spheres at each unique vertex
+  // We will try to set the x and z axis to the normals of 2 planes
+  // This will ensure that our sphere tesselation somewhat matches 2 planes
+  vertices2planes.forEach((item) => {
+    const vertex = item[0]
+    const planes = item[1]
+    // use the first normal to be the x axis of our sphere:
+    const xaxis = planes[0]
+    // and find a suitable z axis. We will use the normal which is most perpendicular to the x axis:
+    let bestzaxis = null
+    let bestzaxisorthogonality = 0
+    for (let i = 1; i < planes.length; i++) {
+      const normal = planes[i]
+      const cross = vec3.cross(v1, xaxis, normal)
+      const crosslength = vec3.length(cross)
+      if (crosslength > 0.05) { // FIXME why 0.05?
+        if (crosslength > bestzaxisorthogonality) {
+          bestzaxisorthogonality = crosslength
+          bestzaxis = normal
+        }
+      }
+    }
+    if (!bestzaxis) {
+      bestzaxis = vec3.orthogonal(v1, xaxis)
+    }
+    const yaxis = vec3.cross(v1, xaxis, bestzaxis)
+    vec3.normalize(yaxis, yaxis)
+    const zaxis = vec3.cross(v2, yaxis, xaxis)
+    const corner = sphere({
+      center: [vertex[0], vertex[1], vertex[2]],
+      radius: delta,
+      segments: segments,
+      axes: [xaxis, yaxis, zaxis]
+    })
+    result = unionGeom3Sub(result, corner)
+  })
+  return retessellate(result)
+}
+
+module.exports = expandShell

package/src/operations/expansions/extrudePolygon.js

@@ -0,0 +1,34 @@
+const mat4 = require('../../maths/mat4')
+const vec3 = require('../../maths/vec3')
+
+const geom3 = require('../../geometries/geom3')
+const poly3 = require('../../geometries/poly3')
+
+// Extrude a polygon in the direction of the offsetvector.
+// Returns (geom3) a new geometry
+const extrudePolygon = (offsetvector, polygon1) => {
+  const direction = vec3.dot(poly3.plane(polygon1), offsetvector)
+  if (direction > 0) {
+    polygon1 = poly3.invert(polygon1)
+  }
+
+  const newpolygons = [polygon1]
+
+  const polygon2 = poly3.transform(mat4.fromTranslation(mat4.create(), offsetvector), polygon1)
+  const numvertices = polygon1.vertices.length
+  for (let i = 0; i < numvertices; i++) {
+    const nexti = (i < (numvertices - 1)) ? i + 1 : 0
+    const sideFacePolygon = poly3.create([
+      polygon1.vertices[i],
+      polygon2.vertices[i],
+      polygon2.vertices[nexti],
+      polygon1.vertices[nexti]
+    ])
+    newpolygons.push(sideFacePolygon)
+  }
+  newpolygons.push(poly3.invert(polygon2))
+
+  return geom3.create(newpolygons)
+}
+
+module.exports = extrudePolygon

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

@@ -0,0 +1,4 @@
+export { default as expand, ExpandOptions } from './expand'
+export { default as offset, OffsetOptions } from './offset'
+
+export as namespace expansions

package/src/operations/expansions/index.js

@@ -0,0 +1,11 @@
+/**
+ * All shapes (primitives or the results of operations) can be expanded (or contracted.)
+ * In all cases, the function returns the results, and never changes the original shapes.
+ * @module modeling/expansions
+ * @example
+ * const { expand, offset } = require('@jscad/modeling').expansions
+ */
+module.exports = {
+  expand: require('./expand'),
+  offset: require('./offset')
+}

package/src/operations/expansions/offset.d.ts

@@ -0,0 +1,15 @@
+import { Path2, Geom2 } from '../../geometries/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+type Geometry = Path2 | Geom2
+
+export default offset
+
+export interface OffsetOptions {
+  delta?: number
+  corners?: 'edge' | 'chamfer' | 'round'
+  segments?: number
+}
+
+declare function offset<T extends Geometry>(options: OffsetOptions, geometry: T): T
+declare function offset(options?: OffsetOptions, ...geometries: RecursiveArray<Geometry>): Geometry

package/src/operations/expansions/offset.js

@@ -0,0 +1,36 @@
+const flatten = require('../../utils/flatten')
+
+const geom2 = require('../../geometries/geom2')
+const path2 = require('../../geometries/path2')
+
+const offsetGeom2 = require('./offsetGeom2')
+const offsetPath2 = require('./offsetPath2')
+
+/**
+ * Create offset geometry from the given geometry using the given options.
+ * Offsets from internal and external space are created.
+ * @param {Object} options - options for offset
+ * @param {Float} [options.delta=1] - delta of offset (+ to exterior, - from interior)
+ * @param {String} [options.corners='edge'] - type of corner to create after offseting; edge, chamfer, round
+ * @param {Integer} [options.segments=16] - number of segments when creating round corners
+ * @param {...Object} objects - the geometries to offset
+ * @return {Object|Array} new geometry, or list of new geometries
+ * @alias module:modeling/expansions.offset
+ *
+ * @example
+ * let small = offset({ delta: -4, corners: 'chamfer' }, square({size: 40})) // contract
+ */
+const offset = (options, ...objects) => {
+  objects = flatten(objects)
+  if (objects.length === 0) throw new Error('wrong number of arguments')
+
+  const results = objects.map((object) => {
+    if (path2.isA(object)) return offsetPath2(options, object)
+    if (geom2.isA(object)) return offsetGeom2(options, object)
+    // if (geom3.isA(object)) return geom3.transform(matrix, object)
+    return object
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = offset