@jscad/modeling 2.12.0 → 3.0.0-alpha.0

package/src/operations/modifiers/retessellate.js

@@ -1,7 +1,9 @@
-const geom3 = require('../../geometries/geom3')
-const poly3 = require('../../geometries/poly3')
-const { NEPS } = require('../../maths/constants')
-const reTesselateCoplanarPolygons = require('./reTesselateCoplanarPolygons')
+import { NEPS } from '../../maths/constants.js'
+
+import * as geom3 from '../../geometries/geom3/index.js'
+import * as poly3 from '../../geometries/poly3/index.js'
+
+import { reTesselateCoplanarPolygons } from './reTesselateCoplanarPolygons.js'
 
 /*
   After boolean operations all coplanar polygon fragments are joined by a retesselating
@@ -11,7 +13,7 @@ const reTesselateCoplanarPolygons = require('./reTesselateCoplanarPolygons')
   Polygons are split at each sweep line, and the fragments are joined horizontally and vertically into larger polygons
   (making sure that we will end up with convex polygons).
 */
-const retessellate = (geometry) => {
+export const retessellate = (geometry) => {
   if (geometry.isRetesselated) {
     return geometry
   }
@@ -89,5 +91,3 @@ const byPlaneComponent = (component, tolerance) => (a, b) => {
   }
   return 0
 }
-
-module.exports = retessellate

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

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { geom3 } = require('../../geometries')
+import { geom3 } from '../../geometries/index.js'
 
-const retessellate = require('./retessellate')
+import { retessellate } from './retessellate.js'
 
-const { comparePolygonsAsPoints } = require('../../../test/helpers')
+import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
 test('geom3: retessellate() should create proper geometry from empty geometries', (t) => {
   const obj1 = geom3.create()

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

@@ -1,5 +1,5 @@
-import { Geometry } from '../../geometries/types'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geometry } from '../../geometries/types.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
 export function snap<T extends Geometry>(geometry: T): T
 export function snap<T extends Geometry>(...geometries: RecursiveArray<T>): Array<T>

package/src/operations/modifiers/snap.js

@@ -1,37 +1,50 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const vec2 = require('../../maths/vec2')
+import * as vec2 from '../../maths/vec2/index.js'
 
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const path2 = require('../../geometries/path2')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
+import * as path2 from '../../geometries/path2/index.js'
+import * as poly2 from '../../geometries/poly2/index.js'
 
-const measureEpsilon = require('../../measurements/measureEpsilon')
+import { measureEpsilon } from '../../measurements/measureEpsilon.js'
 
-const snapPolygons = require('./snapPolygons')
+import { snapPolygons } from './snapPolygons.js'
 
 const snapPath2 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
   const points = path2.toPoints(geometry)
-  const newpoints = points.map((point) => vec2.snap(vec2.create(), point, epsilon))
+  const newPoints = points.map((point) => vec2.snap(vec2.create(), point, epsilon))
   // snap can produce duplicate points, remove those
-  return path2.create(newpoints)
+  return path2.create(newPoints)
 }
 
 const snapGeom2 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
-  const sides = geom2.toSides(geometry)
-  let newsides = sides.map((side) => [vec2.snap(vec2.create(), side[0], epsilon), vec2.snap(vec2.create(), side[1], epsilon)])
-  // snap can produce sides with zero (0) length, remove those
-  newsides = newsides.filter((side) => !vec2.equals(side[0], side[1]))
-  return geom2.create(newsides)
+  const outlines = geom2.toOutlines(geometry)
+  let newOutlines = outlines.map((outline) => {
+    let prev = vec2.snap(vec2.create(), outline[outline.length - 1], epsilon)
+    const newOutline = []
+    outline.forEach((point) => {
+      const snapped = vec2.snap(vec2.create(), point, epsilon)
+      // remove duplicate points
+      if (!vec2.equals(prev, snapped)) {
+        newOutline.push(snapped)
+      }
+      prev = snapped
+    })
+    return newOutline
+  })
+  // remove zero-area outlines
+  newOutlines = newOutlines.filter((outline) => poly2.measureArea(poly2.create(outline)))
+  return geom2.create(newOutlines)
 }
 
 const snapGeom3 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
   const polygons = geom3.toPolygons(geometry)
