@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/primitives/rectangle.test.js

@@ -1,10 +1,12 @@
-const test = require('ava')
+import test from 'ava'
 
-const { rectangle } = require('./index')
+import { geom2 } from '../geometries/index.js'
 
-const geom2 = require('../geometries/geom2')
+import { measureArea } from '../measurements/index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { rectangle } from './index.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('rectangle (defaults)', (t) => {
   const geometry = rectangle()
@@ -17,7 +19,8 @@ test('rectangle (defaults)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 4)
+  t.is(measureArea(geometry), 4)
+  t.is(obs.length, 4)
   t.true(comparePoints(obs, exp))
 })
 
@@ -33,7 +36,8 @@ test('rectangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 4)
+  t.is(measureArea(geometry), 4)
+  t.is(obs.length, 4)
   t.true(comparePoints(obs, exp))
 
   // test size
@@ -47,7 +51,8 @@ test('rectangle (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 4)
+  t.is(measureArea(geometry), 60)
+  t.is(obs.length, 4)
   t.true(comparePoints(obs, exp))
 })
 
@@ -55,5 +60,6 @@ test('rectangle (zero size)', (t) => {
   const geometry = rectangle({ size: [1, 0] })
   const obs = geom2.toPoints(geometry)
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), 0)
   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,57 +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 { isGTE, isNumberArray } = require('./commonChecks')
-const cuboid = require('./cuboid')
+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) => {
@@ -94,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],
@@ -176,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
@@ -189,5 +190,3 @@ const roundedCuboid = (options) => {
 
   return geom3.create(polygons)
 }
-
-module.exports = roundedCuboid

package/src/primitives/roundedCuboid.test.js

@@ -1,23 +1,29 @@
-const test = require('ava')
+import test from 'ava'
 
-const { roundedCuboid } = require('./index')
+import { geom3 } from '../geometries/index.js'
 
-const geom3 = require('../geometries/geom3')
+import { measureArea, measureVolume } from '../measurements/index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { roundedCuboid } from './index.js'
+
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('roundedCuboid (defaults)', (t) => {
   const obs = roundedCuboid()
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
-  t.deepEqual(pts.length, 614)
+  t.is(measureArea(obs), 21.87859958298585)
+  t.is(measureVolume(obs), 7.800061070935406)
+  t.is(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(measureArea(obs), 0)
+  t.is(measureVolume(obs), 0)
   t.is(pts.length, 0)
 })
 
@@ -25,7 +31,9 @@ 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)
+  t.is(measureArea(obs), 24)
+  t.is(measureVolume(obs), 7.999999999999999)
+  t.is(pts.length, 6)
 })
 
 test('roundedCuboid (options)', (t) => {
@@ -35,6 +43,8 @@ test('roundedCuboid (options)', (t) => {
   let exp = []
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 21.65472758198208)
+  t.is(measureVolume(obs), 7.734600480283937)
   t.is(pts.length, 62)
 
   // test center
@@ -44,6 +54,8 @@ test('roundedCuboid (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 21.65472758198207)
+  t.is(measureVolume(obs), 7.73460048028392)
   t.is(pts.length, 62)
 
   // test size
@@ -144,7 +156,9 @@ test('roundedCuboid (options)', (t) => {
       [-3.8, 4.8, -6], [3.8, 4.8, -6]]
   ]
   t.notThrows(() => geom3.validate(obs))
-  t.deepEqual(pts.length, 62)
+  t.is(measureArea(obs), 580.6448151876211)
+  t.is(measureVolume(obs), 958.6098905200406)
+  t.is(pts.length, 62)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // test roundRadius
@@ -243,6 +257,8 @@ test('roundedCuboid (options)', (t) => {
     [[2, -3, -6], [-2, -3, -6], [-2, 3, -6], [2, 3, -6]]
   ]
   t.notThrows(() => geom3.validate(obs))
-  t.deepEqual(pts.length, 62)
+  t.is(measureArea(obs), 470.09666312772333)
+  t.is(measureVolume(obs), 835.1892253143822)
+  t.is(pts.length, 62)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

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

package/src/primitives/roundedCylinder.js

@@ -1,30 +1,30 @@
-const { EPS, TAU } = require('../maths/constants')
+import { EPS, TAU } from '../maths/constants.js'
+import { sin, cos } from '../maths/utils/trigonometry.js'
 
-const vec3 = require('../maths/vec3')
+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 { isGTE, isNumberArray } = require('./commonChecks')
-const cylinder = require('./cylinder')
+import { cylinder } from './cylinder.js'
 
 /**
  * Construct a Z axis-aligned solid cylinder in three dimensional space with rounded ends.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cylinder
- * @param {Number} [options.height=2] - height of cylinder
- * @param {Number} [options.radius=1] - radius of cylinder
- * @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.height=2] - height of cylinder
+ * @param {number} [options.radius=1] - radius of cylinder
+ * @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.roundedCylinder
  *
  * @example
  * let myshape = roundedCylinder({ height: 10, radius: 2, roundRadius: 0.5 })
  */
-const roundedCylinder = (options) => {
+export const roundedCylinder = (options) => {
   const defaults = {
     center: [0, 0, 0],
     height: 2,
@@ -54,94 +54,91 @@ const roundedCylinder = (options) => {
 
   if ((2 * roundRadius) > (length - EPS)) throw new Error('height must be larger than twice roundRadius')
 
-  let defaultnormal
+  let defaultNormal
   if (Math.abs(direction[0]) > Math.abs(direction[1])) {
-    defaultnormal = vec3.fromValues(0, 1, 0)
+    defaultNormal = vec3.fromValues(0, 1, 0)
   } else {
-    defaultnormal = vec3.fromValues(1, 0, 0)
+    defaultNormal = vec3.fromValues(1, 0, 0)
   }
 
-  const zvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), direction), roundRadius)
-  const xvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), zvector, defaultnormal)), radius)
-  const yvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), xvector, zvector)), radius)
+  const zVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), direction), roundRadius)
+  const xVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), zVector, defaultNormal)), radius)
+  const yVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vec3.cross(vec3.create(), xVector, zVector)), radius)
 
