@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/primitives/roundedRectangle.js

@@ -1,26 +1,27 @@
-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 { isGTE, isNumberArray } = require('./commonChecks')
-const rectangle = require('./rectangle')
+import { isGTE, isNumberArray } from './commonChecks.js'
+
+import { rectangle } from './rectangle.js'
 
 /**
  * Construct an axis-aligned rectangle in two dimensional space with rounded corners.
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of rounded rectangle
  * @param {Array} [options.size=[2,2]] - dimension of rounded rectangle; width and length
- * @param {Number} [options.roundRadius=0.2] - round radius of corners
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
- * @returns {geom2} new 2D geometry
+ * @param {number} [options.roundRadius=0.2] - round radius of corners
+ * @param {number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.roundedRectangle
  *
  * @example
  * let myshape = roundedRectangle({size: [10, 20], roundRadius: 2})
  */
-const roundedRectangle = (options) => {
+export const roundedRectangle = (options) => {
   const defaults = {
     center: [0, 0],
     size: [2, 2],
@@ -46,7 +47,7 @@ const roundedRectangle = (options) => {
   if (roundRadius > (size[0] - EPS) ||
       roundRadius > (size[1] - EPS)) throw new Error('roundRadius must be smaller than the radius of all dimensions')
 
-  const cornersegments = Math.floor(segments / 4)
+  const cornerSegments = Math.floor(segments / 4)
 
   // create sets of points that define the corners
   const corner0 = vec2.add(vec2.create(), center, [size[0] - roundRadius, size[1] - roundRadius])
@@ -57,8 +58,8 @@ const roundedRectangle = (options) => {
   const corner1Points = []
   const corner2Points = []
   const corner3Points = []
-  for (let i = 0; i <= cornersegments; i++) {
-    const radians = TAU / 4 * i / cornersegments
+  for (let i = 0; i <= cornerSegments; i++) {
+    const radians = TAU / 4 * i / cornerSegments
     const point = vec2.fromAngleRadians(vec2.create(), radians)
     vec2.scale(point, point, roundRadius)
     corner0Points.push(vec2.add(vec2.create(), corner0, point))
@@ -70,7 +71,6 @@ const roundedRectangle = (options) => {
     corner3Points.push(vec2.add(vec2.create(), corner3, point))
   }
 
-  return geom2.fromPoints(corner0Points.concat(corner1Points, corner2Points, corner3Points))
+  const points = corner0Points.concat(corner1Points, corner2Points, corner3Points)
+  return geom2.create([points])
 }
-
-module.exports = roundedRectangle

package/src/primitives/roundedRectangle.test.js

@@ -1,23 +1,27 @@
-const test = require('ava')
+import test from 'ava'
 
-const { roundedRectangle } = 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 { roundedRectangle } from './index.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('roundedRectangle (defaults)', (t) => {
   const geometry = roundedRectangle()
   const obs = geom2.toPoints(geometry)
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 36)
+  t.is(measureArea(geometry), 3.964857806090323)
+  t.is(obs.length, 36)
 })
 
 test('roundedRectangle (zero size)', (t) => {
   const obs = roundedRectangle({ size: [1, 0] })
   const pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 0)
   t.is(pts.length, 0)
 })
 
@@ -25,7 +29,8 @@ test('roundedRectangle (zero radius)', (t) => {
   const obs = roundedRectangle({ roundRadius: 0 })
   const pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
-  t.deepEqual(pts.length, 4)
+  t.is(measureArea(obs), 4)
+  t.is(pts.length, 4)
 })
 
 test('roundedRectangle (options)', (t) => {
@@ -55,7 +60,8 @@ test('roundedRectangle (options)', (t) => {
     [5, 4.2]
   ]
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 20)
+  t.is(measureArea(geometry), 3.962458698356829)
+  t.is(obs.length, 20)
   t.true(comparePoints(obs, exp))
 
   // test size
@@ -84,7 +90,8 @@ test('roundedRectangle (options)', (t) => {
     [5, -2.8]
   ]
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 20)
+  t.is(measureArea(geometry), 59.96245869835682)
+  t.is(obs.length, 20)
   t.true(comparePoints(obs, exp))
 
   // test roundRadius
@@ -113,12 +120,14 @@ test('roundedRectangle (options)', (t) => {
     [5, -1.0000000000000004]
   ]
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 20)
+  t.is(measureArea(geometry), 56.24586983568288)
+  t.is(obs.length, 20)
   t.true(comparePoints(obs, exp))
 
   // test segments
   geometry = roundedRectangle({ size: [10, 6], roundRadius: 2, segments: 64 })
   obs = geom2.toPoints(geometry)
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 68)
+  t.is(measureArea(geometry), 56.546193962183764)
+  t.is(obs.length, 68)
 })

package/src/primitives/sphere.d.ts

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

package/src/primitives/sphere.js

@@ -1,22 +1,21 @@
-const ellipsoid = require('./ellipsoid')
-
-const { isGTE } = require('./commonChecks')
+import { ellipsoid } from './ellipsoid.js'
+import { isGTE } from './commonChecks.js'
 
 /**
- * Construct a sphere in three dimensional space where all points are at the same distance from the center.
+ * Construct a sphere in three dimensional space where all vertices are at the same distance from the center.
  * @see [ellipsoid]{@link module:modeling/primitives.ellipsoid} for more options
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of sphere
- * @param {Number} [options.radius=1] - radius of sphere
- * @param {Number} [options.segments=32] - number of segments to create per full rotation
+ * @param {number} [options.radius=1] - radius of sphere
+ * @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.sphere
  *
  * @example
  * let myshape = sphere({radius: 5})
  */
-const sphere = (options) => {
+export const sphere = (options) => {
   const defaults = {
     center: [0, 0, 0],
     radius: 1,
@@ -31,5 +30,3 @@ const sphere = (options) => {
 
   return ellipsoid({ center, radius, segments, axes })
 }
-
-module.exports = sphere

package/src/primitives/sphere.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 { sphere } = require('./index')
+import { measureArea, measureVolume } from '../measurements/index.js'
 
-const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+import { sphere } from './index.js'
+
+import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('sphere (defaults)', (t) => {
   const obs = sphere()
   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)
 })
 
@@ -20,6 +24,8 @@ test('sphere (options)', (t) => {
   let pts = geom3.toPoints(obs)
   let exp = []
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 296.5322084069296)
+  t.is(measureVolume(obs), 466.5063509461097)
   t.is(pts.length, 72)
   // t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -103,6 +109,8 @@ test('sphere (options)', (t) => {
       [0.4999999999999999, 0.5000000000000001, 0.7071067811865475]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 11.013439076647456)
+  t.is(measureVolume(obs), 3.2189514164974597)
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -160,6 +168,8 @@ test('sphere (options)', (t) => {
     [[-3, 5, 8], [-2.2928932188134525, 5, 7.707106781186548], [-2.5, 5.5, 7.707106781186548]]
   ]
   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))
 })
