@jbroll/jscad-modeling 2.12.7

package/src/primitives/circle.test.js

@@ -0,0 +1,155 @@
+const test = require('ava')
+
+const { TAU } = require('../maths/constants')
+const geom2 = require('../geometries/geom2')
+
+const comparePoints = require('../../test/helpers/comparePoints')
+
+const { circle } = require('./index')
+
+test('circle (defaults)', (t) => {
+  const geometry = circle()
+  const pts = geom2.toPoints(geometry)
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(pts.length, 32)
+})
+
+test('circle (options)', (t) => {
+  // test center
+  let geometry = circle({ radius: 3.5, center: [6.5, 6.5] })
+  let pts = geom2.toPoints(geometry)
+  let exp = [
+    [10, 6.5],
+    [9.932748481411306, 7.182816127056449],
+    [9.733578363789503, 7.8393920132778145],
+    [9.410143643058909, 8.444495815568608],
+    [8.974873734152917, 8.974873734152915],
+    [8.444495815568608, 9.410143643058909],
+    [7.8393920132778145, 9.733578363789503],
+    [7.182816127056449, 9.932748481411306],
+    [6.5, 10],
+    [5.817183872943551, 9.932748481411306],
+    [5.1606079867221855, 9.733578363789503],
+    [4.555504184431394, 9.410143643058909],
+    [4.025126265847084, 8.974873734152917],
+    [3.589856356941091, 8.444495815568608],
+    [3.2664216362104965, 7.8393920132778145],
+    [3.0672515185886935, 7.18281612705645],
+    [3, 6.5],
+    [3.0672515185886935, 5.81718387294355],
+    [3.266421636210496, 5.160607986722186],
+    [3.589856356941091, 4.555504184431394],
+    [4.025126265847083, 4.025126265847084],
+    [4.555504184431392, 3.5898563569410915],
+    [5.160607986722184, 3.266421636210497],
+    [5.817183872943549, 3.067251518588694],
+    [6.5, 3],
+    [7.182816127056449, 3.0672515185886935],
+    [7.8393920132778145, 3.266421636210497],
+    [8.444495815568606, 3.589856356941091],
+    [8.974873734152915, 4.025126265847083],
+    [9.410143643058909, 4.555504184431392],
+    [9.733578363789503, 5.160607986722184],
+    [9.932748481411306, 5.817183872943549]
+  ]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(pts.length, 32)
+  t.true(comparePoints(pts, exp))
+
+  // test radius
+  geometry = circle({ radius: 3.5, segments: 16 })
+  pts = geom2.toPoints(geometry)
+  exp = [
+    [3.5, 0],
+    [3.2335783637895035, 1.3393920132778143],
+    [2.4748737341529163, 2.474873734152916],
+    [1.3393920132778145, 3.2335783637895035],
+    [0, 3.5],
+    [-1.339392013277814, 3.2335783637895035],
+    [-2.474873734152916, 2.4748737341529163],
+    [-3.2335783637895035, 1.3393920132778145],
+    [-3.5, 0],
+    [-3.233578363789504, -1.3393920132778139],
+    [-2.474873734152917, -2.474873734152916],
+    [-1.339392013277816, -3.233578363789503],
+    [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))
+
+  // test startAngle
+  geometry = circle({ radius: 3.5, startAngle: TAU / 4, segments: 16 })
+  pts = geom2.toPoints(geometry)
+  exp = [
+    [0, 3.5],
+    [-1.339392013277814, 3.2335783637895035],
+    [-2.474873734152916, 2.4748737341529163],
+    [-3.2335783637895035, 1.3393920132778145],
+    [-3.5, 0],
+    [-3.233578363789504, -1.3393920132778139],
+    [-2.474873734152917, -2.474873734152916],
+    [-1.339392013277816, -3.233578363789503],
+    [0, -3.5],
+    [1.339392013277815, -3.233578363789503],
+    [2.474873734152916, -2.474873734152917],
+    [3.233578363789503, -1.3393920132778163],
+    [3.5, 0],
+    [0, 0]
+  ]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(pts.length, 14)
+  t.true(comparePoints(pts, exp))
+
+  // test endAngle
+  geometry = circle({ radius: 3.5, endAngle: TAU / 4, segments: 16 })
+  pts = geom2.toPoints(geometry)
+  exp = [
+    [3.5, 0],
+    [3.2335783637895035, 1.3393920132778143],
+    [2.4748737341529163, 2.474873734152916],
+    [1.3393920132778145, 3.2335783637895035],
+    [0, 3.5],
+    [0, 0]
+  ]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(pts.length, 6)
+  t.true(comparePoints(pts, exp))
+
+  // test full rotation with non-zero startAngle
+  geometry = circle({ startAngle: 1, endAngle: 1 + TAU })
+  pts = geom2.toPoints(geometry)
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(pts.length, 32)
+
+  // test segments
+  geometry = circle({ radius: 3.5, segments: 5 })
+  pts = geom2.toPoints(geometry)
+  exp = [
+    [3.5, 0],
+    [1.081559480312316, 3.3286978070330373],
+    [-2.8315594803123156, 2.0572483830236563],
+    [-2.831559480312316, -2.0572483830236554],
+    [1.0815594803123152, -3.3286978070330377]
+  ]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(pts.length, 5)
+  t.true(comparePoints(pts, exp))
+})
+
+test('circle (radius zero)', (t) => {
+  const geometry = circle({ radius: 0 })
+  const pts = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(pts.length, 0)
+})

