@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/primitives/polyhedron.js

@@ -1,26 +1,26 @@
-const geom3 = require('../geometries/geom3')
-const poly3 = require('../geometries/poly3')
+import * as geom3 from '../geometries/geom3/index.js'
+import * as poly3 from '../geometries/poly3/index.js'
 
-const { isNumberArray } = require('./commonChecks')
+import { isNumberArray } from './commonChecks.js'
 
 /**
- * Construct a polyhedron in three dimensional space from the given set of 3D points and faces.
+ * Construct a polyhedron in three dimensional space from the given set of 3D vertices and faces.
  * The faces can define outward or inward facing polygons (orientation).
- * However, each face must define a counter clockwise rotation of points which follows the right hand rule.
- * @param {Object} options - options for construction
+ * However, each face must define a counterclockwise rotation of vertices which follows the right hand rule.
+ * @param {object} options - options for construction
  * @param {Array} options.points - list of points in 3D space
  * @param {Array} options.faces - list of faces, where each face is a set of indexes into the points
  * @param {Array} [options.colors=undefined] - list of RGBA colors to apply to each face
- * @param {String} [options.orientation='outward'] - orientation of faces
- * @returns {geom3} new 3D geometry
+ * @param {string} [options.orientation='outward'] - orientation of faces
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.polyhedron
  *
  * @example
- * let mypoints = [ [10, 10, 0], [10, -10, 0], [-10, -10, 0], [-10, 10, 0], [0, 0, 10] ]
- * let myfaces = [ [0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3] ]
- * let myshape = polyhedron({points: mypoint, faces: myfaces, orientation: 'inward'})
+ * let myPoints = [ [10, 10, 0], [10, -10, 0], [-10, -10, 0], [-10, 10, 0], [0, 0, 10] ]
+ * let myFaces = [ [0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3] ]
+ * let myShape = polyhedron({points: myPoints, faces: myFaces, orientation: 'inward'})
  */
