@jbroll/jscad-modeling 2.12.7

package/src/primitives/cylinderElliptic.js

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

package/src/primitives/cylinderElliptic.test.js

@@ -0,0 +1,213 @@
+const test = require('ava')
+
+const { TAU } = require('../maths/constants')
+const geom3 = require('../geometries/geom3')
+
+const { cylinderElliptic } = require('./index')
+
+const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+
+test('cylinderElliptic (defaults)', (t) => {
+  const obs = cylinderElliptic()
+  const pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 96)
+})
+
+test('cylinderElliptic (options)', (t) => {
+  // test height
+  let obs = cylinderElliptic({ height: 10, segments: 12 })
+  let pts = geom3.toPoints(obs)
+  let exp = [
+    [[0, 0, -5], [0.8660254037844387, 0.49999999999999994, -5], [1, 0, -5]],
+    [[0.8660254037844387, 0.49999999999999994, -5], [0.8660254037844387, 0.49999999999999994, 5],
+      [1, 0, 5], [1, 0, -5]],
+    [[0, 0, 5], [1, 0, 5], [0.8660254037844387, 0.49999999999999994, 5]],
+    [[0, 0, -5], [0.5000000000000001, 0.8660254037844386, -5], [0.8660254037844387, 0.49999999999999994, -5]],
+    [[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], [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], [0, 1, 5]],
+    [[0, 0, -5], [-0.4999999999999998, 0.8660254037844387, -5], [0, 1, -5]],
+    [[-0.4999999999999998, 0.8660254037844387, -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, 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, 0, 5]],
+    [[0, 0, -5], [-0.8660254037844386, -0.5000000000000001, -5], [-1, 0, -5]],
+    [[-0.8660254037844386, -0.5000000000000001, -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], [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], [0, -1, 5]],
+    [[0, 0, -5], [0.5000000000000001, -0.8660254037844386, -5], [0, -1, -5]],
+    [[0.5000000000000001, -0.8660254037844386, -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, 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))
+
+  // test startRadius and endRadius
+  obs = cylinderElliptic({ startRadius: [1, 2], endRadius: [2, 1], segments: 12 })
+  pts = geom3.toPoints(obs)
+  exp = [
+    [[0, 0, -1], [0.8660254037844387, 0.9999999999999999, -1], [1, 0, -1]],
+    [[1, 0, -1], [0.8660254037844387, 0.9999999999999999, -1], [2, 0, 1]],
+    [[0, 0, 1], [2, 0, 1], [1.7320508075688774, 0.49999999999999994, 1]],
+    [[2, 0, 1], [0.8660254037844387, 0.9999999999999999, -1], [1.7320508075688774, 0.49999999999999994, 1]],
+    [[0, 0, -1], [0.5000000000000001, 1.7320508075688772, -1], [0.8660254037844387, 0.9999999999999999, -1]],
+    [[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], [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, 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], [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, 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))
+
+  // test startAngle and endAngle
+  obs = cylinderElliptic({ startRadius: [1, 2], endRadius: [2, 1], startAngle: TAU / 4, endAngle: TAU * 0.75, segments: 12 })
+  pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 28)
+
+  // test startAngle and endAngle
+  obs = cylinderElliptic({ startAngle: 1, endAngle: 1 + TAU })
+  pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 96)
+
+  // test segments
+  obs = cylinderElliptic({ segments: 8 })
+  pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 24)
+
+  // test center
+  obs = cylinderElliptic({ center: [-5, -5, -5], height: 3, segments: 8 })
+  pts = geom3.toPoints(obs)
+  exp = [
+    [[-5, -5, -6.5], [-4.292893218813452, -4.292893218813452, -6.5], [-4, -5, -6.5]],
+    [[-4.292893218813452, -4.292893218813452, -6.5], [-4.292893218813452, -4.292893218813452, -3.5],
+      [-4, -5, -3.5], [-4, -5, -6.5]],
+    [[-5, -5, -3.5], [-4, -5, -3.5], [-4.292893218813452, -4.292893218813452, -3.5]],
+    [[-5, -5, -6.5], [-5, -4, -6.5], [-4.292893218813452, -4.292893218813452, -6.5]],
+    [[-5, -4, -6.5], [-5, -4, -3.5],
+      [-4.292893218813452, -4.292893218813452, -3.5], [-4.292893218813452, -4.292893218813452, -6.5]],
+    [[-5, -5, -3.5], [-4.292893218813452, -4.292893218813452, -3.5], [-5, -4, -3.5]],
+    [[-5, -5, -6.5], [-5.707106781186548, -4.292893218813452, -6.5], [-5, -4, -6.5]],
+    [[-5.707106781186548, -4.292893218813452, -6.5], [-5.707106781186548, -4.292893218813452, -3.5],
+      [-5, -4, -3.5], [-5, -4, -6.5]],
+    [[-5, -5, -3.5], [-5, -4, -3.5], [-5.707106781186548, -4.292893218813452, -3.5]],
+    [[-5, -5, -6.5], [-6, -5, -6.5], [-5.707106781186548, -4.292893218813452, -6.5]],
+    [[-6, -5, -6.5], [-6, -5, -3.5],
+      [-5.707106781186548, -4.292893218813452, -3.5], [-5.707106781186548, -4.292893218813452, -6.5]],
+    [[-5, -5, -3.5], [-5.707106781186548, -4.292893218813452, -3.5], [-6, -5, -3.5]],
+    [[-5, -5, -6.5], [-5.707106781186548, -5.707106781186548, -6.5], [-6, -5, -6.5]],
+    [[-5.707106781186548, -5.707106781186548, -6.5], [-5.707106781186548, -5.707106781186548, -3.5],
+      [-6, -5, -3.5], [-6, -5, -6.5]],
+    [[-5, -5, -3.5], [-6, -5, -3.5], [-5.707106781186548, -5.707106781186548, -3.5]],
+    [[-5, -5, -6.5], [-5, -6, -6.5], [-5.707106781186548, -5.707106781186548, -6.5]],
+    [[-5, -6, -6.5], [-5, -6, -3.5],
+      [-5.707106781186548, -5.707106781186548, -3.5], [-5.707106781186548, -5.707106781186548, -6.5]],
+    [[-5, -5, -3.5], [-5.707106781186548, -5.707106781186548, -3.5], [-5, -6, -3.5]],
+    [[-5, -5, -6.5], [-4.292893218813453, -5.707106781186548, -6.5], [-5, -6, -6.5]],
+    [[-4.292893218813453, -5.707106781186548, -6.5], [-4.292893218813453, -5.707106781186548, -3.5],
+      [-5, -6, -3.5], [-5, -6, -6.5]],
+    [[-5, -5, -3.5], [-5, -6, -3.5], [-4.292893218813453, -5.707106781186548, -3.5]],
+    [[-5, -5, -6.5], [-4, -5, -6.5], [-4.292893218813453, -5.707106781186548, -6.5]],
+    [[-4, -5, -6.5], [-4, -5, -3.5],
+      [-4.292893218813453, -5.707106781186548, -3.5], [-4.292893218813453, -5.707106781186548, -6.5]],
+    [[-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.d.ts

@@ -0,0 +1,14 @@
+import Vec2 from '../maths/vec2/type'
+import Geom2 from '../geometries/geom2/type'
+
+export default ellipse
+
+export interface EllipseOptions {
+  center?: Vec2
+  radius?: Vec2
+  startAngle?: number
+  endAngle?: number
+  segments?: number
+}
+
+declare function ellipse(options?: EllipseOptions): Geom2

package/src/primitives/ellipse.js

@@ -0,0 +1,78 @@
+const { EPS, TAU } = require('../maths/constants')
+
+const vec2 = require('../maths/vec2')
+
+const geom2 = require('../geometries/geom2')
+
+const { sin, cos } = require('../maths/utils/trigonometry')
+
+const { isGTE, isNumberArray } = require('./commonChecks')
+
+/**
+ * Construct an axis-aligned ellipse in two dimensional space.
+ * @see https://en.wikipedia.org/wiki/Ellipse
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0]] - center of ellipse
+ * @param {Array} [options.radius=[1,1]] - radius of ellipse, along X and Y
+ * @param {Number} [options.startAngle=0] - start angle of ellipse, in radians
+ * @param {Number} [options.endAngle=TAU] - end angle of ellipse, in radians
+ * @param {Number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {geom2} new 2D geometry
+ * @alias module:modeling/primitives.ellipse
+ * @example
+ * let myshape = ellipse({radius: [5,10]})
+ */
+const ellipse = (options) => {
+  const defaults = {
+    center: [0, 0],
+    radius: [1, 1],
+    startAngle: 0,
+    endAngle: TAU,
+    segments: 32
+  }
+  let { center, radius, startAngle, endAngle, segments } = Object.assign({}, defaults, options)
+
+  if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
+  if (!isNumberArray(radius, 2)) throw new Error('radius must be an array of X and Y values')
+  if (!radius.every((n) => n >= 0)) throw new Error('radius values 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, 3)) throw new Error('segments must be three or more')
+
+  // if any radius is zero return empty geometry
+  if (radius[0] === 0 || radius[1] === 0) return geom2.create()
+
+  startAngle = startAngle % TAU
+  endAngle = endAngle % TAU
+
+  let rotation = TAU
+  if (startAngle < endAngle) {
+    rotation = endAngle - startAngle
+  }
+  if (startAngle > endAngle) {
+    rotation = endAngle + (TAU - startAngle)
+  }
+
+  const minradius = Math.min(radius[0], radius[1])
+  const minangle = Math.acos(((minradius * minradius) + (minradius * minradius) - (EPS * EPS)) /
+                            (2 * minradius * minradius))
+  if (rotation < minangle) throw new Error('startAngle and endAngle do not define a significant rotation')
+
+  segments = Math.floor(segments * (rotation / TAU))
+
+  const centerv = vec2.clone(center)
+  const step = rotation / segments // radians per segment
+
+  const points = []
+  segments = (rotation < TAU) ? segments + 1 : segments
+  for (let i = 0; i < segments; i++) {
+    const angle = (step * i) + startAngle
+    const point = vec2.fromValues(radius[0] * cos(angle), radius[1] * sin(angle))
+    vec2.add(point, centerv, point)
+    points.push(point)
+  }
+  if (rotation < TAU) points.push(centerv)
+  return geom2.fromPoints(points)
+}
+
+module.exports = ellipse

package/src/primitives/ellipse.test.js

@@ -0,0 +1,146 @@
+const test = require('ava')
+
+const { TAU } = require('../maths/constants')
+const geom2 = require('../geometries/geom2')
+
+const comparePoints = require('../../test/helpers/comparePoints')
+
+const { ellipse } = require('./index')
+
+test('ellipse (defaults)', (t) => {
+  const geometry = ellipse()
+  const obs = geom2.toPoints(geometry)
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 32)
+})
+
+test('ellipse (options)', (t) => {
+  // test center
+  let geometry = ellipse({ center: [3, 5] })
+  let obs = geom2.toPoints(geometry)
+  let exp = [
+    [4, 5],
+    [3.9807852804032304, 5.195090322016128],
+    [3.923879532511287, 5.38268343236509],
+    [3.8314696123025453, 5.555570233019602],
+    [3.7071067811865475, 5.707106781186548],
+    [3.555570233019602, 5.831469612302545],
+    [3.3826834323650896, 5.923879532511287],
+    [3.1950903220161284, 5.98078528040323],
+    [3, 6],
+    [2.804909677983872, 5.98078528040323],
+    [2.6173165676349104, 5.923879532511287],
+    [2.444429766980398, 5.831469612302545],
+    [2.2928932188134525, 5.707106781186548],
+    [2.1685303876974547, 5.555570233019602],
+    [2.076120467488713, 5.38268343236509],
+    [2.0192147195967696, 5.195090322016129],
+    [2, 5],
+    [2.0192147195967696, 4.804909677983872],
+    [2.076120467488713, 4.61731656763491],
+    [2.1685303876974547, 4.444429766980398],
+    [2.292893218813452, 4.292893218813452],
+    [2.444429766980398, 4.168530387697455],
+    [2.6173165676349095, 4.076120467488714],
+    [2.804909677983871, 4.01921471959677],
+    [3, 4],
+    [3.1950903220161284, 4.01921471959677],
+    [3.38268343236509, 4.076120467488713],
+    [3.5555702330196017, 4.168530387697454],
+    [3.7071067811865475, 4.292893218813452],
+    [3.8314696123025453, 4.444429766980398],
+    [3.9238795325112865, 4.6173165676349095],
+    [3.9807852804032304, 4.804909677983871]
+  ]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 32)
+  t.true(comparePoints(obs, exp))
+
+  // test radius
+  geometry = ellipse({ radius: [3, 5], segments: 16 })
+  obs = geom2.toPoints(geometry)
+  exp = [
+    [3, 0],
+    [2.77163859753386, 1.913417161825449],
+    [2.121320343559643, 3.5355339059327373],
+    [1.1480502970952695, 4.619397662556434],
+    [0, 5],
+    [-1.1480502970952693, 4.619397662556434],
+    [-2.1213203435596424, 3.5355339059327378],
+    [-2.77163859753386, 1.9134171618254494],
+    [-3, 0],
+    [-2.7716385975338604, -1.9134171618254483],
+    [-2.121320343559643, -3.5355339059327373],
+    [-1.148050297095271, -4.619397662556432],
+    [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))
+
+  // test startAngle
+  geometry = ellipse({ radius: [3, 5], startAngle: TAU / 4, segments: 16 })
+  obs = geom2.toPoints(geometry)
+  exp = [
+    [0, 5],
+    [-1.1480502970952693, 4.619397662556434],
+    [-2.1213203435596424, 3.5355339059327378],
+    [-2.77163859753386, 1.9134171618254494],
+    [-3, 0],
+    [-2.7716385975338604, -1.9134171618254483],
+    [-2.121320343559643, -3.5355339059327373],
+    [-1.148050297095271, -4.619397662556432],
+    [0, -5],
+    [1.14805029709527, -4.619397662556433],
+    [2.121320343559642, -3.5355339059327386],
+    [2.7716385975338595, -1.913417161825452],
+    [3, 0],
+    [0, 0]
+  ]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 14)
+  t.true(comparePoints(obs, exp))
+
+  // test endAngle
+  geometry = ellipse({ radius: [3, 5], endAngle: TAU / 4, segments: 16 })
+  obs = geom2.toPoints(geometry)
+  exp = [
+    [3, 0],
+    [2.77163859753386, 1.913417161825449],
+    [2.121320343559643, 3.5355339059327373],
+    [1.1480502970952695, 4.619397662556434],
+    [0, 5],
+    [0, 0]
+  ]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 6)
+  t.true(comparePoints(obs, exp))
+
+  // test full rotation with non-zero startAngle
+  geometry = ellipse({ startAngle: 1, endAngle: 1 + TAU })
+  obs = geom2.toPoints(geometry)
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 32)
+
+  // test segments
+  geometry = ellipse({ segments: 72 })
+  obs = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(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(obs.length, 0)
+})

package/src/primitives/ellipsoid.d.ts

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