-  vec3.add(start, start, zvector)
-  vec3.subtract(end, end, zvector)
+  vec3.add(start, start, zVector)
+  vec3.subtract(end, end, zVector)
 
-  const qsegments = Math.floor(0.25 * segments)
+  const qSegments = Math.floor(0.25 * segments)
 
-  const fromPoints = (points) => {
-    // adjust the points to center
-    const newpoints = points.map((point) => vec3.add(point, point, center))
-    return poly3.create(newpoints)
+  const fromVertices = (vertices) => {
+    // adjust the vertices to center
+    const newVertices = vertices.map((vertex) => vec3.add(vertex, vertex, center))
+    return poly3.create(newVertices)
   }
 
   const polygons = []
   const v1 = vec3.create()
   const v2 = vec3.create()
-  let prevcylinderpoint
+  let prevCylinderVertex
   for (let slice1 = 0; slice1 <= segments; slice1++) {
     const angle = TAU * slice1 / segments
-    const cylinderpoint = vec3.add(vec3.create(), vec3.scale(v1, xvector, cos(angle)), vec3.scale(v2, yvector, sin(angle)))
+    const cylinderVertex = vec3.add(vec3.create(), vec3.scale(v1, xVector, cos(angle)), vec3.scale(v2, yVector, sin(angle)))
     if (slice1 > 0) {
       // cylinder wall
-      let points = []
-      points.push(vec3.add(vec3.create(), start, cylinderpoint))
-      points.push(vec3.add(vec3.create(), start, prevcylinderpoint))
-      points.push(vec3.add(vec3.create(), end, prevcylinderpoint))
-      points.push(vec3.add(vec3.create(), end, cylinderpoint))
-      polygons.push(fromPoints(points))
-
-      let prevcospitch, prevsinpitch
-      for (let slice2 = 0; slice2 <= qsegments; slice2++) {
-        const pitch = TAU / 4 * slice2 / qsegments
-        const cospitch = cos(pitch)
-        const sinpitch = sin(pitch)
+      let vertices = []
+      vertices.push(vec3.add(vec3.create(), start, cylinderVertex))
+      vertices.push(vec3.add(vec3.create(), start, prevCylinderVertex))
+      vertices.push(vec3.add(vec3.create(), end, prevCylinderVertex))
+      vertices.push(vec3.add(vec3.create(), end, cylinderVertex))
+      polygons.push(fromVertices(vertices))
+
+      let prevCosPitch, prevSinPitch
+      let vertex
+      for (let slice2 = 0; slice2 <= qSegments; slice2++) {
+        const pitch = TAU / 4 * slice2 / qSegments
+        const cosPitch = cos(pitch)
+        const sinPitch = sin(pitch)
         if (slice2 > 0) {
           // cylinder rounding, start
-          points = []
-          let point
-          point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevcylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch)))
-          points.push(point)
-          point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch)))
-          points.push(point)
-          if (slice2 < qsegments) {
-            point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch)))
-            points.push(point)
+          vertices = []
+          vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevCylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch)))
+          vertices.push(vertex)
+          vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch)))
+          vertices.push(vertex)
+          if (slice2 < qSegments) {
+            vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, cylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch)))
+            vertices.push(vertex)
           }
-          point = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevcylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch)))
-          points.push(point)
+          vertex = vec3.add(vec3.create(), start, vec3.subtract(v1, vec3.scale(v1, prevCylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch)))
+          vertices.push(vertex)
 
-          polygons.push(fromPoints(points))
+          polygons.push(fromVertices(vertices))
 
           // cylinder rounding, end
