@jscad/modeling 3.0.0-alpha.0 → 3.0.2-alpha.0

package/src/primitives/cylinder.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../geometries/index.js'
 
+import { measureArea, measureVolume } from '../measurements/index.js'
+
 import { cylinder } from './index.js'
 
 import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
@@ -11,6 +13,8 @@ test('cylinder (defaults)', (t) => {
   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)
 })
 
@@ -18,6 +22,8 @@ test('cylinder (zero height)', (t) => {
   const obs = cylinder({ 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('cylinder (zero radius)', (t) => {
   const obs = cylinder({ 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)
 })
 
@@ -55,6 +63,8 @@ test('cylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 311.1986222206015)
+  t.is(measureVolume(obs), 380.4226065180614)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -85,6 +95,8 @@ test('cylinder (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 16.51098762732523)
+  t.is(measureVolume(obs), 4.755282581475773)
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/primitives/cylinderElliptic.test.js

@@ -1,8 +1,10 @@
 import test from 'ava'
 
+import { geom3 } from '../geometries/index.js'
+
 import { TAU } from '../maths/constants.js'
 
-import { geom3 } from '../geometries/index.js'
+import { measureArea, measureVolume } from '../measurements/index.js'
 
 import { cylinderElliptic } from './index.js'
 
@@ -13,6 +15,8 @@ test('cylinderElliptic (defaults)', (t) => {
   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)
 })
 
@@ -72,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))
 
@@ -130,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))
 
@@ -138,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
@@ -145,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
@@ -152,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
@@ -193,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))
 })
@@ -202,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)
 })
 
@@ -210,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.test.js

@@ -1,8 +1,10 @@
 import test from 'ava'
 
+import { geom2 } from '../geometries/index.js'
+
 import { TAU } from '../maths/constants.js'
 
-import { geom2 } from '../geometries/index.js'
+import { measureArea } from '../measurements/index.js'
 
 import { comparePoints } from '../../test/helpers/index.js'
 