-  const newpolygons = snapPolygons(epsilon, polygons)
-  return geom3.create(newpolygons)
+  const newPolygons = snapPolygons(epsilon, polygons)
+  return geom3.create(newPolygons)
 }
 
 /**
@@ -41,7 +54,7 @@ const snapGeom3 = (geometry) => {
  * @return {Object|Array} the snapped geometry, or a list of snapped geometries
  * @alias module:modeling/modifiers.snap
  */
-const snap = (...geometries) => {
+export const snap = (...geometries) => {
   geometries = flatten(geometries)
   if (geometries.length === 0) throw new Error('wrong number of arguments')
 
@@ -53,5 +66,3 @@ const snap = (...geometries) => {
   })
   return results.length === 1 ? results[0] : results
 }
-
-module.exports = snap

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

@@ -1,14 +1,14 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+import { comparePoints, comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
-const { TAU } = require('../../maths/constants')
+import { TAU } from '../../maths/constants.js'
 
-const { geom2, geom3, path2 } = require('../../geometries')
+import { geom2, geom3, path2 } from '../../geometries/index.js'
 
-const { arc, rectangle, cuboid } = require('../../primitives')
+import { arc, rectangle, cuboid } from '../../primitives/index.js'
 
-const { snap } = require('./index')
+import { snap } from './index.js'
 
 test('snap: snap of a path2 produces an expected path2', (t) => {
   const geometry1 = path2.create()
@@ -73,19 +73,41 @@ test('snap: snap of a geom2 produces an expected geom2', (t) => {
 
   pts = geom2.toPoints(results[2])
   exp = [
-    [-0.6666666666666666, -0.6666666666666666], [0.6666666666666666, -0.6666666666666666],
-    [0.6666666666666666, 0.6666666666666666], [-0.6666666666666666, 0.6666666666666666]
+    [-0.6666666666666666, -0.6666666666666666],
+    [0.6666666666666666, -0.6666666666666666],
+    [0.6666666666666666, 0.6666666666666666],
+    [-0.6666666666666666, 0.6666666666666666]
   ]
   t.true(comparePoints(pts, exp))
 
   pts = geom2.toPoints(results[3])
   exp = [
-    [-1570.7963267948967, -1570.7963267948967], [1570.7963267948967, -1570.7963267948967],
-    [1570.7963267948967, 1570.7963267948967], [-1570.7963267948967, 1570.7963267948967]
+    [-1570.7963267948967, -1570.7963267948967],
+    [1570.7963267948967, -1570.7963267948967],
+    [1570.7963267948967, 1570.7963267948967],
+    [-1570.7963267948967, 1570.7963267948967]
   ]
   t.true(comparePoints(pts, exp))
 })
 
+test('snap: snap of a geom2 removes duplicate points after snap', (t) => {
+  const geometry = geom2.create([[[0, 0], [0, 1], [2, 0], [1.999999, 0]]])
+  const result = snap(geometry)
+  const pts = geom2.toPoints(result)
+  const exp = [[0, 0], [0, 1.000005], [1.9999950000000002, 0]]
+  t.is(pts.length, 3)
+  t.true(comparePoints(pts, exp))
+})
+
+test('snap: snap of a geom2 removes empty outlines after snap', (t) => {
+  const geometry = geom2.create([[[0, 0], [0, 1.000001], [0, 0.999999]]])
+  const result = snap(geometry)
+  const pts = geom2.toPoints(result)
+  const exp = []
+  t.is(pts.length, 0)
+  t.true(comparePoints(pts, exp))
+})
+
 test('snap: snap of a geom3 produces an expected geom3', (t) => {
   const geometry1 = geom3.create()
   const geometry2 = cuboid({ size: [1, 1, 1] })

package/src/operations/modifiers/snapPolygons.js

@@ -1,6 +1,6 @@
-const vec3 = require('../../maths/vec3')
+import * as vec3 from '../../maths/vec3/index.js'
 
-const poly3 = require('../../geometries/poly3')
+import * as poly3 from '../../geometries/poly3/index.js'
 
 const isValidPoly3 = (epsilon, polygon) => {
   const area = Math.abs(poly3.measureArea(polygon))
@@ -10,23 +10,21 @@ const isValidPoly3 = (epsilon, polygon) => {
 /*
  * Snap the given list of polygons to the epsilon.
  */
-const snapPolygons = (epsilon, polygons) => {
-  let newpolygons = polygons.map((polygon) => {
-    const snapvertices = polygon.vertices.map((vertice) => vec3.snap(vec3.create(), vertice, epsilon))
+export const snapPolygons = (epsilon, polygons) => {
+  let newPolygons = polygons.map((polygon) => {
+    const snapVertices = polygon.vertices.map((vertex) => vec3.snap(vec3.create(), vertex, epsilon))
     // only retain unique vertices
-    const newvertices = []
-    for (let i = 0; i < snapvertices.length; i++) {
-      const j = (i + 1) % snapvertices.length
-      if (!vec3.equals(snapvertices[i], snapvertices[j])) newvertices.push(snapvertices[i])
+    const newVertices = []
+    for (let i = 0; i < snapVertices.length; i++) {
+      const j = (i + 1) % snapVertices.length
+      if (!vec3.equals(snapVertices[i], snapVertices[j])) newVertices.push(snapVertices[i])
     }
-    const newpolygon = poly3.create(newvertices)
-    if (polygon.color) newpolygon.color = polygon.color
-    return newpolygon
+    const newPolygon = poly3.create(newVertices)
+    if (polygon.color) newPolygon.color = polygon.color
+    return newPolygon
   })
   // snap can produce polygons with zero (0) area, remove those
   const epsilonArea = (epsilon * epsilon * Math.sqrt(3) / 4)
-  newpolygons = newpolygons.filter((polygon) => isValidPoly3(epsilonArea, polygon))
-  return newpolygons
+  newPolygons = newPolygons.filter((polygon) => isValidPoly3(epsilonArea, polygon))
+  return newPolygons
 }
-
-module.exports = snapPolygons

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

@@ -1,8 +1,8 @@
-const test = require('ava')
+import test from 'ava'
 
-const { poly3 } = require('../../geometries')
+import { poly3 } from '../../geometries/index.js'
 
-const snapPolygons = require('./snapPolygons')
+import { snapPolygons } from './snapPolygons.js'
 
 test('snapPolygons: snap of polygons produces expected results', (t) => {
   const polygons = [

package/src/operations/modifiers/triangulatePolygons.js

@@ -1,5 +1,6 @@
-const vec3 = require('../../maths/vec3')
-const poly3 = require('../../geometries/poly3')
+import * as vec3 from '../../maths/vec3/index.js'
+
+import * as poly3 from '../../geometries/poly3/index.js'
 
 const triangulatePolygon = (epsilon, polygon, triangles) => {
   const nv = polygon.vertices.length
@@ -7,7 +8,7 @@ const triangulatePolygon = (epsilon, polygon, triangles) => {
     if (nv > 4) {
       // split the polygon using a midpoint
       const midpoint = [0, 0, 0]
-      polygon.vertices.forEach((vertice) => vec3.add(midpoint, midpoint, vertice))
+      polygon.vertices.forEach((vertex) => vec3.add(midpoint, midpoint, vertex))
       vec3.snap(midpoint, vec3.divide(midpoint, midpoint, [nv, nv, nv]), epsilon)
       for (let i = 0; i < nv; i++) {
         const poly = poly3.create([midpoint, polygon.vertices[i], polygon.vertices[(i + 1) % nv]])
@@ -34,12 +35,10 @@ const triangulatePolygon = (epsilon, polygon, triangles) => {
  * Convert the given polygons into a list of triangles (polygons with 3 vertices).
  * NOTE: this is possible because poly3 is CONVEX by definition
  */
-const triangulatePolygons = (epsilon, polygons) => {
+export const triangulatePolygons = (epsilon, polygons) => {
   const triangles = []
   polygons.forEach((polygon) => {
     triangulatePolygon(epsilon, polygon, triangles)
   })
   return triangles
 }
-
-module.exports = triangulatePolygons

package/src/operations/offsets/extrudePolygon.js

@@ -0,0 +1,32 @@
+import * as mat4 from '../../maths/mat4/index.js'
+import * as vec3 from '../../maths/vec3/index.js'
+
+import * as geom3 from '../../geometries/geom3/index.js'
+import * as poly3 from '../../geometries/poly3/index.js'
+
+// Extrude a polygon in the direction of the offset vector.
+// Returns (geom3) a new geometry
+export 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)
+}

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

@@ -0,0 +1,2 @@
+export { offset, OffsetOptions } from './offset.js'
+export { offsetFromPoints } from './offsetFromPoints.js'

package/src/operations/offsets/index.js

@@ -0,0 +1,9 @@
+/**
+ * Polygon offsetting is a geometric operation that expands or contracts
+ * shapes by a fixed distance.
+ * @module modeling/offsets
+ * @example
+ * import { offset } from '@jscad/modeling'
+ */
+export { offset } from './offset.js'
+export { offsetFromPoints } from './offsetFromPoints.js'

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

@@ -0,0 +1,12 @@
+import type { Geometry } from '../../geometries/types.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
+
+export interface OffsetOptions {
+  delta?: number
+  corners?: 'edge' | 'chamfer' | 'round'
+  segments?: number
+  expandHoles?: boolean
+}
+
+export function offset<T extends Geometry>(options: OffsetOptions, geometry: T): T
+export function offset(options?: OffsetOptions, ...geometries: RecursiveArray<Geometry>): Geometry

package/src/operations/offsets/offset.js

@@ -0,0 +1,36 @@
+import { flatten } from '../../utils/flatten.js'
+
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
+import * as path2 from '../../geometries/path2/index.js'
+
+import { offsetGeom2 } from './offsetGeom2.js'
+import { offsetGeom3 } from './offsetGeom3.js'
+import { offsetPath2 } from './offsetPath2.js'
+
+/**
+ * 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 {number} [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 {number} [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/offsets.offset
+ *
+ * @example
+ * let small = offset({ delta: -4, corners: 'chamfer' }, square({size: 40})) // contract
+ */
+export 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 offsetGeom3(options, object)
+    return object
+  })
+  return results.length === 1 ? results[0] : results
+}

package/src/operations/offsets/offsetFromPoints.d.ts

@@ -0,0 +1,10 @@
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
+
+export interface OffsetFromPointsOptions {
+  delta?: number
+  corners?: 'edge' | 'chamfer' | 'round'
+  segments?: number
+  closed?: boolean
+}
+
+export function offsetFromPoints(options: OffsetFromPointsOptions, points: Array<Vec2>): Array<Vec2>

package/src/operations/{expansions → offsets}/offsetFromPoints.js

@@ -1,21 +1,23 @@
-const { EPS, TAU } = require('../../maths/constants')
+import { EPS, TAU } from '../../maths/constants.js'
 
-const intersect = require('../../maths/utils/intersect')
-const line2 = require('../../maths/line2')
-const vec2 = require('../../maths/vec2')
-const area = require('../../maths/utils/area')
+import { area } from '../../maths/utils/area.js'
+import { intersect } from '../../maths/utils/intersect.js'
 
-/*
+import * as line2 from '../../maths/line2/index.js'
+import * as vec2 from '../../maths/vec2/index.js'
+
+/**
  * Create a set of offset points from the given points using the given options (if any).
- * @param {Object} options - options for offset
- * @param {Float} [options.delta=1] - delta of offset (+ to exterior, - from interior)
- * @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 {Integer} [options.closed=false] - is the last point connected back to the first point?
+ * @param {object} options - options for offset
+ * @param {number} [options.delta=1] - delta of offset (+ to exterior, - from interior)
+ * @param {string} [options.corners='edge'] - type corner to create during of expansion; edge, chamfer, round
+ * @param {number} [options.segments=16] - number of segments when creating round corners
+ * @param {number} [options.closed=false] - is the last point connected back to the first point?
  * @param {Array} points - array of 2D points
  * @returns {Array} new set of offset points, plus points for each rounded corner
+ * @alias module:modeling/offsets.offsetFromPoints
  */
-const offsetFromPoints = (options, points) => {
+export const offsetFromPoints = (options, points) => {
   const defaults = {
     delta: 1,
     corners: 'edge',
@@ -25,6 +27,7 @@ const offsetFromPoints = (options, points) => {
   let { delta, corners, closed, segments } = Object.assign({ }, defaults, options)
 
   if (Math.abs(delta) < EPS) return points
+  if (points.length < 2) return points
 
   let rotation = options.closed ? area(points) : 1.0 // + counter clockwise, - clockwise
   if (rotation === 0) rotation = 1.0
@@ -56,7 +59,7 @@ const offsetFromPoints = (options, points) => {
     if (previousSegment != null) {
       if (closed || (!closed && j !== 0)) {
         // check for intersection of new line segments
-        const ip = intersect(previousSegment[0], previousSegment[1], currentSegment[0], currentSegment[1])
+        const ip = intersect(previousSegment[0], previousSegment[1], currentSegment[0], currentSegment[1], true)
         if (ip) {
           // adjust the previous points
           newPoints.pop()
@@ -79,15 +82,15 @@ const offsetFromPoints = (options, points) => {
     // check for intersection of closing line segments
     const n0 = newPoints[0]
     const n1 = newPoints[1]
-    const ip = intersect(previousSegment[0], previousSegment[1], n0, n1)
+    const ip = intersect(previousSegment[0], previousSegment[1], n0, n1, true)
     if (ip) {
       // adjust the previous points
       newPoints[0] = ip
       newPoints.pop()
     } else {
       const p0 = points[0]
-      const cursegment = [n0, n1]
-      newCorners.push({ c: p0, s0: previousSegment, s1: cursegment })
+      const currentSegment = [n0, n1]
+      newCorners.push({ c: p0, s0: previousSegment, s1: currentSegment })
     }
   }
 
@@ -111,7 +114,7 @@ const offsetFromPoints = (options, points) => {
         newPoints[i] = ip
         newPoints[(i + 1) % newPoints.length] = undefined
       } else {
-        // paralell segments, drop one
+        // parallel segments, drop one
         const p0 = corner.s1[0]
         const i = pointIndex.get(p0)
         newPoints[i] = undefined
@@ -122,7 +125,7 @@ const offsetFromPoints = (options, points) => {
 
   if (corners === 'round') {
     // create rounded corners
-    let cornersegments = Math.floor(segments / 4)
+    let cornerSegments = Math.floor(segments / 4)
     const v0 = vec2.create()
     newCorners.forEach((corner) => {
       // calculate angle of rotation
@@ -139,25 +142,25 @@ const offsetFromPoints = (options, points) => {
 
       if (rotation !== 0.0) {
         // generate the segments
-        cornersegments = Math.floor(segments * (Math.abs(rotation) / TAU))
-        const step = rotation / cornersegments
+        cornerSegments = Math.floor(segments * (Math.abs(rotation) / TAU))
+        const step = rotation / cornerSegments
         const start = vec2.angle(vec2.subtract(v0, corner.s0[1], corner.c))
-        const cornerpoints = []
-        for (let i = 1; i < cornersegments; i++) {
+        const cornerPoints = []
+        for (let i = 1; i < cornerSegments; i++) {
           const radians = start + (step * i)
           const point = vec2.fromAngleRadians(vec2.create(), radians)
           vec2.scale(point, point, delta)
           vec2.add(point, point, corner.c)
-          cornerpoints.push(point)
+          cornerPoints.push(point)
         }
-        if (cornerpoints.length > 0) {
+        if (cornerPoints.length > 0) {
           const p0 = corner.s0[1]
           let i = newPoints.findIndex((point) => vec2.equals(p0, point))
           i = (i + 1) % newPoints.length
-          newPoints.splice(i, 0, ...cornerpoints)
+          newPoints.splice(i, 0, ...cornerPoints)
         }
       } else {
-        // paralell segments, drop one
+        // parallel segments, drop one
         const p0 = corner.s1[0]
         const i = newPoints.findIndex((point) => vec2.equals(p0, point))
         newPoints.splice(i, 1)
@@ -166,5 +169,3 @@ const offsetFromPoints = (options, points) => {
   }
   return newPoints
 }
-
-module.exports = offsetFromPoints