package/src/primitives/commonChecks.js

@@ -0,0 +1,19 @@
+// verify that the array has the given dimension, and contains Number values
+const isNumberArray = (array, dimension) => {
+  if (Array.isArray(array) && array.length >= dimension) {
+    return array.every((n) => Number.isFinite(n))
+  }
+  return false
+}
+
+// verify that the value is a Number greater than the constant
+const isGT = (value, constant) => (Number.isFinite(value) && value > constant)
+
+// verify that the value is a Number greater than or equal to the constant
+const isGTE = (value, constant) => (Number.isFinite(value) && value >= constant)
+
+module.exports = {
+  isNumberArray,
+  isGT,
+  isGTE
+}

package/src/primitives/cube.d.ts

@@ -0,0 +1,11 @@
+import Vec3 from '../maths/vec3/type'
+import Geom3 from '../geometries/geom3/type'
+
+export default cube
+
+export interface CubeOptions {
+  center?: Vec3
+  size?: number
+}
+
+declare function cube(options?: CubeOptions): Geom3

package/src/primitives/cube.js

@@ -0,0 +1,30 @@
+const cuboid = require('./cuboid')
+
+const { isGTE } = require('./commonChecks')
+
+/**
+ * Construct an axis-aligned solid cube in three dimensional space with six square faces.
+ * @see [cuboid]{@link module:modeling/primitives.cuboid} for more options
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0,0]] - center of cube
+ * @param {Number} [options.size=2] - dimension of cube
+ * @returns {geom3} new 3D geometry
+ * @alias module:modeling/primitives.cube
+ * @example
+ * let myshape = cube({size: 10})
+ */
+const cube = (options) => {
+  const defaults = {
+    center: [0, 0, 0],
+    size: 2
+  }
+  let { center, size } = Object.assign({}, defaults, options)
+
+  if (!isGTE(size, 0)) throw new Error('size must be positive')
+
+  size = [size, size, size]
+
+  return cuboid({ center, size })
+}
+
+module.exports = cube

package/src/primitives/cube.test.js