@@ -168,5 +178,7 @@ test('sphere (zero radius)', (t) => {
   const obs = sphere({ radius: 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/square.d.ts

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

package/src/primitives/square.js

@@ -1,20 +1,19 @@
-const rectangle = require('./rectangle')
-
-const { isGTE } = require('./commonChecks')
+import { rectangle } from './rectangle.js'
+import { isGTE } from './commonChecks.js'
 
 /**
  * Construct an axis-aligned square in two dimensional space with four equal sides at right angles.
  * @see [rectangle]{@link module:modeling/primitives.rectangle} for more options
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of square
- * @param {Number} [options.size=2] - dimension of square
- * @returns {geom2} new 2D geometry
+ * @param {number} [options.size=2] - dimension of square
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.square
  *
  * @example
  * let myshape = square({size: 10})
  */
-const square = (options) => {
+export const square = (options) => {
   const defaults = {
     center: [0, 0],
     size: 2
@@ -27,5 +26,3 @@ const square = (options) => {
 
   return rectangle({ center, size })
 }
-
-module.exports = square

package/src/primitives/square.test.js

@@ -1,16 +1,19 @@
-const test = require('ava')
+import test from 'ava'
 
-const { square } = 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 { square } from './index.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('square (defaults)', (t) => {
   const geometry = square()
-  const obs = geom2.toPoints(geometry)
+  const pts = geom2.toPoints(geometry)
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(obs.length, 4)
+  t.is(measureArea(geometry), 4)
+  t.is(pts.length, 4)
 })
 
 test('square (options)', (t) => {
@@ -25,6 +28,7 @@ test('square (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 49)
   t.is(pts.length, 4)
   t.true(comparePoints(pts, exp))
 
@@ -39,13 +43,15 @@ test('square (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 49)
   t.is(pts.length, 4)
   t.true(comparePoints(pts, exp))
 })
 
 test('square (zero size)', (t) => {
   const geometry = square({ size: 0 })
-  const obs = geom2.toPoints(geometry)
+  const pts = geom2.toPoints(geometry)
   t.notThrows(() => geom2.validate(geometry))
-  t.is(obs.length, 0)
+  t.is(measureArea(geometry), 0)
+  t.is(pts.length, 0)
 })

package/src/primitives/star.d.ts

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

package/src/primitives/star.js

@@ -1,9 +1,9 @@
-const { TAU } = require('../maths/constants')
-const vec2 = require('../maths/vec2')
+import { TAU } from '../maths/constants.js'
+import * as vec2 from '../maths/vec2/index.js'
 
-const geom2 = require('../geometries/geom2')
+import * as geom2 from '../geometries/geom2/index.js'
 
-const { isGT, isGTE, isNumberArray } = require('./commonChecks')
+import { isGT, isGTE, isNumberArray } from './commonChecks.js'
 
 // @see http://www.jdawiseman.com/papers/easymath/surds_star_inner_radius.html
 const getRadiusRatio = (vertices, density) => {
@@ -29,21 +29,21 @@ const getPoints = (vertices, radius, startAngle, center) => {
 /**
  * Construct a star in two dimensional space.
  * @see https://en.wikipedia.org/wiki/Star_polygon
- * @param {Object} [options] - options for construction
+ * @param {object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of star
- * @param {Number} [options.vertices=5] - number of vertices (P) on the star
- * @param {Number} [options.density=2] - density (Q) of star
- * @param {Number} [options.outerRadius=1] - outer radius of vertices
- * @param {Number} [options.innerRadius=0] - inner radius of vertices, or zero to calculate
- * @param {Number} [options.startAngle=0] - starting angle for first vertice, in radians
- * @returns {geom2} new 2D geometry
+ * @param {number} [options.vertices=5] - number of vertices (P) on the star
+ * @param {number} [options.density=2] - density (Q) of star
+ * @param {number} [options.outerRadius=1] - outer radius of vertices
+ * @param {number} [options.innerRadius=0] - inner radius of vertices, or zero to calculate
+ * @param {number} [options.startAngle=0] - starting angle for first vertex, in radians
+ * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.star
  *
  * @example
  * let star1 = star({vertices: 8, outerRadius: 10}) // star with 8/2 density
  * let star2 = star({vertices: 12, outerRadius: 40, innerRadius: 20}) // star with given radius
  */
-const star = (options) => {
+export const star = (options) => {
   const defaults = {
     center: [0, 0],
     vertices: 5,
@@ -71,10 +71,10 @@ const star = (options) => {
     innerRadius = outerRadius * getRadiusRatio(vertices, density)
   }
 
-  const centerv = vec2.clone(center)
+  const centerV = vec2.clone(center)
 
-  const outerPoints = getPoints(vertices, outerRadius, startAngle, centerv)
-  const innerPoints = getPoints(vertices, innerRadius, startAngle + Math.PI / vertices, centerv)
+  const outerPoints = getPoints(vertices, outerRadius, startAngle, centerV)
+  const innerPoints = getPoints(vertices, innerRadius, startAngle + Math.PI / vertices, centerV)
 
   const allPoints = []
   for (let i = 0; i < vertices; i++) {
@@ -82,7 +82,5 @@ const star = (options) => {
     allPoints.push(innerPoints[i])
   }
 
-  return geom2.fromPoints(allPoints)
+  return geom2.create([allPoints])
 }
-
-module.exports = star

package/src/primitives/star.test.js

@@ -1,10 +1,12 @@
-const test = require('ava')
+import test from 'ava'
 
-const { star } = 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 { star } from './index.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('star (defaults)', (t) => {
   const geometry = star()
@@ -23,7 +25,8 @@ test('star (defaults)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 10)
+  t.is(measureArea(geometry), 1.1225699414489634)
+  t.is(pts.length, 10)
   t.true(comparePoints(pts, exp))
 })
 
@@ -45,7 +48,8 @@ test('star (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 10)
+  t.is(measureArea(geometry), 28.06424853622408)
+  t.is(pts.length, 10)
   t.true(comparePoints(pts, exp))
 
   // test vertices
@@ -71,7 +75,8 @@ test('star (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 16)
+  t.is(measureArea(geometry), 58.5786437626905)
+  t.is(pts.length, 16)
   t.true(comparePoints(pts, exp))
 
   // test density
@@ -97,7 +102,8 @@ test('star (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 16)
+  t.is(measureArea(geometry), 41.42135623730952)
+  t.is(pts.length, 16)
   t.true(comparePoints(pts, exp))
 
   // test innerRadius
@@ -123,7 +129,8 @@ test('star (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 16)
+  t.is(measureArea(geometry), 15.30733729460359)
+  t.is(pts.length, 16)
   t.true(comparePoints(pts, exp))
 
   // test start angle
@@ -143,6 +150,7 @@ test('star (options)', (t) => {
   ]
 
   t.notThrows(() => geom2.validate(geometry))
-  t.deepEqual(pts.length, 10)
+  t.is(measureArea(geometry), 28.06424853622409)
+  t.is(pts.length, 10)
   t.true(comparePoints(pts, exp))
 })

package/src/primitives/torus.d.ts

@@ -1,6 +1,4 @@
-import Geom3 from '../geometries/geom3/type'
-
-export default torus
+import type { Geom3 } from '../geometries/geom3/type.d.ts'
 
 export interface TorusOptions {
   innerRadius?: number
@@ -12,4 +10,4 @@ export interface TorusOptions {
   startAngle?: number
 }
 
-declare function torus(options?: TorusOptions): Geom3
+export function torus(options?: TorusOptions): Geom3

package/src/primitives/torus.js

@@ -1,30 +1,30 @@
-const { TAU } = require('../maths/constants')
+import { TAU } from '../maths/constants.js'
 
-const extrudeRotate = require('../operations/extrusions/extrudeRotate')
-const { rotate } = require('../operations/transforms/rotate')
-const { translate } = require('../operations/transforms/translate')
+import { extrudeRotate } from '../operations/extrusions/extrudeRotate.js'
+import { rotate } from '../operations/transforms/rotate.js'
+import { translate } from '../operations/transforms/translate.js'
 
-const circle = require('./circle')
+import { circle } from './circle.js'
 
-const { isGT, isGTE } = require('./commonChecks')
+import { isGT, isGTE } from './commonChecks.js'
 
 /**
  * Construct a torus by revolving a small circle (inner) about the circumference of a large (outer) circle.
- * @param {Object} [options] - options for construction
- * @param {Number} [options.innerRadius=1] - radius of small (inner) circle
- * @param {Number} [options.outerRadius=4] - radius of large (outer) circle
- * @param {Integer} [options.innerSegments=32] - number of segments to create per rotation
- * @param {Integer} [options.outerSegments=32] - number of segments to create per rotation
- * @param {Integer} [options.innerRotation=0] - rotation of small (inner) circle in radians
- * @param {Number} [options.outerRotation=TAU] - rotation (outer) of the torus (RADIANS)
- * @param {Number} [options.startAngle=0] - start angle of the torus (RADIANS)
- * @returns {geom3} new 3D geometry
+ * @param {object} [options] - options for construction
+ * @param {number} [options.innerRadius=1] - radius of small (inner) circle
+ * @param {number} [options.outerRadius=4] - radius of large (outer) circle
+ * @param {number} [options.innerSegments=32] - number of segments to create per rotation
+ * @param {number} [options.outerSegments=32] - number of segments to create per rotation
+ * @param {number} [options.innerRotation=0] - rotation of small (inner) circle in radians
+ * @param {number} [options.outerRotation=TAU] - rotation (outer) of the torus (RADIANS)
+ * @param {number} [options.startAngle=0] - start angle of the torus (RADIANS)
+ * @returns {Geom3} new 3D geometry
  * @alias module:modeling/primitives.torus
  *
  * @example
  * let myshape = torus({ innerRadius: 10, outerRadius: 100 })
  */
-const torus = (options) => {
+export const torus = (options) => {
   const defaults = {
     innerRadius: 1,
     innerSegments: 32,
@@ -60,5 +60,3 @@ const torus = (options) => {
   }
   return extrudeRotate(extrudeOptions, innerCircle)
 }
-
-module.exports = torus

package/src/primitives/torus.test.js

@@ -1,18 +1,22 @@
-const test = require('ava')
+import test from 'ava'
 
-const geom3 = require('../geometries/geom3')
-const measureBoundingBox = require('../measurements/measureBoundingBox')
-const { TAU } = require('../maths/constants')
+import { TAU } from '../maths/constants.js'
 
-const comparePoints = require('../../test/helpers/comparePoints')
+import { geom3 } from '../geometries/index.js'
 
-const { torus } = require('./index')
+import { measureArea, measureBoundingBox, measureVolume } from '../measurements/index.js'
+
+import { torus } from './index.js'
+
+import { comparePoints } from '../../test/helpers/index.js'
 
 test('torus (defaults)', (t) => {
   const obs = torus()
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 157.0282327749074)
+  t.is(measureVolume(obs), 77.94735870844194)
   t.is(pts.length, 2048) // 32 * 32 * 2 (polys/segment) = 2048
 
   const bounds = measureBoundingBox(obs)
@@ -24,6 +28,8 @@ test('torus (simple options)', (t) => {
   const obs = torus({ innerRadius: 0.5, innerSegments: 4, outerRadius: 5, outerSegments: 8 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 83.36086132479792)
+  t.is(measureVolume(obs), 14.14213562373095)
   t.is(pts.length, 64) // 4 * 8 * 2 (polys/segment) = 64
 
   const bounds = measureBoundingBox(obs)
@@ -35,6 +41,8 @@ test('torus (complex options)', (t) => {
   const obs = torus({ innerRadius: 1, outerRadius: 5, innerSegments: 32, outerSegments: 72, startAngle: TAU / 4, outerRotation: TAU / 4 })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 55.472610544494)
+  t.is(measureVolume(obs), 24.484668362201525)
   t.is(pts.length, 1212)
 
   const bounds = measureBoundingBox(obs)
@@ -46,6 +54,8 @@ test('torus (startAngle)', (t) => {
   const obs = torus({ startAngle: 1, endAngle: 1 + TAU })
   const pts = geom3.toPoints(obs)
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 157.0282327749074)
+  t.is(measureVolume(obs), 77.94735870844195)
   t.is(pts.length, 2048)
 })
 
@@ -55,5 +65,7 @@ test('torus (square by square)', (t) => {
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-5, -5, -1], [5, 5, 1]]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 110.85125168440814)
+  t.is(measureVolume(obs), 32)
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected: ' + JSON.stringify(bounds))
 })