-          points = []
-          point = vec3.add(vec3.create(), vec3.scale(v1, prevcylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch))
-          vec3.add(point, point, end)
-          points.push(point)
-          point = vec3.add(vec3.create(), vec3.scale(v1, cylinderpoint, prevcospitch), vec3.scale(v2, zvector, prevsinpitch))
-          vec3.add(point, point, end)
-          points.push(point)
-          if (slice2 < qsegments) {
-            point = vec3.add(vec3.create(), vec3.scale(v1, cylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch))
-            vec3.add(point, point, end)
-            points.push(point)
+          vertices = []
+          vertex = vec3.add(vec3.create(), vec3.scale(v1, prevCylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch))
+          vec3.add(vertex, vertex, end)
+          vertices.push(vertex)
+          vertex = vec3.add(vec3.create(), vec3.scale(v1, cylinderVertex, prevCosPitch), vec3.scale(v2, zVector, prevSinPitch))
+          vec3.add(vertex, vertex, end)
+          vertices.push(vertex)
+          if (slice2 < qSegments) {
+            vertex = vec3.add(vec3.create(), vec3.scale(v1, cylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch))
+            vec3.add(vertex, vertex, end)
+            vertices.push(vertex)
           }
-          point = vec3.add(vec3.create(), vec3.scale(v1, prevcylinderpoint, cospitch), vec3.scale(v2, zvector, sinpitch))
-          vec3.add(point, point, end)
-          points.push(point)
-          points.reverse()
+          vertex = vec3.add(vec3.create(), vec3.scale(v1, prevCylinderVertex, cosPitch), vec3.scale(v2, zVector, sinPitch))
+          vec3.add(vertex, vertex, end)
+          vertices.push(vertex)
+          vertices.reverse()
 
-          polygons.push(fromPoints(points))
+          polygons.push(fromVertices(vertices))
         }
-        prevcospitch = cospitch
-        prevsinpitch = sinpitch
+        prevCosPitch = cosPitch
+        prevSinPitch = sinPitch
       }
     }
-    prevcylinderpoint = cylinderpoint
+    prevCylinderVertex = cylinderVertex
   }
-  const result = geom3.create(polygons)
-  return result
+  return geom3.create(polygons)
 }
-
-module.exports = roundedCylinder

package/src/primitives/roundedCylinder.test.js

@@ -1,16 +1,20 @@
-const test = require('ava')
+import test from 'ava'
 
-const geom3 = require('../geometries/geom3')
+import { geom3 } from '../geometries/index.js'
 
-const { roundedCylinder } = require('./index')
+import { measureArea, measureVolume } from '../measurements/index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { roundedCylinder } from './index.js'
+
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('roundedCylinder (defaults)', (t) => {
   const obs = roundedCylinder()
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 16.844951865908268)
+  t.is(measureVolume(obs), 5.81870059177007)
   t.is(pts.length, 544)
 })
 
@@ -18,6 +22,8 @@ test('roundedCylinder (zero height)', (t) => {
   const obs = roundedCylinder({ height: 0 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 0)
+  t.is(measureVolume(obs), 0)
   t.is(pts.length, 0)
 })
 
@@ -25,6 +31,8 @@ test('roundedCylinder (zero radius)', (t) => {
   const obs = roundedCylinder({ radius: 0, roundRadius: 0 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 0)
+  t.is(measureVolume(obs), 0)
   t.is(pts.length, 0)
 })
 
@@ -32,6 +40,8 @@ test('roundedCylinder (zero roundRadius)', (t) => {
   const obs = roundedCylinder({ roundRadius: 0 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 18.789084266699856)
+  t.is(measureVolume(obs), 6.2428903045161)
   t.is(pts.length, 96)
 })
 
@@ -43,6 +53,8 @@ test('roundedCylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 14.303000362787825)
+  t.is(measureVolume(obs), 4.121244903945666)
   t.is(pts.length, 15)
 
   // test center
@@ -72,6 +84,8 @@ test('roundedCylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 14.303000362787827)
+  t.is(measureVolume(obs), 4.121244903945658)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -102,6 +116,8 @@ test('roundedCylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 120.104345775433)
+  t.is(measureVolume(obs), 46.91878813722758)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -131,6 +147,8 @@ test('roundedCylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 569.7191848255909)
+  t.is(measureVolume(obs), 412.1244903945666)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -160,6 +178,8 @@ test('roundedCylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 602.8474323274462)
+  t.is(measureVolume(obs), 1030.3112259864165)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/primitives/roundedRectangle.d.ts

@@ -1,7 +1,5 @@
-import Vec2 from '../maths/vec2/type'
-import Geom2 from '../geometries/geom2/type'
-
-export default roundedRectangle
+import type { Vec2 } from '../maths/vec2/type.d.ts'
+import type { Geom2 } from '../geometries/geom2/type.d.ts'
 
 export interface RoundedRectangleOptions {
   center?: Vec2
@@ -10,4 +8,4 @@ export interface RoundedRectangleOptions {
   segments?: number
 }
 
-declare function roundedRectangle(options?: RoundedRectangleOptions): Geom2
+export function roundedRectangle(options?: RoundedRectangleOptions): Geom2