@@ -0,0 +1,55 @@
+const test = require('ava')
+
+const geom3 = require('../geometries/geom3')
+
+const { cube } = require('./index')
+
+const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+
+test('cube (defaults)', (t) => {
+  const obs = cube()
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 6)
+})
+
+test('cube (options)', (t) => {
+  // test center
+  let obs = cube({ size: 7, center: [6.5, 6.5, 6.5] })
+  let pts = geom3.toPoints(obs)
+  let exp = [
+    [[3, 3, 3], [3, 3, 10], [3, 10, 10], [3, 10, 3]],
+    [[10, 3, 3], [10, 10, 3], [10, 10, 10], [10, 3, 10]],
+    [[3, 3, 3], [10, 3, 3], [10, 3, 10], [3, 3, 10]],
+    [[3, 10, 3], [3, 10, 10], [10, 10, 10], [10, 10, 3]],
+    [[3, 3, 3], [3, 10, 3], [10, 10, 3], [10, 3, 3]],
+    [[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))
+
+  // test size
+  obs = cube({ size: 7 })
+  pts = geom3.toPoints(obs)
+  exp = [
+    [[-3.5, -3.5, -3.5], [-3.5, -3.5, 3.5], [-3.5, 3.5, 3.5], [-3.5, 3.5, -3.5]],
+    [[3.5, -3.5, -3.5], [3.5, 3.5, -3.5], [3.5, 3.5, 3.5], [3.5, -3.5, 3.5]],
+    [[-3.5, -3.5, -3.5], [3.5, -3.5, -3.5], [3.5, -3.5, 3.5], [-3.5, -3.5, 3.5]],
+    [[-3.5, 3.5, -3.5], [-3.5, 3.5, 3.5], [3.5, 3.5, 3.5], [3.5, 3.5, -3.5]],
+    [[-3.5, -3.5, -3.5], [-3.5, 3.5, -3.5], [3.5, 3.5, -3.5], [3.5, -3.5, -3.5]],
+    [[-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))
+})
+
+test('cube (zero size)', (t) => {
+  const obs = cube({ size: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/cuboid.d.ts

@@ -0,0 +1,11 @@
+import Vec3 from '../maths/vec3/type'
+import Geom3 from '../geometries/geom3/type'
+
+export default cuboid
+
+export interface CuboidOptions {
+  center?: Vec3
+  size?: Vec3
+}
+
+declare function cuboid(options?: CuboidOptions): Geom3

package/src/primitives/cuboid.js

@@ -0,0 +1,55 @@
+const geom3 = require('../geometries/geom3')
+const poly3 = require('../geometries/poly3')
+
+const { isNumberArray } = require('./commonChecks')
+
+/**
+ * Construct an axis-aligned solid cuboid in three dimensional space.
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0,0]] - center of cuboid
+ * @param {Array} [options.size=[2,2,2]] - dimensions of cuboid; width, depth, height
+ * @returns {geom3} new 3D geometry
+ * @alias module:modeling/primitives.cuboid
+ *
+ * @example
+ * let myshape = cuboid({size: [5, 10, 5]})
+ */
+const cuboid = (options) => {
+  const defaults = {
+    center: [0, 0, 0],
+    size: [2, 2, 2]
+  }
+  const { center, size } = Object.assign({}, defaults, options)
+
+  if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
+  if (!isNumberArray(size, 3)) throw new Error('size must be an array of width, depth and height values')
+  if (!size.every((n) => n >= 0)) throw new Error('size values must be positive')
+
+  // if any size is zero return empty geometry
+  if (size[0] === 0 || size[1] === 0 || size[2] === 0) return geom3.create()
+
+  const result = geom3.create(
+    // adjust a basic shape to size
+    [
+      [[0, 4, 6, 2], [-1, 0, 0]],
+      [[1, 3, 7, 5], [+1, 0, 0]],
+      [[0, 1, 5, 4], [0, -1, 0]],
+      [[2, 6, 7, 3], [0, +1, 0]],
+      [[0, 2, 3, 1], [0, 0, -1]],
+      [[4, 5, 7, 6], [0, 0, +1]]
+    ].map((info) => {
+      const points = info[0].map((i) => {
+        const pos = [
+          center[0] + (size[0] / 2) * (2 * !!(i & 1) - 1),
+          center[1] + (size[1] / 2) * (2 * !!(i & 2) - 1),
+          center[2] + (size[2] / 2) * (2 * !!(i & 4) - 1)
+        ]
+        return pos
+      })
+      return poly3.create(points)
+    })
+  )
+  return result
+}
+
+module.exports = cuboid

package/src/primitives/cuboid.test.js

@@ -0,0 +1,64 @@
+const test = require('ava')
+
+const geom3 = require('../geometries/geom3')
+
+const { cuboid } = require('./index')
+
+const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+
+test('cuboid (defaults)', (t) => {
+  const obs = cuboid()
+  const pts = geom3.toPoints(obs)
+  const exp = [
+    [[-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))
+})
+
+test('cuboid (options)', (t) => {
+  // test center
+  let obs = cuboid({ size: [6, 6, 6], center: [3, 5, 7] })
+  let pts = geom3.toPoints(obs)
+  let exp = [
+    [[0, 2, 4], [0, 2, 10], [0, 8, 10], [0, 8, 4]],
+    [[6, 2, 4], [6, 8, 4], [6, 8, 10], [6, 2, 10]],
+    [[0, 2, 4], [6, 2, 4], [6, 2, 10], [0, 2, 10]],
+    [[0, 8, 4], [0, 8, 10], [6, 8, 10], [6, 8, 4]],
+    [[0, 2, 4], [0, 8, 4], [6, 8, 4], [6, 2, 4]],
+    [[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))
+
+  // test size
+  obs = cuboid({ size: [4.5, 1.5, 7] })
+  pts = geom3.toPoints(obs)
+  exp = [
+    [[-2.25, -0.75, -3.5], [-2.25, -0.75, 3.5], [-2.25, 0.75, 3.5], [-2.25, 0.75, -3.5]],
+    [[2.25, -0.75, -3.5], [2.25, 0.75, -3.5], [2.25, 0.75, 3.5], [2.25, -0.75, 3.5]],
+    [[-2.25, -0.75, -3.5], [2.25, -0.75, -3.5], [2.25, -0.75, 3.5], [-2.25, -0.75, 3.5]],
+    [[-2.25, 0.75, -3.5], [-2.25, 0.75, 3.5], [2.25, 0.75, 3.5], [2.25, 0.75, -3.5]],
+    [[-2.25, -0.75, -3.5], [-2.25, 0.75, -3.5], [2.25, 0.75, -3.5], [2.25, -0.75, -3.5]],
+    [[-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))
+})
+
+test('cuboid (zero size)', (t) => {
+  const obs = cuboid({ size: [1, 1, 0] })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/cylinder.d.ts

@@ -0,0 +1,13 @@
+import Vec3 from '../maths/vec3/type'
+import Geom3 from '../geometries/geom3/type'
+
+export default cylinder
+
+export interface CylinderOptions {
+  center?: Vec3
+  height?: number
+  radius?: number
+  segments?: number
+}
+
+declare function cylinder(options?: CylinderOptions): Geom3

package/src/primitives/cylinder.js

@@ -0,0 +1,46 @@
+const geom3 = require('../geometries/geom3')
+
+const cylinderElliptic = require('./cylinderElliptic')
+
+const { isGTE } = require('./commonChecks')
+
+/**
+ * Construct a Z axis-aligned cylinder in three dimensional space.
+ * @see [cylinderElliptic]{@link module:modeling/primitives.cylinderElliptic} for more options
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0,0]] - center of cylinder
+ * @param {Number} [options.height=2] - height of cylinder
+ * @param {Number} [options.radius=1] - radius of cylinder (at both start and end)
+ * @param {Number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {geom3} new geometry
+ * @alias module:modeling/primitives.cylinder
+ *
+ * @example
+ * let myshape = cylinder({height: 2, radius: 10})
+ */
+const cylinder = (options) => {
+  const defaults = {
+    center: [0, 0, 0],
+    height: 2,
+    radius: 1,
+    segments: 32
+  }
+  const { center, height, radius, segments } = Object.assign({}, defaults, options)
+
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
+
+  // if size is zero return empty geometry
+  if (height === 0 || radius === 0) return geom3.create()
+
+  const newoptions = {
+    center,
+    height,
+    startRadius: [radius, radius],
+    endRadius: [radius, radius],
+    segments
+  }
+
+  return cylinderElliptic(newoptions)
+}
+
+module.exports = cylinder

package/src/primitives/cylinder.test.js

@@ -0,0 +1,90 @@
+const test = require('ava')
+
+const geom3 = require('../geometries/geom3')
+
+const { cylinder } = require('./index')
+
+const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+
+test('cylinder (defaults)', (t) => {
+  const obs = cylinder()
+  const pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 96)
+})
+
+test('cylinder (zero height)', (t) => {
+  const obs = cylinder({ height: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})
+
+test('cylinder (zero radius)', (t) => {
+  const obs = cylinder({ radius: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})
+
+test('cylinder (options)', (t) => {
+  let obs = cylinder({ height: 10, radius: 4, segments: 5 })
+  let pts = geom3.toPoints(obs)
+  let exp = [
+    [[0, 0, -5], [1.2360679774997898, 3.804226065180614, -5], [4, 0, -5]],
+    [[1.2360679774997898, 3.804226065180614, -5], [1.2360679774997898, 3.804226065180614, 5],
+      [4, 0, 5], [4, 0, -5]],
+    [[0, 0, 5], [4, 0, 5], [1.2360679774997898, 3.804226065180614, 5]],
+    [[0, 0, -5], [-3.2360679774997894, 2.351141009169893, -5], [1.2360679774997898, 3.804226065180614, -5]],
+    [[-3.2360679774997894, 2.351141009169893, -5], [-3.2360679774997894, 2.351141009169893, 5],
+      [1.2360679774997898, 3.804226065180614, 5], [1.2360679774997898, 3.804226065180614, -5]],
+    [[0, 0, 5], [1.2360679774997898, 3.804226065180614, 5], [-3.2360679774997894, 2.351141009169893, 5]],
+    [[0, 0, -5], [-3.23606797749979, -2.351141009169892, -5], [-3.2360679774997894, 2.351141009169893, -5]],
+    [[-3.23606797749979, -2.351141009169892, -5], [-3.23606797749979, -2.351141009169892, 5],
+      [-3.2360679774997894, 2.351141009169893, 5], [-3.2360679774997894, 2.351141009169893, -5]],
+    [[0, 0, 5], [-3.2360679774997894, 2.351141009169893, 5], [-3.23606797749979, -2.351141009169892, 5]],
+    [[0, 0, -5], [1.236067977499789, -3.8042260651806146, -5], [-3.23606797749979, -2.351141009169892, -5]],
+    [[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, 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))
+
+  // test center
+  obs = cylinder({ center: [-5, -5, -5], segments: 5 })
+  pts = geom3.toPoints(obs)
+  exp = [
+    [[-5, -5, -6], [-4.6909830056250525, -4.048943483704846, -6], [-4, -5, -6]],
+    [[-4.6909830056250525, -4.048943483704846, -6], [-4.6909830056250525, -4.048943483704846, -4],
+      [-4, -5, -4], [-4, -5, -6]],
+    [[-5, -5, -4], [-4, -5, -4], [-4.6909830056250525, -4.048943483704846, -4]],
+    [[-5, -5, -6], [-5.8090169943749475, -4.412214747707527, -6], [-4.6909830056250525, -4.048943483704846, -6]],
+    [[-5.8090169943749475, -4.412214747707527, -6], [-5.8090169943749475, -4.412214747707527, -4],
+      [-4.6909830056250525, -4.048943483704846, -4], [-4.6909830056250525, -4.048943483704846, -6]],
+    [[-5, -5, -4], [-4.6909830056250525, -4.048943483704846, -4], [-5.8090169943749475, -4.412214747707527, -4]],
+    [[-5, -5, -6], [-5.8090169943749475, -5.587785252292473, -6], [-5.8090169943749475, -4.412214747707527, -6]],
+    [[-5.8090169943749475, -5.587785252292473, -6], [-5.8090169943749475, -5.587785252292473, -4],
+      [-5.8090169943749475, -4.412214747707527, -4], [-5.8090169943749475, -4.412214747707527, -6]],
+    [[-5, -5, -4], [-5.8090169943749475, -4.412214747707527, -4], [-5.8090169943749475, -5.587785252292473, -4]],
+    [[-5, -5, -6], [-4.6909830056250525, -5.951056516295154, -6], [-5.8090169943749475, -5.587785252292473, -6]],
+    [[-4.6909830056250525, -5.951056516295154, -6], [-4.6909830056250525, -5.951056516295154, -4],
+      [-5.8090169943749475, -5.587785252292473, -4], [-5.8090169943749475, -5.587785252292473, -6]],
+    [[-5, -5, -4], [-5.8090169943749475, -5.587785252292473, -4], [-4.6909830056250525, -5.951056516295154, -4]],
+    [[-5, -5, -6], [-4, -5, -6], [-4.6909830056250525, -5.951056516295154, -6]],
+    [[-4, -5, -6], [-4, -5, -4],
+      [-4.6909830056250525, -5.951056516295154, -4], [-4.6909830056250525, -5.951056516295154, -6]],
+    [[-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.d.ts

@@ -0,0 +1,16 @@
+import Vec3 from '../maths/vec3/type'
+import Geom3 from '../geometries/geom3/type'
+
+export default cylinderElliptic
+
+export interface CylinderEllipticOptions {
+  center?: Vec3
+  height?: number
+  startRadius?: [number, number]
+  startAngle?: number
+  endRadius?: [number, number]
+  endAngle?: number
+  segments?: number
+}
+
+declare function cylinderElliptic(options?: CylinderEllipticOptions): Geom3