@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/primitives/cylinderElliptic.js

@@ -1,31 +1,31 @@
-const { EPS, TAU } = require('../maths/constants')
+import { EPS, TAU } from '../maths/constants.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 { sin, cos } from '../maths/utils/trigonometry.js'
 
-const { isGT, isGTE, isNumberArray } = require('./commonChecks')
+import { isGT, isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct a Z axis-aligned elliptic cylinder in three dimensional space.
- * @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.height=2] - height of cylinder
  * @param {Array} [options.startRadius=[1,1]] - radius of rounded start, must be two dimensional array
- * @param {Number} [options.startAngle=0] - start angle of cylinder, in radians
+ * @param {number} [options.startAngle=0] - start angle of cylinder, in radians
  * @param {Array} [options.endRadius=[1,1]] - radius of rounded end, must be two dimensional array
- * @param {Number} [options.endAngle=TAU] - end angle of cylinder, in radians
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @returns {geom3} new geometry
+ * @param {number} [options.endAngle=TAU] - end angle of cylinder, in radians
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {Geom3} new geometry
  * @alias module:modeling/primitives.cylinderElliptic
  *
  * @example
  * let myshape = cylinderElliptic({height: 2, startRadius: [10,5], endRadius: [8,3]})
  */
-const cylinderElliptic = (options) => {
+export const cylinderElliptic = (options) => {
   const defaults = {
     center: [0, 0, 0],
     height: 2,
@@ -59,10 +59,10 @@ const cylinderElliptic = (options) => {
     rotation = endAngle + (TAU - startAngle)
   }
 
-  const minradius = Math.min(startRadius[0], startRadius[1], endRadius[0], endRadius[1])
-  const minangle = Math.acos(((minradius * minradius) + (minradius * minradius) - (EPS * EPS)) /
-                            (2 * minradius * minradius))
-  if (rotation < minangle) throw new Error('startAngle and endAngle do not define a significant rotation')
+  const minRadius = Math.min(startRadius[0], startRadius[1], endRadius[0], endRadius[1])
+  const minAngle = Math.acos(((minRadius * minRadius) + (minRadius * minRadius) - (EPS * EPS)) /
+                            (2 * minRadius * minRadius))
+  if (rotation < minAngle) throw new Error('startAngle and endAngle do not define a significant rotation')
 
   const slices = Math.floor(segments * (rotation / TAU))
 
@@ -76,7 +76,7 @@ const cylinderElliptic = (options) => {
   const v1 = vec3.create()
   const v2 = vec3.create()
   const v3 = vec3.create()
-  const point = (stack, slice, radius) => {
+  const genVertex = (stack, slice, radius) => {
     const angle = slice * rotation + startAngle
     vec3.scale(v1, axisX, radius[0] * cos(angle))
     vec3.scale(v2, axisY, radius[1] * sin(angle))
@@ -87,10 +87,10 @@ const cylinderElliptic = (options) => {
     return vec3.add(vec3.create(), v1, v3)
   }
 
-  // adjust the points to center
-  const fromPoints = (...points) => {
-    const newpoints = points.map((point) => vec3.add(vec3.create(), point, center))
-    return poly3.create(newpoints)
+  // adjust the vertices to center
+  const fromVertices = (...vertices) => {
+    const newVertices = vertices.map((vertex) => vec3.add(vec3.create(), vertex, center))
+    return poly3.create(newVertices)
   }
 
   const polygons = []
@@ -101,32 +101,30 @@ const cylinderElliptic = (options) => {
     if (rotation === TAU && i === slices - 1) t1 = 0
 
     if (endRadius[0] === startRadius[0] && endRadius[1] === startRadius[1]) {
-      polygons.push(fromPoints(start, point(0, t1, endRadius), point(0, t0, endRadius)))
-      polygons.push(fromPoints(point(0, t1, endRadius), point(1, t1, endRadius), point(1, t0, endRadius), point(0, t0, endRadius)))
-      polygons.push(fromPoints(end, point(1, t0, endRadius), point(1, t1, endRadius)))
+      polygons.push(fromVertices(start, genVertex(0, t1, endRadius), genVertex(0, t0, endRadius)))
+      polygons.push(fromVertices(genVertex(0, t1, endRadius), genVertex(1, t1, endRadius), genVertex(1, t0, endRadius), genVertex(0, t0, endRadius)))
+      polygons.push(fromVertices(end, genVertex(1, t0, endRadius), genVertex(1, t1, endRadius)))
     } else {
       if (startRadius[0] > 0 && startRadius[1] > 0) {
-        polygons.push(fromPoints(start, point(0, t1, startRadius), point(0, t0, startRadius)))
+        polygons.push(fromVertices(start, genVertex(0, t1, startRadius), genVertex(0, t0, startRadius)))
       }
       if (startRadius[0] > 0 || startRadius[1] > 0) {
-        polygons.push(fromPoints(point(0, t0, startRadius), point(0, t1, startRadius), point(1, t0, endRadius)))
+        polygons.push(fromVertices(genVertex(0, t0, startRadius), genVertex(0, t1, startRadius), genVertex(1, t0, endRadius)))
       }
       if (endRadius[0] > 0 && endRadius[1] > 0) {
-        polygons.push(fromPoints(end, point(1, t0, endRadius), point(1, t1, endRadius)))
+        polygons.push(fromVertices(end, genVertex(1, t0, endRadius), genVertex(1, t1, endRadius)))
       }
       if (endRadius[0] > 0 || endRadius[1] > 0) {
-        polygons.push(fromPoints(point(1, t0, endRadius), point(0, t1, startRadius), point(1, t1, endRadius)))
+        polygons.push(fromVertices(genVertex(1, t0, endRadius), genVertex(0, t1, startRadius), genVertex(1, t1, endRadius)))
       }
     }
   }
   if (rotation < TAU) {
-    polygons.push(fromPoints(start, point(0, 0, startRadius), end))
-    polygons.push(fromPoints(point(0, 0, startRadius), point(1, 0, endRadius), end))
-    polygons.push(fromPoints(start, end, point(0, 1, startRadius)))
-    polygons.push(fromPoints(point(0, 1, startRadius), end, point(1, 1, endRadius)))
+    polygons.push(fromVertices(start, genVertex(0, 0, startRadius), end))
+    polygons.push(fromVertices(genVertex(0, 0, startRadius), genVertex(1, 0, endRadius), end))
+    polygons.push(fromVertices(start, end, genVertex(0, 1, startRadius)))
+    polygons.push(fromVertices(genVertex(0, 1, startRadius), end, genVertex(1, 1, endRadius)))
   }
   const result = geom3.create(polygons)
   return result
 }
-
-module.exports = cylinderElliptic

package/src/primitives/cylinderElliptic.test.js

@@ -1,17 +1,22 @@
-const test = require('ava')
+import test from 'ava'
 
-const { TAU } = require('../maths/constants')
-const geom3 = require('../geometries/geom3')
+import { geom3 } from '../geometries/index.js'
 
-const { cylinderElliptic } = require('./index')
+import { TAU } from '../maths/constants.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { measureArea, measureVolume } from '../measurements/index.js'
+
+import { cylinderElliptic } from './index.js'
+
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cylinderElliptic (defaults)', (t) => {
   const obs = cylinderElliptic()
   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)
 })
 
@@ -71,6 +76,8 @@ test('cylinderElliptic (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 68.11657082460499)
+  t.is(measureVolume(obs), 30.00000000000001)
   t.is(pts.length, 36)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -129,6 +136,8 @@ test('cylinderElliptic (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 32.34210030145122)
+  t.is(measureVolume(obs), 12.999999999999991)
   t.is(pts.length, 48)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -137,6 +146,8 @@ test('cylinderElliptic (options)', (t) => {
   pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 22.17105015072561)
+  t.is(measureVolume(obs), 6.5)
   t.is(pts.length, 28)
 
   // test startAngle and endAngle
@@ -144,6 +155,8 @@ test('cylinderElliptic (options)', (t) => {
   pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 18.78908426669986)
+  t.is(measureVolume(obs), 6.2428903045160995)
   t.is(pts.length, 96)
 
   // test segments
@@ -151,6 +164,8 @@ test('cylinderElliptic (options)', (t) => {
   pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 17.902724085175244)
+  t.is(measureVolume(obs), 5.6568542494923815)
   t.is(pts.length, 24)
 
   // test center
@@ -192,6 +207,8 @@ test('cylinderElliptic (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 24.025659003016692)
+  t.is(measureVolume(obs), 8.485281374238578)
   t.is(pts.length, 24)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -201,6 +218,8 @@ test('cylinderElliptic (cone)', (t) => {
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 10.128239395900382)
+  t.is(measureVolume(obs), 2.080963434838702)
   t.is(pts.length, 64)
 })
 
@@ -209,5 +228,7 @@ test('cylinderElliptic (squished)', (t) => {
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 8.47213595499958)
+  t.is(measureVolume(obs), 0.6666666666666666)
   t.is(pts.length, 8)
 })

package/src/primitives/ellipse.d.ts

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

package/src/primitives/ellipse.js

@@ -1,28 +1,28 @@
-const { EPS, TAU } = require('../maths/constants')
+import { EPS, TAU } from '../maths/constants.js'
 
-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 { sin, cos } = require('../maths/utils/trigonometry')
+import { sin, cos } from '../maths/utils/trigonometry.js'
 
-const { isGTE, isNumberArray } = require('./commonChecks')
+import { isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned ellipse in two dimensional space.
  * @see https://en.wikipedia.org/wiki/Ellipse
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of ellipse
  * @param {Array} [options.radius=[1,1]] - radius of ellipse, along X and Y
- * @param {Number} [options.startAngle=0] - start angle of ellipse, in radians
- * @param {Number} [options.endAngle=TAU] - end angle of ellipse, in radians
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @returns {geom2} new 2D geometry
+ * @param {number} [options.startAngle=0] - start angle of ellipse, in radians
+ * @param {number} [options.endAngle=TAU] - end angle of ellipse, in radians
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.ellipse
  * @example
  * let myshape = ellipse({radius: [5,10]})
  */
-const ellipse = (options) => {
+export const ellipse = (options) => {
   const defaults = {
     center: [0, 0],
     radius: [1, 1],
@@ -53,14 +53,14 @@ const ellipse = (options) => {
     rotation = endAngle + (TAU - startAngle)
   }
 
-  const minradius = Math.min(radius[0], radius[1])
-  const minangle = Math.acos(((minradius * minradius) + (minradius * minradius) - (EPS * EPS)) /
-                            (2 * minradius * minradius))
-  if (rotation < minangle) throw new Error('startAngle and endAngle do not define a significant rotation')
+  const minRadius = Math.min(radius[0], radius[1])
+  const minAngle = Math.acos(((minRadius * minRadius) + (minRadius * minRadius) - (EPS * EPS)) /
+                            (2 * minRadius * minRadius))
+  if (rotation < minAngle) throw new Error('startAngle and endAngle do not define a significant rotation')
 
   segments = Math.floor(segments * (rotation / TAU))
 
-  const centerv = vec2.clone(center)
+  const centerV = vec2.clone(center)
   const step = rotation / segments // radians per segment
 
   const points = []
@@ -68,11 +68,9 @@ const ellipse = (options) => {
   for (let i = 0; i < segments; i++) {
     const angle = (step * i) + startAngle
     const point = vec2.fromValues(radius[0] * cos(angle), radius[1] * sin(angle))
-    vec2.add(point, centerv, point)
+    vec2.add(point, centerV, point)
     points.push(point)
   }
-  if (rotation < TAU) points.push(centerv)
-  return geom2.fromPoints(points)
+  if (rotation < TAU) points.push(centerV)
+  return geom2.create([points])
 }
-
-module.exports = ellipse

package/src/primitives/ellipse.test.js

@@ -1,18 +1,22 @@
-const test = require('ava')
+import test from 'ava'
 
-const { TAU } = require('../maths/constants')
-const geom2 = require('../geometries/geom2')
+import { geom2 } from '../geometries/index.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { TAU } from '../maths/constants.js'
 
-const { ellipse } = require('./index')
+import { measureArea } from '../measurements/index.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
+
+import { ellipse } from './index.js'
 
 test('ellipse (defaults)', (t) => {
   const geometry = ellipse()
   const obs = geom2.toPoints(geometry)
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 32)
+  t.is(measureArea(geometry), 3.1214451522580537)
+  t.is(obs.length, 32)
 })
 
 test('ellipse (options)', (t) => {
@@ -55,7 +59,8 @@ test('ellipse (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 32)
+  t.is(measureArea(geometry), 3.121445152258051)
+  t.is(obs.length, 32)
   t.true(comparePoints(obs, exp))
 
   // test radius
@@ -81,7 +86,8 @@ test('ellipse (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 16)
+  t.is(measureArea(geometry), 45.92201188381077)
+  t.is(obs.length, 16)
   t.true(comparePoints(obs, exp))
 
   // test startAngle
@@ -105,7 +111,8 @@ test('ellipse (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 14)
+  t.is(measureArea(geometry), 34.44150891285808)
+  t.is(obs.length, 14)
   t.true(comparePoints(obs, exp))
 
   // test endAngle
@@ -121,7 +128,8 @@ test('ellipse (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 6)
+  t.is(measureArea(geometry), 11.480502970952696)
+  t.is(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
   // test full rotation with non-zero startAngle
@@ -129,18 +137,21 @@ test('ellipse (options)', (t) => {
   obs = geom2.toPoints(geometry)
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 32)
+  t.is(measureArea(geometry), 3.1214451522580537)
+  t.is(obs.length, 32)
 
   // test segments
   geometry = ellipse({ segments: 72 })
   obs = geom2.toPoints(geometry)
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 72)
+  t.is(measureArea(geometry), 3.1376067389156956)
+  t.is(obs.length, 72)
 })
 
 test('ellipse (zero radius)', (t) => {
   const geometry = ellipse({ radius: [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/ellipsoid.d.ts

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

package/src/primitives/ellipsoid.js

@@ -1,27 +1,26 @@
-const { TAU } = require('../maths/constants')
-const vec3 = require('../maths/vec3')
+import { TAU } from '../maths/constants.js'
+import { sin, cos } from '../maths/utils/trigonometry.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')
-
-const { isGTE, isNumberArray } = require('./commonChecks')
+import { isGTE, isNumberArray } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned ellipsoid in three dimensional space.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of ellipsoid
  * @param {Array} [options.radius=[1,1,1]] - radius of ellipsoid, along X, Y and Z
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
  * @param {Array} [options.axes] -  an array with three vectors for the x, y and z base vectors
- * @returns {geom3} new 3D geometry
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.ellipsoid
  *
  * @example
  * let myshape = ellipsoid({radius: [5, 10, 20]})
 */
-const ellipsoid = (options) => {
+export const ellipsoid = (options) => {
   const defaults = {
     center: [0, 0, 0],
     radius: [1, 1, 1],
@@ -38,62 +37,60 @@ const ellipsoid = (options) => {
   // if any radius is zero return empty geometry
   if (radius[0] === 0 || radius[1] === 0 || radius[2] === 0) return geom3.create()
 
-  const xvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[0]), radius[0])
-  const yvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[1]), radius[1])
-  const zvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[2]), radius[2])
+  const xVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[0]), radius[0])
+  const yVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[1]), radius[1])
+  const zVector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[2]), radius[2])
 
-  const qsegments = Math.round(segments / 4)
-  let prevcylinderpoint
+  const qSegments = Math.round(segments / 4)
+  let prevCylinderVertex
   const polygons = []
   const p1 = vec3.create()
   const p2 = vec3.create()
   for (let slice1 = 0; slice1 <= segments; slice1++) {
     const angle = TAU * slice1 / segments
-    const cylinderpoint = vec3.add(vec3.create(), vec3.scale(p1, xvector, cos(angle)), vec3.scale(p2, yvector, sin(angle)))
+    const cylinderVertex = vec3.add(vec3.create(), vec3.scale(p1, xVector, cos(angle)), vec3.scale(p2, yVector, sin(angle)))
     if (slice1 > 0) {
-      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 prevCosPitch, prevSinPitch
+      for (let slice2 = 0; slice2 <= qSegments; slice2++) {
+        const pitch = TAU / 4 * slice2 / qSegments
+        const cosPitch = cos(pitch)
+        const sinPitch = sin(pitch)
         if (slice2 > 0) {
-          let points = []
-          let point
-          point = vec3.subtract(vec3.create(), vec3.scale(p1, prevcylinderpoint, prevcospitch), vec3.scale(p2, zvector, prevsinpitch))
-          points.push(vec3.add(point, point, center))
-          point = vec3.subtract(vec3.create(), vec3.scale(p1, cylinderpoint, prevcospitch), vec3.scale(p2, zvector, prevsinpitch))
-          points.push(vec3.add(point, point, center))
-          if (slice2 < qsegments) {
-            point = vec3.subtract(vec3.create(), vec3.scale(p1, cylinderpoint, cospitch), vec3.scale(p2, zvector, sinpitch))
-            points.push(vec3.add(point, point, center))
+          let vertices = []
+          let vertex
+          vertex = vec3.subtract(vec3.create(), vec3.scale(p1, prevCylinderVertex, prevCosPitch), vec3.scale(p2, zVector, prevSinPitch))
+          vertices.push(vec3.add(vertex, vertex, center))
+          vertex = vec3.subtract(vec3.create(), vec3.scale(p1, cylinderVertex, prevCosPitch), vec3.scale(p2, zVector, prevSinPitch))
+          vertices.push(vec3.add(vertex, vertex, center))
+          if (slice2 < qSegments) {
+            vertex = vec3.subtract(vec3.create(), vec3.scale(p1, cylinderVertex, cosPitch), vec3.scale(p2, zVector, sinPitch))
+            vertices.push(vec3.add(vertex, vertex, center))
           }
-          point = vec3.subtract(vec3.create(), vec3.scale(p1, prevcylinderpoint, cospitch), vec3.scale(p2, zvector, sinpitch))
-          points.push(vec3.add(point, point, center))
+          vertex = vec3.subtract(vec3.create(), vec3.scale(p1, prevCylinderVertex, cosPitch), vec3.scale(p2, zVector, sinPitch))
+          vertices.push(vec3.add(vertex, vertex, center))
 
-          polygons.push(poly3.create(points))
+          polygons.push(poly3.create(vertices))
 
-          points = []
-          point = vec3.add(vec3.create(), vec3.scale(p1, prevcylinderpoint, prevcospitch), vec3.scale(p2, zvector, prevsinpitch))
-          points.push(vec3.add(vec3.create(), center, point))
-          point = vec3.add(point, vec3.scale(p1, cylinderpoint, prevcospitch), vec3.scale(p2, zvector, prevsinpitch))
-          points.push(vec3.add(vec3.create(), center, point))
-          if (slice2 < qsegments) {
-            point = vec3.add(point, vec3.scale(p1, cylinderpoint, cospitch), vec3.scale(p2, zvector, sinpitch))
-            points.push(vec3.add(vec3.create(), center, point))
+          vertices = []
+          vertex = vec3.add(vec3.create(), vec3.scale(p1, prevCylinderVertex, prevCosPitch), vec3.scale(p2, zVector, prevSinPitch))
+          vertices.push(vec3.add(vec3.create(), center, vertex))
+          vertex = vec3.add(vertex, vec3.scale(p1, cylinderVertex, prevCosPitch), vec3.scale(p2, zVector, prevSinPitch))
+          vertices.push(vec3.add(vec3.create(), center, vertex))
+          if (slice2 < qSegments) {
+            vertex = vec3.add(vertex, vec3.scale(p1, cylinderVertex, cosPitch), vec3.scale(p2, zVector, sinPitch))
+            vertices.push(vec3.add(vec3.create(), center, vertex))
           }
-          point = vec3.add(point, vec3.scale(p1, prevcylinderpoint, cospitch), vec3.scale(p2, zvector, sinpitch))
-          points.push(vec3.add(vec3.create(), center, point))
-          points.reverse()
+          vertex = vec3.add(vertex, vec3.scale(p1, prevCylinderVertex, cosPitch), vec3.scale(p2, zVector, sinPitch))
+          vertices.push(vec3.add(vec3.create(), center, vertex))
+          vertices.reverse()
 
-          polygons.push(poly3.create(points))
+          polygons.push(poly3.create(vertices))
         }
-        prevcospitch = cospitch
-        prevsinpitch = sinpitch
+        prevCosPitch = cosPitch
+        prevSinPitch = sinPitch
       }
     }
-    prevcylinderpoint = cylinderpoint
+    prevCylinderVertex = cylinderVertex
   }
   return geom3.create(polygons)
 }
-
-module.exports = ellipsoid

package/src/primitives/ellipsoid.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 { ellipsoid } = require('./index')
+import { measureArea, measureVolume } from '../measurements/index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { ellipsoid } from './index.js'
+
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('ellipsoid (defaults)', (t) => {
   const obs = ellipsoid()
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 12.465694088650583)
+  t.is(measureVolume(obs), 4.121941740785839)
   t.is(pts.length, 512)
 })
 
@@ -141,6 +145,8 @@ test('ellipsoid (options)', (t) => {
     [[0, 0, 7], [1.5000000000000004, 0, 6.06217782649107], [1.2990381056766578, 1.2500000000000013, 6.06217782649107]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 291.2703265603712)
+  t.is(measureVolume(obs), 391.86533479473223)
   t.is(pts.length, 72)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -148,6 +154,8 @@ test('ellipsoid (options)', (t) => {
   obs = ellipsoid({ segments: 8 })
   pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 11.013439076647456)
+  t.is(measureVolume(obs), 3.2189514164974597)
   t.is(pts.length, 32)
 
   obs = ellipsoid({ center: [-3, 5, 7], segments: 8 })
@@ -204,6 +212,8 @@ test('ellipsoid (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 11.013439076647467)
+  t.is(measureVolume(obs), 3.218951416497485)
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -212,5 +222,7 @@ test('ellipsoid (zero radius)', (t) => {
   const obs = ellipsoid({ radius: [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)
 })

package/src/primitives/geodesicSphere.d.ts

@@ -1,10 +1,8 @@
-import Geom3 from '../geometries/geom3/type'
-
-export default geodesicSphere
+import type { Geom3 } from '../geometries/geom3/type.d.ts'
 
 export interface GeodesicSphereOptions {
   radius?: number
   frequency?: number
 }
 
-declare function geodesicSphere(options?: GeodesicSphereOptions): Geom3
+export function geodesicSphere(options?: GeodesicSphereOptions): Geom3