@jscad/modeling 2.8.0 → 2.9.2

package/src/primitives/circle.test.js

@@ -10,6 +10,7 @@ test('circle (defaults)', (t) => {
   const geometry = circle()
   const pts = geom2.toPoints(geometry)
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 32)
 })
 
@@ -42,7 +43,7 @@ test('circle (options)', (t) => {
     [4.555504184431392, 3.5898563569410915],
     [5.160607986722184, 3.266421636210497],
     [5.817183872943549, 3.067251518588694],
-    [6.499999999999999, 3],
+    [6.5, 3],
     [7.182816127056449, 3.0672515185886935],
     [7.8393920132778145, 3.266421636210497],
     [8.444495815568606, 3.589856356941091],
@@ -52,6 +53,7 @@ test('circle (options)', (t) => {
     [9.932748481411306, 5.817183872943549]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 32)
   t.true(comparePoints(pts, exp))
 
@@ -63,20 +65,21 @@ test('circle (options)', (t) => {
     [3.2335783637895035, 1.3393920132778143],
     [2.4748737341529163, 2.474873734152916],
     [1.3393920132778145, 3.2335783637895035],
-    [2.143131898507868e-16, 3.5],
+    [0, 3.5],
     [-1.339392013277814, 3.2335783637895035],
     [-2.474873734152916, 2.4748737341529163],
     [-3.2335783637895035, 1.3393920132778145],
-    [-3.5, 4.286263797015736e-16],
+    [-3.5, 0],
     [-3.233578363789504, -1.3393920132778139],
     [-2.474873734152917, -2.474873734152916],
     [-1.339392013277816, -3.233578363789503],
-    [-6.429395695523604e-16, -3.5],
+    [0, -3.5],
     [1.339392013277815, -3.233578363789503],
     [2.474873734152916, -2.474873734152917],
     [3.233578363789503, -1.3393920132778163]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 16)
   t.true(comparePoints(pts, exp))
 
@@ -84,22 +87,23 @@ test('circle (options)', (t) => {
   geometry = circle({ radius: 3.5, startAngle: Math.PI / 2, segments: 16 })
   pts = geom2.toPoints(geometry)
   exp = [
-    [2.143131898507868e-16, 3.5],
+    [0, 3.5],
     [-1.339392013277814, 3.2335783637895035],
     [-2.474873734152916, 2.4748737341529163],
     [-3.2335783637895035, 1.3393920132778145],
-    [-3.5, 4.286263797015736e-16],
+    [-3.5, 0],
     [-3.233578363789504, -1.3393920132778139],
     [-2.474873734152917, -2.474873734152916],
     [-1.339392013277816, -3.233578363789503],
-    [-6.429395695523604e-16, -3.5],
+    [0, -3.5],
     [1.339392013277815, -3.233578363789503],
     [2.474873734152916, -2.474873734152917],
     [3.233578363789503, -1.3393920132778163],
-    [3.5, -8.572527594031472e-16],
+    [3.5, 0],
     [0, 0]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 14)
   t.true(comparePoints(pts, exp))
 
@@ -111,10 +115,11 @@ test('circle (options)', (t) => {
     [3.2335783637895035, 1.3393920132778143],
     [2.4748737341529163, 2.474873734152916],
     [1.3393920132778145, 3.2335783637895035],
-    [2.143131898507868e-16, 3.5],
+    [0, 3.5],
     [0, 0]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 6)
   t.true(comparePoints(pts, exp))
 
@@ -129,6 +134,7 @@ test('circle (options)', (t) => {
     [1.0815594803123152, -3.3286978070330377]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 5)
   t.true(comparePoints(pts, exp))
 })

package/src/primitives/cube.test.js

@@ -9,6 +9,7 @@ const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoi
 test('cube (defaults)', (t) => {
   const obs = cube()
   const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6)
 })
 
@@ -25,6 +26,7 @@ test('cube (options)', (t) => {
     [[3, 3, 10], [10, 3, 10], [10, 10, 10], [3, 10, 10]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -40,6 +42,7 @@ test('cube (options)', (t) => {
     [[-3.5, -3.5, 3.5], [3.5, -3.5, 3.5], [3.5, 3.5, 3.5], [-3.5, 3.5, 3.5]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/primitives/cuboid.test.js

@@ -10,31 +10,14 @@ test('cuboid (defaults)', (t) => {
   const obs = cuboid()
   const pts = geom3.toPoints(obs)
   const exp = [
-    [[-1.0000000, -1.0000000, -1.0000000],
-      [-1.0000000, -1.0000000, 1.0000000],
-      [-1.0000000, 1.0000000, 1.0000000],
-      [-1.0000000, 1.0000000, -1.0000000]],
-    [[1.0000000, -1.0000000, -1.0000000],
-      [1.0000000, 1.0000000, -1.0000000],
-      [1.0000000, 1.0000000, 1.0000000],
-      [1.0000000, -1.0000000, 1.0000000]],
-    [[-1.0000000, -1.0000000, -1.0000000],
-      [1.0000000, -1.0000000, -1.0000000],
-      [1.0000000, -1.0000000, 1.0000000],
-      [-1.0000000, -1.0000000, 1.0000000]],
-    [[-1.0000000, 1.0000000, -1.0000000],
-      [-1.0000000, 1.0000000, 1.0000000],
-      [1.0000000, 1.0000000, 1.0000000],
-      [1.0000000, 1.0000000, -1.0000000]],
-    [[-1.0000000, -1.0000000, -1.0000000],
-      [-1.0000000, 1.0000000, -1.0000000],
-      [1.0000000, 1.0000000, -1.0000000],
-      [1.0000000, -1.0000000, -1.0000000]],
-    [[-1.0000000, -1.0000000, 1.0000000],
-      [1.0000000, -1.0000000, 1.0000000],
-      [1.0000000, 1.0000000, 1.0000000],
-      [-1.0000000, 1.0000000, 1.0000000]]
+    [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
+    [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],
+    [[-1, -1, -1], [1, -1, -1], [1, -1, 1], [-1, -1, 1]],
+    [[-1, 1, -1], [-1, 1, 1], [1, 1, 1], [1, 1, -1]],
+    [[-1, -1, -1], [-1, 1, -1], [1, 1, -1], [1, -1, -1]],
+    [[-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]]
   ]
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -52,6 +35,7 @@ test('cuboid (options)', (t) => {
     [[0, 2, 10], [6, 2, 10], [6, 8, 10], [0, 8, 10]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -67,6 +51,7 @@ test('cuboid (options)', (t) => {
     [[-2.25, -0.75, 3.5], [2.25, -0.75, 3.5], [2.25, 0.75, 3.5], [-2.25, 0.75, 3.5]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/primitives/cylinder.test.js

@@ -10,6 +10,7 @@ test('cylinder (defaults)', (t) => {
   const obs = cylinder()
   const pts = geom3.toPoints(obs)
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 96)
 })
 
@@ -33,12 +34,13 @@ test('cylinder (options)', (t) => {
     [[1.236067977499789, -3.8042260651806146, -5], [1.236067977499789, -3.8042260651806146, 5],
       [-3.23606797749979, -2.351141009169892, 5], [-3.23606797749979, -2.351141009169892, -5]],
     [[0, 0, 5], [-3.23606797749979, -2.351141009169892, 5], [1.236067977499789, -3.8042260651806146, 5]],
-    [[0, 0, -5], [4, -9.797174393178826e-16, -5], [1.236067977499789, -3.8042260651806146, -5]],
-    [[4, -9.797174393178826e-16, -5], [4, -9.797174393178826e-16, 5],
-      [1.236067977499789, -3.8042260651806146, 5], [1.236067977499789, -3.8042260651806146, -5]],
-    [[0, 0, 5], [1.236067977499789, -3.8042260651806146, 5], [4, -9.797174393178826e-16, 5]]
+    [[0, 0, -5], [4, 0, -5], [1.236067977499789, -3.8042260651806146, -5]],
+    [[4, 0, -5], [4, 0, 5], [1.236067977499789, -3.8042260651806146, 5],
+      [1.236067977499789, -3.8042260651806146, -5]],
+    [[0, 0, 5], [1.236067977499789, -3.8042260651806146, 5], [4, 0, 5]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -68,6 +70,7 @@ test('cylinder (options)', (t) => {
     [[-5, -5, -4], [-4.6909830056250525, -5.951056516295154, -4], [-4, -5, -4]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 15)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/primitives/cylinderElliptic.js

@@ -5,6 +5,8 @@ const vec3 = require('../maths/vec3')
 const geom3 = require('../geometries/geom3')
 const poly3 = require('../geometries/poly3')
 
+const { sin, cos } = require('../utils/trigonometry')
+
 const { isGT, isGTE, isNumberArray } = require('./commonChecks')
 
 /**
@@ -38,9 +40,10 @@ const cylinderElliptic = (options) => {
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isGT(height, 0)) throw new Error('height must be greater then zero')
   if (!isNumberArray(startRadius, 2)) throw new Error('startRadius must be an array of X and Y values')
-  if (!startRadius.every((n) => n > 0)) throw new Error('startRadius values must be greater than zero')
+  if (!startRadius.every((n) => n >= 0)) throw new Error('startRadius values must be positive')
   if (!isNumberArray(endRadius, 2)) throw new Error('endRadius must be an array of X and Y values')
-  if (!endRadius.every((n) => n > 0)) throw new Error('endRadius values must be greater than zero')
+  if (!endRadius.every((n) => n >= 0)) throw new Error('endRadius values must be positive')
+  if (endRadius.every((n) => n === 0) && startRadius.every((n) => n === 0)) throw new Error('at least one radius must be positive')
   if (!isGTE(startAngle, 0)) throw new Error('startAngle must be positive')
   if (!isGTE(endAngle, 0)) throw new Error('endAngle must be positive')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
@@ -75,8 +78,8 @@ const cylinderElliptic = (options) => {
   const v3 = vec3.create()
   const point = (stack, slice, radius) => {
     const angle = slice * rotation + startAngle
-    vec3.scale(v1, axisX, radius[0] * Math.cos(angle))
-    vec3.scale(v2, axisY, radius[1] * Math.sin(angle))
+    vec3.scale(v1, axisX, radius[0] * cos(angle))
+    vec3.scale(v2, axisY, radius[1] * sin(angle))
     vec3.add(v1, v1, v2)
 
     vec3.scale(v3, ray, stack)
@@ -100,12 +103,16 @@ const cylinderElliptic = (options) => {
       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)))
     } else {
-      if (startRadius[0] > 0) {
+      if (startRadius[0] > 0 && startRadius[1] > 0) {
         polygons.push(fromPoints(start, point(0, t1, startRadius), point(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)))
       }
-      if (endRadius[0] > 0) {
+      if (endRadius[0] > 0 && endRadius[1] > 0) {
         polygons.push(fromPoints(end, point(1, t0, endRadius), point(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)))
       }
     }

package/src/primitives/cylinderElliptic.test.js

@@ -10,6 +10,7 @@ test('cylinderElliptic (defaults)', (t) => {
   const obs = cylinderElliptic()
   const pts = geom3.toPoints(obs)
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 96)
 })
 
@@ -26,48 +27,49 @@ test('cylinderElliptic (options)', (t) => {
     [[0.5000000000000001, 0.8660254037844386, -5], [0.5000000000000001, 0.8660254037844386, 5],
       [0.8660254037844387, 0.49999999999999994, 5], [0.8660254037844387, 0.49999999999999994, -5]],
     [[0, 0, 5], [0.8660254037844387, 0.49999999999999994, 5], [0.5000000000000001, 0.8660254037844386, 5]],
-    [[0, 0, -5], [6.123233995736766e-17, 1, -5], [0.5000000000000001, 0.8660254037844386, -5]],
-    [[6.123233995736766e-17, 1, -5], [6.123233995736766e-17, 1, 5],
+    [[0, 0, -5], [0, 1, -5], [0.5000000000000001, 0.8660254037844386, -5]],
+    [[0, 1, -5], [0, 1, 5],
       [0.5000000000000001, 0.8660254037844386, 5], [0.5000000000000001, 0.8660254037844386, -5]],
-    [[0, 0, 5], [0.5000000000000001, 0.8660254037844386, 5], [6.123233995736766e-17, 1, 5]],
-    [[0, 0, -5], [-0.4999999999999998, 0.8660254037844387, -5], [6.123233995736766e-17, 1, -5]],
+    [[0, 0, 5], [0.5000000000000001, 0.8660254037844386, 5], [0, 1, 5]],
+    [[0, 0, -5], [-0.4999999999999998, 0.8660254037844387, -5], [0, 1, -5]],
     [[-0.4999999999999998, 0.8660254037844387, -5], [-0.4999999999999998, 0.8660254037844387, 5],
-      [6.123233995736766e-17, 1, 5], [6.123233995736766e-17, 1, -5]],
-    [[0, 0, 5], [6.123233995736766e-17, 1, 5], [-0.4999999999999998, 0.8660254037844387, 5]],
+      [0, 1, 5], [0, 1, -5]],
+    [[0, 0, 5], [0, 1, 5], [-0.4999999999999998, 0.8660254037844387, 5]],
     [[0, 0, -5], [-0.8660254037844387, 0.49999999999999994, -5], [-0.4999999999999998, 0.8660254037844387, -5]],
     [[-0.8660254037844387, 0.49999999999999994, -5], [-0.8660254037844387, 0.49999999999999994, 5],
       [-0.4999999999999998, 0.8660254037844387, 5], [-0.4999999999999998, 0.8660254037844387, -5]],
     [[0, 0, 5], [-0.4999999999999998, 0.8660254037844387, 5], [-0.8660254037844387, 0.49999999999999994, 5]],
-    [[0, 0, -5], [-1, 1.2246467991473532e-16, -5], [-0.8660254037844387, 0.49999999999999994, -5]],
-    [[-1, 1.2246467991473532e-16, -5], [-1, 1.2246467991473532e-16, 5],
+    [[0, 0, -5], [-1, 0, -5], [-0.8660254037844387, 0.49999999999999994, -5]],
+    [[-1, 0, -5], [-1, 0, 5],
       [-0.8660254037844387, 0.49999999999999994, 5], [-0.8660254037844387, 0.49999999999999994, -5]],
-    [[0, 0, 5], [-0.8660254037844387, 0.49999999999999994, 5], [-1, 1.2246467991473532e-16, 5]],
-    [[0, 0, -5], [-0.8660254037844386, -0.5000000000000001, -5], [-1, 1.2246467991473532e-16, -5]],
+    [[0, 0, 5], [-0.8660254037844387, 0.49999999999999994, 5], [-1, 0, 5]],
+    [[0, 0, -5], [-0.8660254037844386, -0.5000000000000001, -5], [-1, 0, -5]],
     [[-0.8660254037844386, -0.5000000000000001, -5], [-0.8660254037844386, -0.5000000000000001, 5],
-      [-1, 1.2246467991473532e-16, 5], [-1, 1.2246467991473532e-16, -5]],
-    [[0, 0, 5], [-1, 1.2246467991473532e-16, 5], [-0.8660254037844386, -0.5000000000000001, 5]],
+      [-1, 0, 5], [-1, 0, -5]],
+    [[0, 0, 5], [-1, 0, 5], [-0.8660254037844386, -0.5000000000000001, 5]],
     [[0, 0, -5], [-0.5000000000000004, -0.8660254037844385, -5], [-0.8660254037844386, -0.5000000000000001, -5]],
     [[-0.5000000000000004, -0.8660254037844385, -5], [-0.5000000000000004, -0.8660254037844385, 5],
       [-0.8660254037844386, -0.5000000000000001, 5], [-0.8660254037844386, -0.5000000000000001, -5]],
     [[0, 0, 5], [-0.8660254037844386, -0.5000000000000001, 5], [-0.5000000000000004, -0.8660254037844385, 5]],
-    [[0, 0, -5], [-1.8369701987210297e-16, -1, -5], [-0.5000000000000004, -0.8660254037844385, -5]],
-    [[-1.8369701987210297e-16, -1, -5], [-1.8369701987210297e-16, -1, 5],
+    [[0, 0, -5], [0, -1, -5], [-0.5000000000000004, -0.8660254037844385, -5]],
+    [[0, -1, -5], [0, -1, 5],
       [-0.5000000000000004, -0.8660254037844385, 5], [-0.5000000000000004, -0.8660254037844385, -5]],
-    [[0, 0, 5], [-0.5000000000000004, -0.8660254037844385, 5], [-1.8369701987210297e-16, -1, 5]],
-    [[0, 0, -5], [0.5000000000000001, -0.8660254037844386, -5], [-1.8369701987210297e-16, -1, -5]],
+    [[0, 0, 5], [-0.5000000000000004, -0.8660254037844385, 5], [0, -1, 5]],
+    [[0, 0, -5], [0.5000000000000001, -0.8660254037844386, -5], [0, -1, -5]],
     [[0.5000000000000001, -0.8660254037844386, -5], [0.5000000000000001, -0.8660254037844386, 5],
-      [-1.8369701987210297e-16, -1, 5], [-1.8369701987210297e-16, -1, -5]],
-    [[0, 0, 5], [-1.8369701987210297e-16, -1, 5], [0.5000000000000001, -0.8660254037844386, 5]],
+      [0, -1, 5], [0, -1, -5]],
+    [[0, 0, 5], [0, -1, 5], [0.5000000000000001, -0.8660254037844386, 5]],
     [[0, 0, -5], [0.8660254037844384, -0.5000000000000004, -5], [0.5000000000000001, -0.8660254037844386, -5]],
     [[0.8660254037844384, -0.5000000000000004, -5], [0.8660254037844384, -0.5000000000000004, 5],
       [0.5000000000000001, -0.8660254037844386, 5], [0.5000000000000001, -0.8660254037844386, -5]],
     [[0, 0, 5], [0.5000000000000001, -0.8660254037844386, 5], [0.8660254037844384, -0.5000000000000004, 5]],
-    [[0, 0, -5], [1, -2.4492935982947064e-16, -5], [0.8660254037844384, -0.5000000000000004, -5]],
-    [[1, -2.4492935982947064e-16, -5], [1, -2.4492935982947064e-16, 5],
-      [0.8660254037844384, -0.5000000000000004, 5], [0.8660254037844384, -0.5000000000000004, -5]],
-    [[0, 0, 5], [0.8660254037844384, -0.5000000000000004, 5], [1, -2.4492935982947064e-16, 5]]
+    [[0, 0, -5], [1, 0, -5], [0.8660254037844384, -0.5000000000000004, -5]],
+    [[1, 0, -5], [1, 0, 5], [0.8660254037844384, -0.5000000000000004, 5],
+      [0.8660254037844384, -0.5000000000000004, -5]],
+    [[0, 0, 5], [0.8660254037844384, -0.5000000000000004, 5], [1, 0, 5]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 36)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -83,48 +85,49 @@ test('cylinderElliptic (options)', (t) => {
     [[0.8660254037844387, 0.9999999999999999, -1], [0.5000000000000001, 1.7320508075688772, -1], [1.7320508075688774, 0.49999999999999994, 1]],
     [[0, 0, 1], [1.7320508075688774, 0.49999999999999994, 1], [1.0000000000000002, 0.8660254037844386, 1]],
     [[1.7320508075688774, 0.49999999999999994, 1], [0.5000000000000001, 1.7320508075688772, -1], [1.0000000000000002, 0.8660254037844386, 1]],
-    [[0, 0, -1], [6.123233995736766e-17, 2, -1], [0.5000000000000001, 1.7320508075688772, -1]],
-    [[0.5000000000000001, 1.7320508075688772, -1], [6.123233995736766e-17, 2, -1], [1.0000000000000002, 0.8660254037844386, 1]],
-    [[0, 0, 1], [1.0000000000000002, 0.8660254037844386, 1], [1.2246467991473532e-16, 1, 1]],
-    [[1.0000000000000002, 0.8660254037844386, 1], [6.123233995736766e-17, 2, -1], [1.2246467991473532e-16, 1, 1]],
-    [[0, 0, -1], [-0.4999999999999998, 1.7320508075688774, -1], [6.123233995736766e-17, 2, -1]],
-    [[6.123233995736766e-17, 2, -1], [-0.4999999999999998, 1.7320508075688774, -1], [1.2246467991473532e-16, 1, 1]],
-    [[0, 0, 1], [1.2246467991473532e-16, 1, 1], [-0.9999999999999996, 0.8660254037844387, 1]],
-    [[1.2246467991473532e-16, 1, 1], [-0.4999999999999998, 1.7320508075688774, -1], [-0.9999999999999996, 0.8660254037844387, 1]],
+    [[0, 0, -1], [0, 2, -1], [0.5000000000000001, 1.7320508075688772, -1]],
+    [[0.5000000000000001, 1.7320508075688772, -1], [0, 2, -1], [1.0000000000000002, 0.8660254037844386, 1]],
+    [[0, 0, 1], [1.0000000000000002, 0.8660254037844386, 1], [0, 1, 1]],
+    [[1.0000000000000002, 0.8660254037844386, 1], [0, 2, -1], [0, 1, 1]],
+    [[0, 0, -1], [-0.4999999999999998, 1.7320508075688774, -1], [0, 2, -1]],
+    [[0, 2, -1], [-0.4999999999999998, 1.7320508075688774, -1], [0, 1, 1]],
+    [[0, 0, 1], [0, 1, 1], [-0.9999999999999996, 0.8660254037844387, 1]],
+    [[0, 1, 1], [-0.4999999999999998, 1.7320508075688774, -1], [-0.9999999999999996, 0.8660254037844387, 1]],
     [[0, 0, -1], [-0.8660254037844387, 0.9999999999999999, -1], [-0.4999999999999998, 1.7320508075688774, -1]],
     [[-0.4999999999999998, 1.7320508075688774, -1], [-0.8660254037844387, 0.9999999999999999, -1], [-0.9999999999999996, 0.8660254037844387, 1]],
     [[0, 0, 1], [-0.9999999999999996, 0.8660254037844387, 1], [-1.7320508075688774, 0.49999999999999994, 1]],
     [[-0.9999999999999996, 0.8660254037844387, 1], [-0.8660254037844387, 0.9999999999999999, -1], [-1.7320508075688774, 0.49999999999999994, 1]],
-    [[0, 0, -1], [-1, 2.4492935982947064e-16, -1], [-0.8660254037844387, 0.9999999999999999, -1]],
-    [[-0.8660254037844387, 0.9999999999999999, -1], [-1, 2.4492935982947064e-16, -1], [-1.7320508075688774, 0.49999999999999994, 1]],
-    [[0, 0, 1], [-1.7320508075688774, 0.49999999999999994, 1], [-2, 1.2246467991473532e-16, 1]],
-    [[-1.7320508075688774, 0.49999999999999994, 1], [-1, 2.4492935982947064e-16, -1], [-2, 1.2246467991473532e-16, 1]],
-    [[0, 0, -1], [-0.8660254037844386, -1.0000000000000002, -1], [-1, 2.4492935982947064e-16, -1]],
-    [[-1, 2.4492935982947064e-16, -1], [-0.8660254037844386, -1.0000000000000002, -1], [-2, 1.2246467991473532e-16, 1]],
-    [[0, 0, 1], [-2, 1.2246467991473532e-16, 1], [-1.7320508075688772, -0.5000000000000001, 1]],
-    [[-2, 1.2246467991473532e-16, 1], [-0.8660254037844386, -1.0000000000000002, -1], [-1.7320508075688772, -0.5000000000000001, 1]],
+    [[0, 0, -1], [-1, 0, -1], [-0.8660254037844387, 0.9999999999999999, -1]],
+    [[-0.8660254037844387, 0.9999999999999999, -1], [-1, 0, -1], [-1.7320508075688774, 0.49999999999999994, 1]],
+    [[0, 0, 1], [-1.7320508075688774, 0.49999999999999994, 1], [-2, 0, 1]],
+    [[-1.7320508075688774, 0.49999999999999994, 1], [-1, 0, -1], [-2, 0, 1]],
+    [[0, 0, -1], [-0.8660254037844386, -1.0000000000000002, -1], [-1, 0, -1]],
+    [[-1, 0, -1], [-0.8660254037844386, -1.0000000000000002, -1], [-2, 0, 1]],
+    [[0, 0, 1], [-2, 0, 1], [-1.7320508075688772, -0.5000000000000001, 1]],
+    [[-2, 0, 1], [-0.8660254037844386, -1.0000000000000002, -1], [-1.7320508075688772, -0.5000000000000001, 1]],
     [[0, 0, -1], [-0.5000000000000004, -1.732050807568877, -1], [-0.8660254037844386, -1.0000000000000002, -1]],
     [[-0.8660254037844386, -1.0000000000000002, -1], [-0.5000000000000004, -1.732050807568877, -1], [-1.7320508075688772, -0.5000000000000001, 1]],
     [[0, 0, 1], [-1.7320508075688772, -0.5000000000000001, 1], [-1.0000000000000009, -0.8660254037844385, 1]],
     [[-1.7320508075688772, -0.5000000000000001, 1], [-0.5000000000000004, -1.732050807568877, -1], [-1.0000000000000009, -0.8660254037844385, 1]],
-    [[0, 0, -1], [-1.8369701987210297e-16, -2, -1], [-0.5000000000000004, -1.732050807568877, -1]],
-    [[-0.5000000000000004, -1.732050807568877, -1], [-1.8369701987210297e-16, -2, -1], [-1.0000000000000009, -0.8660254037844385, 1]],
-    [[0, 0, 1], [-1.0000000000000009, -0.8660254037844385, 1], [-3.6739403974420594e-16, -1, 1]],
-    [[-1.0000000000000009, -0.8660254037844385, 1], [-1.8369701987210297e-16, -2, -1], [-3.6739403974420594e-16, -1, 1]],
-    [[0, 0, -1], [0.5000000000000001, -1.7320508075688772, -1], [-1.8369701987210297e-16, -2, -1]],
-    [[-1.8369701987210297e-16, -2, -1], [0.5000000000000001, -1.7320508075688772, -1], [-3.6739403974420594e-16, -1, 1]],
-    [[0, 0, 1], [-3.6739403974420594e-16, -1, 1], [1.0000000000000002, -0.8660254037844386, 1]],
-    [[-3.6739403974420594e-16, -1, 1], [0.5000000000000001, -1.7320508075688772, -1], [1.0000000000000002, -0.8660254037844386, 1]],
+    [[0, 0, -1], [0, -2, -1], [-0.5000000000000004, -1.732050807568877, -1]],
+    [[-0.5000000000000004, -1.732050807568877, -1], [0, -2, -1], [-1.0000000000000009, -0.8660254037844385, 1]],
+    [[0, 0, 1], [-1.0000000000000009, -0.8660254037844385, 1], [0, -1, 1]],
+    [[-1.0000000000000009, -0.8660254037844385, 1], [0, -2, -1], [0, -1, 1]],
+    [[0, 0, -1], [0.5000000000000001, -1.7320508075688772, -1], [0, -2, -1]],
+    [[0, -2, -1], [0.5000000000000001, -1.7320508075688772, -1], [0, -1, 1]],
+    [[0, 0, 1], [0, -1, 1], [1.0000000000000002, -0.8660254037844386, 1]],
+    [[0, -1, 1], [0.5000000000000001, -1.7320508075688772, -1], [1.0000000000000002, -0.8660254037844386, 1]],
     [[0, 0, -1], [0.8660254037844384, -1.0000000000000009, -1], [0.5000000000000001, -1.7320508075688772, -1]],
     [[0.5000000000000001, -1.7320508075688772, -1], [0.8660254037844384, -1.0000000000000009, -1], [1.0000000000000002, -0.8660254037844386, 1]],
     [[0, 0, 1], [1.0000000000000002, -0.8660254037844386, 1], [1.7320508075688767, -0.5000000000000004, 1]],
     [[1.0000000000000002, -0.8660254037844386, 1], [0.8660254037844384, -1.0000000000000009, -1], [1.7320508075688767, -0.5000000000000004, 1]],
-    [[0, 0, -1], [1, -4.898587196589413e-16, -1], [0.8660254037844384, -1.0000000000000009, -1]],
-    [[0.8660254037844384, -1.0000000000000009, -1], [1, -4.898587196589413e-16, -1], [1.7320508075688767, -0.5000000000000004, 1]],
-    [[0, 0, 1], [1.7320508075688767, -0.5000000000000004, 1], [2, -2.4492935982947064e-16, 1]],
-    [[1.7320508075688767, -0.5000000000000004, 1], [1, -4.898587196589413e-16, -1], [2, -2.4492935982947064e-16, 1]]
+    [[0, 0, -1], [1, 0, -1], [0.8660254037844384, -1.0000000000000009, -1]],
+    [[0.8660254037844384, -1.0000000000000009, -1], [1, 0, -1], [1.7320508075688767, -0.5000000000000004, 1]],
+    [[0, 0, 1], [1.7320508075688767, -0.5000000000000004, 1], [2, 0, 1]],
+    [[1.7320508075688767, -0.5000000000000004, 1], [1, 0, -1], [2, 0, 1]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 48)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -132,6 +135,7 @@ test('cylinderElliptic (options)', (t) => {
   obs = cylinderElliptic({ startRadius: [1, 2], endRadius: [2, 1], startAngle: Math.PI / 2, endAngle: Math.PI * 2 * 0.75, segments: 12 })
   pts = geom3.toPoints(obs)
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 28)
   // t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -139,6 +143,7 @@ test('cylinderElliptic (options)', (t) => {
   obs = cylinderElliptic({ segments: 8 })
   pts = geom3.toPoints(obs)
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 24)
 
   // test center
@@ -179,6 +184,23 @@ test('cylinderElliptic (options)', (t) => {
     [[-5, -5, -3.5], [-4.292893218813453, -5.707106781186548, -3.5], [-4, -5, -3.5]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 24)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
+
+test('cylinderElliptic (cone)', (t) => {
+  const obs = cylinderElliptic({ endRadius: [0, 0] })
+  const pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 64)
+})
+
+test('cylinderElliptic (squished)', (t) => {
+  const obs = cylinderElliptic({ startRadius: [1, 0], endRadius: [0, 1], segments: 4 })
+  const pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 8)
+})

package/src/primitives/ellipse.js

@@ -4,6 +4,8 @@ const vec2 = require('../maths/vec2')
 
 const geom2 = require('../geometries/geom2')
 
+const { sin, cos } = require('../utils/trigonometry')
+
 const { isGTE, isNumberArray } = require('./commonChecks')
 
 /**
@@ -62,7 +64,7 @@ const ellipse = (options) => {
   segments = (rotation < Math.PI * 2) ? segments + 1 : segments
   for (let i = 0; i < segments; i++) {
     const angle = (step * i) + startAngle
-    const point = vec2.fromValues(radius[0] * Math.cos(angle), radius[1] * Math.sin(angle))
+    const point = vec2.fromValues(radius[0] * cos(angle), radius[1] * sin(angle))
     vec2.add(point, centerv, point)
     points.push(point)
   }

package/src/primitives/ellipse.test.js

@@ -10,6 +10,7 @@ test('ellipse (defaults)', (t) => {
   const geometry = ellipse()
   const obs = geom2.toPoints(geometry)
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(obs.length, 32)
 })
 
@@ -52,6 +53,7 @@ test('ellipse (options)', (t) => {
     [3.9807852804032304, 4.804909677983871]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(obs.length, 32)
   t.true(comparePoints(obs, exp))
 
@@ -63,20 +65,21 @@ test('ellipse (options)', (t) => {
     [2.77163859753386, 1.913417161825449],
     [2.121320343559643, 3.5355339059327373],
     [1.1480502970952695, 4.619397662556434],
-    [1.8369701987210297e-16, 5],
+    [0, 5],
     [-1.1480502970952693, 4.619397662556434],
     [-2.1213203435596424, 3.5355339059327378],
     [-2.77163859753386, 1.9134171618254494],
-    [-3, 6.123233995736766e-16],
+    [-3, 0],
     [-2.7716385975338604, -1.9134171618254483],
     [-2.121320343559643, -3.5355339059327373],
     [-1.148050297095271, -4.619397662556432],
-    [-5.51091059616309e-16, -5],
+    [0, -5],
     [1.14805029709527, -4.619397662556433],
     [2.121320343559642, -3.5355339059327386],
     [2.7716385975338595, -1.913417161825452]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(obs.length, 16)
   t.true(comparePoints(obs, exp))
 
@@ -84,22 +87,23 @@ test('ellipse (options)', (t) => {
   geometry = ellipse({ radius: [3, 5], startAngle: Math.PI / 2, segments: 16 })
   obs = geom2.toPoints(geometry)
   exp = [
-    [1.8369701987210297e-16, 5],
+    [0, 5],
     [-1.1480502970952693, 4.619397662556434],
     [-2.1213203435596424, 3.5355339059327378],
     [-2.77163859753386, 1.9134171618254494],
-    [-3, 6.123233995736766e-16],
+    [-3, 0],
     [-2.7716385975338604, -1.9134171618254483],
     [-2.121320343559643, -3.5355339059327373],
     [-1.148050297095271, -4.619397662556432],
-    [-5.51091059616309e-16, -5],
+    [0, -5],
     [1.14805029709527, -4.619397662556433],
     [2.121320343559642, -3.5355339059327386],
     [2.7716385975338595, -1.913417161825452],
-    [3, -1.2246467991473533e-15],
+    [3, 0],
     [0, 0]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(obs.length, 14)
   t.true(comparePoints(obs, exp))
 
@@ -111,15 +115,17 @@ test('ellipse (options)', (t) => {
     [2.77163859753386, 1.913417161825449],
     [2.121320343559643, 3.5355339059327373],
     [1.1480502970952695, 4.619397662556434],
-    [1.8369701987210297e-16, 5],
+    [0, 5],
     [0, 0]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
   // test segments
   geometry = ellipse({ segments: 72 })
   obs = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(obs.length, 72)
 })

package/src/primitives/ellipsoid.js

@@ -3,6 +3,8 @@ const vec3 = require('../maths/vec3')
 const geom3 = require('../geometries/geom3')
 const poly3 = require('../geometries/poly3')
 
+const { sin, cos } = require('../utils/trigonometry')
+
 const { isGTE, isNumberArray } = require('./commonChecks')
 
 /**
@@ -42,14 +44,14 @@ const ellipsoid = (options) => {
   const p1 = vec3.create()
   const p2 = vec3.create()
   for (let slice1 = 0; slice1 <= segments; slice1++) {
-    const angle = Math.PI * 2.0 * slice1 / segments
-    const cylinderpoint = vec3.add(vec3.create(), vec3.scale(p1, xvector, Math.cos(angle)), vec3.scale(p2, yvector, Math.sin(angle)))
+    const angle = 2 * Math.PI * slice1 / segments
+    const cylinderpoint = 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 = 0.5 * Math.PI * slice2 / qsegments
-        const cospitch = Math.cos(pitch)
-        const sinpitch = Math.sin(pitch)
+        const cospitch = cos(pitch)
+        const sinpitch = sin(pitch)
         if (slice2 > 0) {
           let points = []
           let point