@@ -13,7 +15,8 @@ test('ellipse (defaults)', (t) => {
   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) => {
@@ -56,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
@@ -82,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
@@ -106,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
@@ -122,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
@@ -130,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.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../geometries/index.js'
 
+import { measureArea, measureVolume } from '../measurements/index.js'
+
 import { ellipsoid } from './index.js'
 
 import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
@@ -11,6 +13,8 @@ test('ellipsoid (defaults)', (t) => {
   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.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../geometries/index.js'
 
+import { measureArea, measureVolume } from '../measurements/index.js'
+
 import { geodesicSphere } from './index.js'
 
 import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
@@ -41,6 +43,8 @@ test('geodesicSphere (options)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 239.3635345818432)
+  t.is(measureVolume(obs), 317.0188387650327)
   t.is(pts.length, 20)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -49,6 +53,8 @@ test('geodesicSphere (options)', (t) => {
   pts = geom3.toPoints(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
+  t.is(measureArea(obs), 303.76605423529395)
+  t.is(measureVolume(obs), 492.6739732379337)
   t.is(pts.length, 180)
 })
 
@@ -56,5 +62,7 @@ test('geodesicSphere (zero radius)', (t) => {
   const obs = geodesicSphere({ 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/line.test.js

@@ -12,6 +12,6 @@ test('line (defaults)', (t) => {
   const obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
-  t.deepEqual(obs.length, 3)
+  t.is(obs.length, 3)
   t.true(comparePoints(obs, exp))
 })

package/src/primitives/polygon.d.ts

@@ -4,6 +4,7 @@ import type { Geom2 } from '../geometries/geom2/type.d.ts'
 export interface PolygonOptions {
   points: Array<Vec2> | Array<Array<Vec2>>
   paths?: Array<number> | Array<Array<number>>
+  orientation?: 'counterclockwise' | 'clockwise'
 }
 
 export function polygon(options: PolygonOptions): Geom2

package/src/primitives/polygon.js

@@ -2,10 +2,13 @@ import * as geom2 from '../geometries/geom2/index.js'
 
 /**
  * Construct a polygon in two dimensional space from a list of points, or a list of points and paths.
- * NOTE: The ordering of points is VERY IMPORTANT.
+ *
+ * NOTE: The ordering of points is important, and must define a counter clockwise rotation of points.
+ *
  * @param {object} options - options for construction
  * @param {Array} options.points - points of the polygon : either flat or nested array of 2D points
  * @param {Array} [options.paths] - paths of the polygon : either flat or nested array of point indexes
+ * @param {String} [options.orientation='counterclockwise'] - orientation of points
  * @returns {Geom2} new 2D geometry
  * @alias module:modeling/primitives.polygon
  *
@@ -24,9 +27,10 @@ import * as geom2 from '../geometries/geom2/index.js'
 export const polygon = (options) => {
   const defaults = {
     points: [],
-    paths: []
+    paths: [],
+    orientation: 'counterclockwise'
   }
-  const { points, paths } = Object.assign({}, defaults, options)
+  const { points, paths, orientation } = Object.assign({}, defaults, options)
 
   if (!(Array.isArray(points) && Array.isArray(paths))) throw new Error('points and paths must be arrays')
 
@@ -63,5 +67,10 @@ export const polygon = (options) => {
     const setOfPoints = path.map((index) => allPoints[index])
     outlines.push(setOfPoints)
   })
-  return geom2.create(outlines)
+
+  let geometry = geom2.create(outlines)
+  if (orientation === 'clockwise') {
+    geometry = geom2.reverse(geometry)
+  }
+  return geometry
 }

package/src/primitives/polygon.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom2 } from '../geometries/index.js'
 
+import { measureArea } from '../measurements/index.js'
+
 import { polygon } from './index.js'
 
 import { comparePoints } from '../../test/helpers/index.js'
@@ -13,6 +15,7 @@ test('polygon: providing only object.points creates expected geometry', (t) => {
   let exp = [[0, 0], [100, 0], [130, 50], [30, 50]]
 
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), 5000)
   t.true(comparePoints(obs, exp))
 
   geometry = polygon({ points: [[[0, 0], [100, 0], [0, 100]], [[10, 10], [80, 10], [10, 80]]] })
@@ -21,6 +24,7 @@ test('polygon: providing only object.points creates expected geometry', (t) => {
   exp = [[0, 0], [100, 0], [0, 100], [10, 10], [80, 10], [10, 80]]
 
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), 7450)
   t.true(comparePoints(obs, exp))
 })
 
@@ -31,6 +35,7 @@ test('polygon: providing object.points (array) and object.path (array) creates e
   let exp = [[30, 50], [130, 50], [100, 0], [0, 0]]
 
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), -5000)
   t.true(comparePoints(obs, exp))
 
   // multiple paths
@@ -40,6 +45,7 @@ test('polygon: providing object.points (array) and object.path (array) creates e
   exp = [[0, 0], [100, 0], [0, 100], [10, 10], [80, 10], [10, 80]]
 
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), 7450)
   t.true(comparePoints(obs, exp))
 
   // multiple points and paths
@@ -49,5 +55,14 @@ test('polygon: providing object.points (array) and object.path (array) creates e
   exp = [[0, 0], [100, 0], [0, 100], [10, 10], [80, 10], [10, 80]]
 
   t.notThrows(() => geom2.validate(geometry))
+  t.is(measureArea(geometry), 7450)
   t.true(comparePoints(obs, exp))
 })
+
+test('polygon: clockwise points', (t) => {
+  const poly = polygon({
+    points: [[-10, -0], [-10, -10], [-15, -5]],
+    orientation: 'clockwise'
+  })
+  t.is(measureArea(poly), 25)
+})

package/src/primitives/polyhedron.js

@@ -5,6 +5,7 @@ import { isNumberArray } from './commonChecks.js'
 
 /**
  * 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 counterclockwise rotation of vertices which follows the right hand rule.
  * @param {object} options - options for construction

package/src/primitives/polyhedron.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../geometries/index.js'
 
+import { measureArea, measureVolume } from '../measurements/index.js'
+
 import { polyhedron } from './index.js'
 
 import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
@@ -22,7 +24,9 @@ test('polyhedron (points and faces)', (t) => {
     [[-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]]
   ]
   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)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // test orientation
@@ -39,6 +43,8 @@ test('polyhedron (points and faces)', (t) => {
     [[-10, 10, 0], [10, -10, 0], [-10, -10, 0]]
   ]
   t.notThrows(() => geom3.validate(obs))
-  t.deepEqual(pts.length, 6)
+  t.is(measureArea(obs), 965.6854249492379)
+  t.is(measureVolume(obs), 1333.3333333333333)
+  t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/primitives/rectangle.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom2 } from '../geometries/index.js'
 
+import { measureArea } from '../measurements/index.js'
+
 import { rectangle } from './index.js'
 
 import { comparePoints } from '../../test/helpers/index.js'
@@ -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.js

@@ -151,7 +151,7 @@ export const roundedCuboid = (options) => {
 
   if (roundRadius > (size[0] - EPS) ||
       roundRadius > (size[1] - EPS) ||
-      roundRadius > (size[2] - EPS)) throw new Error('roundRadius must be smaller then the radius of all dimensions')
+      roundRadius > (size[2] - EPS)) throw new Error('roundRadius must be smaller than the radius of all dimensions')
 
   segments = Math.floor(segments / 4)
 

package/src/primitives/roundedCuboid.test.js

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../geometries/index.js'
 
+import { measureArea, measureVolume } from '../measurements/index.js'
+
 import { roundedCuboid } from './index.js'
 
 import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
@@ -11,13 +13,17 @@ test('roundedCuboid (defaults)', (t) => {
   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.js

@@ -38,7 +38,7 @@ export const roundedCylinder = (options) => {
   if (!isGTE(height, 0)) throw new Error('height must be positive')
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
   if (!isGTE(roundRadius, 0)) throw new Error('roundRadius must be positive')
-  if (roundRadius > radius) throw new Error('roundRadius must be smaller then the radius')
+  if (roundRadius > radius) throw new Error('roundRadius must be smaller than the radius')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
   // if size is zero return empty geometry