-const polyhedron = (options) => {
+export const polyhedron = (options) => {
   const defaults = {
     points: [],
     faces: [],
@@ -46,15 +46,15 @@ const polyhedron = (options) => {
       throw new Error('faces and colors must have the same length')
     }
   }
-  points.forEach((point, i) => {
-    if (!isNumberArray(point, 3)) throw new Error(`point ${i} must be an array of X, Y, Z values`)
+  points.forEach((vertex, i) => {
+    if (!isNumberArray(vertex, 3)) throw new Error(`vertex ${i} must be an array of X, Y, Z values`)
   })
   faces.forEach((face, i) => {
     if (face.length < 3) throw new Error(`face ${i} must contain 3 or more indexes`)
     if (!isNumberArray(face, face.length)) throw new Error(`face ${i} must be an array of numbers`)
   })
 
-  // invert the faces if orientation is inwards, as all internals expect outwarding facing polygons
+  // invert the faces if orientation is inwards, as all internals expect outward facing polygons
   if (orientation !== 'outward') {
     faces.forEach((face) => face.reverse())
   }
@@ -67,5 +67,3 @@ const polyhedron = (options) => {
 
   return geom3.create(polygons)
 }
-
-module.exports = polyhedron

package/src/primitives/polyhedron.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { polyhedron } = require('./index')
+import { geom3 } from '../geometries/index.js'
 
-const geom3 = require('../geometries/geom3')
+import { polyhedron } from './index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('polyhedron (points and faces)', (t) => {
   // points and faces form a cube

package/src/primitives/rectangle.d.ts

@@ -1,11 +1,9 @@
-import Vec2 from '../maths/vec2/type'
-import Geom2 from '../geometries/geom2/type'
-
-export default rectangle
+import type { Vec2 } from '../maths/vec2/type.d.ts'
+import type { Geom2 } from '../geometries/geom2/type.d.ts'
 
 export interface RectangleOptions {
   center?: Vec2
   size?: Vec2
 }
 
-declare function rectangle(options?: RectangleOptions): Geom2
+export function rectangle(options?: RectangleOptions): Geom2

package/src/primitives/rectangle.js

@@ -1,21 +1,21 @@
-const vec2 = require('../maths/vec2')
+import * as vec2 from '../maths/vec2/index.js'
 
-const geom2 = require('../geometries/geom2')
+import * as geom2 from '../geometries/geom2/index.js'
 
-const { isNumberArray } = require('./commonChecks')
+import { isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned rectangle in two dimensional space with four sides at right angles.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of rectangle
  * @param {Array} [options.size=[2,2]] - dimension of rectangle, width and length
- * @returns {geom2} new 2D geometry
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.rectangle
  *
  * @example
  * let myshape = rectangle({size: [10, 20]})
  */
-const rectangle = (options) => {
+export const rectangle = (options) => {
   const defaults = {
     center: [0, 0],
     size: [2, 2]
@@ -24,18 +24,19 @@ const rectangle = (options) => {
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isNumberArray(size, 2)) throw new Error('size must be an array of X and Y values')
-  if (!size.every((n) => n > 0)) throw new Error('size values must be greater than zero')
+  if (!size.every((n) => n >= 0)) throw new Error('size values must be positive')
+
+  // if any size is zero return empty geometry
+  if (size[0] === 0 || size[1] === 0) return geom2.create()
 
   const point = [size[0] / 2, size[1] / 2]
-  const pswap = [point[0], -point[1]]
+  const swapped = [point[0], -point[1]]
 
   const points = [
     vec2.subtract(vec2.create(), center, point),
-    vec2.add(vec2.create(), center, pswap),
+    vec2.add(vec2.create(), center, swapped),
     vec2.add(vec2.create(), center, point),
-    vec2.subtract(vec2.create(), center, pswap)
+    vec2.subtract(vec2.create(), center, swapped)
   ]
-  return geom2.fromPoints(points)
+  return geom2.create([points])
 }
-
-module.exports = rectangle

package/src/primitives/rectangle.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { rectangle } = require('./index')
+import { geom2 } from '../geometries/index.js'
 
-const geom2 = require('../geometries/geom2')
+import { rectangle } from './index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('rectangle (defaults)', (t) => {
   const geometry = rectangle()
@@ -50,3 +50,10 @@ test('rectangle (options)', (t) => {
   t.deepEqual(obs.length, 4)
   t.true(comparePoints(obs, exp))
 })
+
+test('rectangle (zero size)', (t) => {
+  const geometry = rectangle({ size: [1, 0] })
+  const obs = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(obs.length, 0)
+})

package/src/primitives/roundedCuboid.d.ts

@@ -1,7 +1,5 @@
-import Vec3 from '../maths/vec3/type'
-import Geom3 from '../geometries/geom3/type'
-
-export default roundedCuboid
+import type { Vec3 } from '../maths/vec3/type.d.ts'
+import type { Geom3 } from '../geometries/geom3/type.d.ts'
 
 export interface RoundedCuboidOptions {
   center?: Vec3
@@ -10,4 +8,4 @@ export interface RoundedCuboidOptions {
   segments?: number
 }
 
-declare function roundedCuboid(options?: RoundedCuboidOptions): Geom3
+export function roundedCuboid(options?: RoundedCuboidOptions): Geom3

package/src/primitives/roundedCuboid.js

@@ -1,56 +1,58 @@
-const { EPS, TAU } = require('../maths/constants')
+import { EPS, TAU } from '../maths/constants.js'
+import { sin, cos } from '../maths/utils/trigonometry.js'
 
-const vec2 = require('../maths/vec2')
-const vec3 = require('../maths/vec3')
+import * as vec2 from '../maths/vec2/index.js'
+import * as vec3 from '../maths/vec3/index.js'
 
-const geom3 = require('../geometries/geom3')
-const poly3 = require('../geometries/poly3')
+import * as geom3 from '../geometries/geom3/index.js'
+import * as poly3 from '../geometries/poly3/index.js'
 
-const { sin, cos } = require('../maths/utils/trigonometry')
+import { isGTE, isNumberArray } from './commonChecks.js'
 
-const { isGT, isGTE, isNumberArray } = require('./commonChecks')
+import { cuboid } from './cuboid.js'
 
 const createCorners = (center, size, radius, segments, slice, positive) => {
   const pitch = (TAU / 4) * slice / segments
-  const cospitch = cos(pitch)
-  const sinpitch = sin(pitch)
-
-  const layersegments = segments - slice
-  let layerradius = radius * cospitch
-  let layeroffset = size[2] - (radius - (radius * sinpitch))
-  if (!positive) layeroffset = (radius - (radius * sinpitch)) - size[2]
-
-  layerradius = layerradius > EPS ? layerradius : 0
-
-  const corner0 = vec3.add(vec3.create(), center, [size[0] - radius, size[1] - radius, layeroffset])
-  const corner1 = vec3.add(vec3.create(), center, [radius - size[0], size[1] - radius, layeroffset])
-  const corner2 = vec3.add(vec3.create(), center, [radius - size[0], radius - size[1], layeroffset])
-  const corner3 = vec3.add(vec3.create(), center, [size[0] - radius, radius - size[1], layeroffset])
-  const corner0Points = []
-  const corner1Points = []
-  const corner2Points = []
-  const corner3Points = []
-  for (let i = 0; i <= layersegments; i++) {
-    const radians = layersegments > 0 ? TAU / 4 * i / layersegments : 0
+  const cosPitch = cos(pitch)
+  const sinPitch = sin(pitch)
+
+  const layerSegments = segments - slice
+  let layerRadius = radius * cosPitch
+  let layerOffset = size[2] - (radius - (radius * sinPitch))
+  if (!positive) layerOffset = (radius - (radius * sinPitch)) - size[2]
+
+  layerRadius = layerRadius > EPS ? layerRadius : 0
+
+  const corner0 = vec3.add(vec3.create(), center, [size[0] - radius, size[1] - radius, layerOffset])
+  const corner1 = vec3.add(vec3.create(), center, [radius - size[0], size[1] - radius, layerOffset])
+  const corner2 = vec3.add(vec3.create(), center, [radius - size[0], radius - size[1], layerOffset])
+  const corner3 = vec3.add(vec3.create(), center, [size[0] - radius, radius - size[1], layerOffset])
+  const corner0Vertices = []
+  const corner1Vertices = []
+  const corner2Vertices = []
+  const corner3Vertices = []
+  for (let i = 0; i <= layerSegments; i++) {
+    const radians = layerSegments > 0 ? TAU / 4 * i / layerSegments : 0
+    // FIXME allocate only once
     const point2d = vec2.fromAngleRadians(vec2.create(), radians)
-    vec2.scale(point2d, point2d, layerradius)
+    vec2.scale(point2d, point2d, layerRadius)
     const point3d = vec3.fromVec2(vec3.create(), point2d)
-    corner0Points.push(vec3.add(vec3.create(), corner0, point3d))
+    corner0Vertices.push(vec3.add(vec3.create(), corner0, point3d))
     vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
-    corner1Points.push(vec3.add(vec3.create(), corner1, point3d))
+    corner1Vertices.push(vec3.add(vec3.create(), corner1, point3d))
     vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
-    corner2Points.push(vec3.add(vec3.create(), corner2, point3d))
+    corner2Vertices.push(vec3.add(vec3.create(), corner2, point3d))
     vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
-    corner3Points.push(vec3.add(vec3.create(), corner3, point3d))
+    corner3Vertices.push(vec3.add(vec3.create(), corner3, point3d))
   }
   if (!positive) {
-    corner0Points.reverse()
-    corner1Points.reverse()
-    corner2Points.reverse()
-    corner3Points.reverse()
-    return [corner3Points, corner2Points, corner1Points, corner0Points]
+    corner0Vertices.reverse()
+    corner1Vertices.reverse()
+    corner2Vertices.reverse()
+    corner3Vertices.reverse()
+    return [corner3Vertices, corner2Vertices, corner1Vertices, corner0Vertices]
   }
-  return [corner0Points, corner1Points, corner2Points, corner3Points]
+  return [corner0Vertices, corner1Vertices, corner2Vertices, corner3Vertices]
 }
 
 const stitchCorners = (previousCorners, currentCorners) => {
@@ -93,38 +95,38 @@ const stitchSides = (bottomCorners, topCorners) => {
   bottomCorners = [bottomCorners[3], bottomCorners[2], bottomCorners[1], bottomCorners[0]]
   bottomCorners = bottomCorners.map((corner) => corner.slice().reverse())
 
-  const bottomPoints = []
+  const bottomVertices = []
   bottomCorners.forEach((corner) => {
-    corner.forEach((point) => bottomPoints.push(point))
+    corner.forEach((vertex) => bottomVertices.push(vertex))
   })
 
-  const topPoints = []
+  const topVertices = []
   topCorners.forEach((corner) => {
-    corner.forEach((point) => topPoints.push(point))
+    corner.forEach((vertex) => topVertices.push(vertex))
   })
 
   const polygons = []
-  for (let i = 0; i < topPoints.length; i++) {
-    const j = (i + 1) % topPoints.length
-    polygons.push(poly3.create([bottomPoints[i], bottomPoints[j], topPoints[j], topPoints[i]]))
+  for (let i = 0; i < topVertices.length; i++) {
+    const j = (i + 1) % topVertices.length
+    polygons.push(poly3.create([bottomVertices[i], bottomVertices[j], topVertices[j], topVertices[i]]))
   }
   return polygons
 }
 
 /**
  * Construct an axis-aligned solid cuboid in three dimensional space with rounded corners.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of rounded cube
  * @param {Array} [options.size=[2,2,2]] - dimension of rounded cube; width, depth, height
- * @param {Number} [options.roundRadius=0.2] - radius of rounded edges
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @returns {geom3} new 3D geometry
+ * @param {number} [options.roundRadius=0.2] - radius of rounded edges
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.roundedCuboid
  *
  * @example
- * let mycube = roundedCuboid({size: [10, 20, 10], roundRadius: 2, segments: 16})
+ * let myCube = roundedCuboid({size: [10, 20, 10], roundRadius: 2, segments: 16})
  */
-const roundedCuboid = (options) => {
+export const roundedCuboid = (options) => {
   const defaults = {
     center: [0, 0, 0],
     size: [2, 2, 2],
@@ -135,10 +137,16 @@ const roundedCuboid = (options) => {
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(size, 3)) throw new Error('size must be an array of X, Y and Z values')
-  if (!size.every((n) => n > 0)) throw new Error('size values must be greater than zero')
-  if (!isGT(roundRadius, 0)) throw new Error('roundRadius must be greater than zero')
+  if (!size.every((n) => n >= 0)) throw new Error('size values must be positive')
+  if (!isGTE(roundRadius, 0)) throw new Error('roundRadius must be positive')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
+  // if any size is zero return empty geometry
+  if (size[0] === 0 || size[1] === 0 || size[2] === 0) return geom3.create()
+
+  // if roundRadius is zero, return cuboid
+  if (roundRadius === 0) return cuboid({ center, size })
+
   size = size.map((v) => v / 2) // convert to radius
 
   if (roundRadius > (size[0] - EPS) ||
@@ -169,11 +177,11 @@ const roundedCuboid = (options) => {
 
     if (slice === segments) {
       // add the top
-      let points = cornersPos.map((corner) => corner[0])
-      polygons.push(poly3.create(points))
+      let vertices = cornersPos.map((corner) => corner[0])
+      polygons.push(poly3.create(vertices))
       // add the bottom
-      points = cornersNeg.map((corner) => corner[0])
-      polygons.push(poly3.create(points))
+      vertices = cornersNeg.map((corner) => corner[0])
+      polygons.push(poly3.create(vertices))
     }
 
     prevCornersPos = cornersPos
@@ -182,5 +190,3 @@ const roundedCuboid = (options) => {
 
   return geom3.create(polygons)
 }
-
-module.exports = roundedCuboid

package/src/primitives/roundedCuboid.test.js

@@ -1,10 +1,10 @@
-const test = require('ava')
+import test from 'ava'
 
-const { roundedCuboid } = require('./index')
+import { geom3 } from '../geometries/index.js'
 
-const geom3 = require('../geometries/geom3')
+import { roundedCuboid } from './index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('roundedCuboid (defaults)', (t) => {
   const obs = roundedCuboid()
@@ -14,6 +14,20 @@ test('roundedCuboid (defaults)', (t) => {
   t.deepEqual(pts.length, 614)
 })
 
+test('roundedCuboid (zero size)', (t) => {
+  const obs = roundedCuboid({ size: [1, 1, 0] })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})
+
+test('roundedCuboid (zero radius)', (t) => {
+  const obs = roundedCuboid({ roundRadius: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.deepEqual(pts.length, 6)
+})
+
 test('roundedCuboid (options)', (t) => {
   // test segments
   let obs = roundedCuboid({ segments: 8 })

package/src/primitives/roundedCylinder.d.ts

@@ -1,7 +1,5 @@
-import Vec3 from '../maths/vec3/type'
-import Geom3 from '../geometries/geom3/type'
-
-export default roundedCylinder
+import type { Vec3 } from '../maths/vec3/type.d.ts'
+import type { Geom3 } from '../geometries/geom3/type.d.ts'
 
 export interface RoundedCylinderOptions {
   center?: Vec3
@@ -11,4 +9,4 @@ export interface RoundedCylinderOptions {
   segments?: number
 }
 
-declare function roundedCylinder(options?: RoundedCylinderOptions): Geom3
+export function roundedCylinder(options?: RoundedCylinderOptions): Geom3