@jbroll/jscad-modeling 2.12.7

package/src/operations/transforms/translate.js

@@ -0,0 +1,72 @@
+const flatten = require('../../utils/flatten')
+
+const mat4 = require('../../maths/mat4')
+
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const path2 = require('../../geometries/path2')
+
+/**
+ * Translate the given objects using the given options.
+ * @param {Array} offset - offset (vector) of which to translate the objects
+ * @param {...Object} objects - the objects to translate
+ * @return {Object|Array} the translated object, or a list of translated objects
+ * @alias module:modeling/transforms.translate
+ *
+ * @example
+ * const newsphere = translate([5, 0, 10], sphere())
+ */
+const translate = (offset, ...objects) => {
+  if (!Array.isArray(offset)) throw new Error('offset must be an array')
+
+  objects = flatten(objects)
+  if (objects.length === 0) throw new Error('wrong number of arguments')
+
+  // adjust the offset if necessary
+  offset = offset.slice() // don't modify the original
+  while (offset.length < 3) offset.push(0)
+
+  const matrix = mat4.fromTranslation(mat4.create(), offset)
+
+  const results = objects.map((object) => {
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (geom3.isA(object)) return geom3.transform(matrix, object)
+    return object
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+/**
+ * Translate the given objects along the X axis using the given options.
+ * @param {Number} offset - X offset of which to translate the objects
+ * @param {...Object} objects - the objects to translate
+ * @return {Object|Array} the translated object, or a list of translated objects
+ * @alias module:modeling/transforms.translateX
+ */
+const translateX = (offset, ...objects) => translate([offset, 0, 0], objects)
+
+/**
+ * Translate the given objects along the Y axis using the given options.
+ * @param {Number} offset - Y offset of which to translate the geometries
+ * @param {...Object} objects - the objects to translate
+ * @return {Object|Array} the translated object, or a list of translated objects
+ * @alias module:modeling/transforms.translateY
+ */
+const translateY = (offset, ...objects) => translate([0, offset, 0], objects)
+
+/**
+ * Translate the given objects along the Z axis using the given options.
+ * @param {Number} offset - Z offset of which to translate the geometries
+ * @param {...Object} objects - the objects to translate
+ * @return {Object|Array} the translated object, or a list of translated objects
+ * @alias module:modeling/transforms.translateZ
+ */
+const translateZ = (offset, ...objects) => translate([0, 0, offset], objects)
+
+module.exports = {
+  translate,
+  translateX,
+  translateY,
+  translateZ
+}

package/src/operations/transforms/translate.test.js

@@ -0,0 +1,151 @@
+const test = require('ava')
+
+const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+
+const { geom2, geom3, path2 } = require('../../geometries')
+
+const { translate, translateX, translateY, translateZ } = require('./index')
+
+test('translate: translating of a path2 produces expected changes to points', (t) => {
+  const line = path2.fromPoints({}, [[0, 0], [1, 0]])
+
+  // translate X
+  let translated = translate([1], line)
+  let obs = path2.toPoints(translated)
+  let exp = [[1, 0], [2, 0]]
+  t.notThrows(() => path2.validate(translated))
+  t.true(comparePoints(obs, exp))
+
+  translated = translateX(1, line)
+  obs = path2.toPoints(translated)
+  t.notThrows(() => path2.validate(translated))
+  t.true(comparePoints(obs, exp))
+
+  // translate Y
+  translated = translate([0, 1], line)
+  obs = path2.toPoints(translated)
+  exp = [[0, 1], [1, 1]]
+  t.notThrows(() => path2.validate(translated))
+  t.true(comparePoints(obs, exp))
+
+  translated = translateY(1, line)
+  obs = path2.toPoints(translated)
+  t.notThrows(() => path2.validate(translated))
+  t.true(comparePoints(obs, exp))
+})
+
+test('translate: translating of a geom2 produces expected changes to points', (t) => {
+  const geometry = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+
+  // translate X
+  let translated = translate([1], geometry)
+  let obs = geom2.toPoints(translated)
+  let exp = [[1, 0], [2, 0], [1, 1]]
+  t.notThrows(() => geom2.validate(translated))
+  t.true(comparePoints(obs, exp))
+
+  translated = translateX(1, geometry)
+  obs = geom2.toPoints(translated)
+  t.notThrows(() => geom2.validate(translated))
+  t.true(comparePoints(obs, exp))
+
+  // translate Y
+  translated = translate([0, 1], geometry)
+  obs = geom2.toPoints(translated)
+  exp = [[0, 1], [1, 1], [0, 2]]
+  t.notThrows(() => geom2.validate(translated))
+  t.true(comparePoints(obs, exp))
+
+  translated = translateY(1, geometry)
+  obs = geom2.toPoints(translated)
+  t.notThrows(() => geom2.validate(translated))
+  t.true(comparePoints(obs, exp))
+})
+
+test('translate: translating of a geom3 produces expected changes to polygons', (t) => {
+  const points = [
+    [[-2, -7, -12], [-2, -7, 18], [-2, 13, 18], [-2, 13, -12]],
+    [[8, -7, -12], [8, 13, -12], [8, 13, 18], [8, -7, 18]],
+    [[-2, -7, -12], [8, -7, -12], [8, -7, 18], [-2, -7, 18]],
+    [[-2, 13, -12], [-2, 13, 18], [8, 13, 18], [8, 13, -12]],
+    [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
+    [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
+  ]
+  const geometry = geom3.fromPoints(points)
+
+  // translate X
+  let translated = translate([3], geometry)
+  let obs = geom3.toPoints(translated)
+  let exp = [
+    [[1, -7, -12], [1, -7, 18], [1, 13, 18], [1, 13, -12]],
+    [[11, -7, -12], [11, 13, -12], [11, 13, 18], [11, -7, 18]],
+    [[1, -7, -12], [11, -7, -12], [11, -7, 18], [1, -7, 18]],
+    [[1, 13, -12], [1, 13, 18], [11, 13, 18], [11, 13, -12]],
+    [[1, -7, -12], [1, 13, -12], [11, 13, -12], [11, -7, -12]],
+    [[1, -7, 18], [11, -7, 18], [11, 13, 18], [1, 13, 18]]
+  ]
+  t.notThrows(() => geom3.validate(translated))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  translated = translateX(3, geometry)
+  obs = geom3.toPoints(translated)
+  t.notThrows(() => geom3.validate(translated))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  // translated Y
+  translated = translate([0, 3], geometry)
+  obs = geom3.toPoints(translated)
+  exp = [
+    [[-2, -4, -12], [-2, -4, 18], [-2, 16, 18], [-2, 16, -12]],
+    [[8, -4, -12], [8, 16, -12], [8, 16, 18], [8, -4, 18]],
+    [[-2, -4, -12], [8, -4, -12], [8, -4, 18], [-2, -4, 18]],
+    [[-2, 16, -12], [-2, 16, 18], [8, 16, 18], [8, 16, -12]],
+    [[-2, -4, -12], [-2, 16, -12], [8, 16, -12], [8, -4, -12]],
+    [[-2, -4, 18], [8, -4, 18], [8, 16, 18], [-2, 16, 18]]
+  ]
+  t.notThrows(() => geom3.validate(translated))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  translated = translateY(3, geometry)
+  obs = geom3.toPoints(translated)
+  t.notThrows(() => geom3.validate(translated))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  // translate Z
+  translated = translate([0, 0, 3], geometry)
+  obs = geom3.toPoints(translated)
+  exp = [
+    [[-2, -7, -9], [-2, -7, 21], [-2, 13, 21], [-2, 13, -9]],
+    [[8, -7, -9], [8, 13, -9], [8, 13, 21], [8, -7, 21]],
+    [[-2, -7, -9], [8, -7, -9], [8, -7, 21], [-2, -7, 21]],
+    [[-2, 13, -9], [-2, 13, 21], [8, 13, 21], [8, 13, -9]],
+    [[-2, -7, -9], [-2, 13, -9], [8, 13, -9], [8, -7, -9]],
+    [[-2, -7, 21], [8, -7, 21], [8, 13, 21], [-2, 13, 21]]
+  ]
+  t.notThrows(() => geom3.validate(translated))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  translated = translateZ(3, geometry)
+  obs = geom3.toPoints(translated)
+  t.notThrows(() => geom3.validate(translated))
+  t.true(comparePolygonsAsPoints(obs, exp))
+})
+
+test('translate: translating of multiple objects produces expected changes', (t) => {
+  const junk = 'hello'
+  const geometry1 = path2.fromPoints({}, [[-5, 5], [5, 5], [-5, -5], [10, -5]])
+  const geometry2 = geom2.fromPoints([[-5, -5], [0, 5], [10, -5]])
+
+  const translated = translate([3, 3, 3], junk, geometry1, geometry2)
+  t.is(translated[0], junk)
+
+  let obs = path2.toPoints(translated[1])
+  let exp = [[-2, 8], [8, 8], [-2, -2], [13, -2]]
+  t.notThrows(() => path2.validate(translated[1]))
+  t.true(comparePoints(obs, exp))
+
+  obs = geom2.toPoints(translated[2])
+  exp = [[-2, -2], [3, 8], [13, -2]]
+  t.notThrows(() => geom2.validate(translated[2]))
+  t.true(comparePoints(obs, exp))
+})

package/src/primitives/arc.d.ts

@@ -0,0 +1,15 @@
+import Vec2 from '../maths/vec2/type'
+import Path2 from '../geometries/path2/type'
+
+export default arc
+
+export interface ArcOptions {
+  center?: Vec2
+  radius?: number
+  startAngle?: number
+  endAngle?: number
+  segments?: number
+  makeTangent?: boolean
+}
+
+declare function arc(options?: ArcOptions): Path2

package/src/primitives/arc.js

@@ -0,0 +1,86 @@
+const { EPS, TAU } = require('../maths/constants')
+
+const vec2 = require('../maths/vec2')
+
+const path2 = require('../geometries/path2')
+
+const { isGT, isGTE, isNumberArray } = require('./commonChecks')
+
+/**
+ * Construct an arc in two dimensional space where all points are at the same distance from the center.
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0]] - center of arc
+ * @param {Number} [options.radius=1] - radius of arc
+ * @param {Number} [options.startAngle=0] - starting angle of the arc, in radians
+ * @param {Number} [options.endAngle=TAU] - ending angle of the arc, in radians
+ * @param {Number} [options.segments=32] - number of segments to create per full rotation
+ * @param {Boolean} [options.makeTangent=false] - adds line segments at both ends of the arc to ensure that the gradients at the edges are tangent
+ * @returns {path2} new 2D path
+ * @alias module:modeling/primitives.arc
+ * @example
+ * let myshape = arc({ center: [-1, -1], radius: 2, endAngle: (TAU / 4)})
+ */
+const arc = (options) => {
+  const defaults = {
+    center: [0, 0],
+    radius: 1,
+    startAngle: 0,
+    endAngle: TAU,
+    makeTangent: false,
+    segments: 32
+  }
+  let { center, radius, startAngle, endAngle, makeTangent, segments } = Object.assign({}, defaults, options)
+
+  if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
+  if (!isGT(radius, 0)) throw new Error('radius must be greater than zero')
+  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 minangle = Math.acos(((radius * radius) + (radius * radius) - (EPS * EPS)) / (2 * radius * radius))
+
+  const centerv = vec2.clone(center)
+  let point
+  const pointArray = []
+  if (rotation < minangle) {
+    // there is no rotation, just a single point
+    point = vec2.fromAngleRadians(vec2.create(), startAngle)
+    vec2.scale(point, point, radius)
+    vec2.add(point, point, centerv)
+    pointArray.push(point)
+  } else {
+    // note: add one additional step to acheive full rotation
+    const numsteps = Math.max(1, Math.floor(segments * (rotation / TAU))) + 1
+    let edgestepsize = numsteps * 0.5 / rotation // step size for half a degree
+    if (edgestepsize > 0.25) edgestepsize = 0.25
+
+    const totalsteps = makeTangent ? (numsteps + 2) : numsteps
+    for (let i = 0; i <= totalsteps; i++) {
+      let step = i
+      if (makeTangent) {
+        step = (i - 1) * (numsteps - 2 * edgestepsize) / numsteps + edgestepsize
+        if (step < 0) step = 0
+        if (step > numsteps) step = numsteps
+      }
+      const angle = startAngle + (step * (rotation / numsteps))
+      point = vec2.fromAngleRadians(vec2.create(), angle)
+      vec2.scale(point, point, radius)
+      vec2.add(point, point, centerv)
+      pointArray.push(point)
+    }
+  }
+  return path2.fromPoints({ closed: false }, pointArray)
+}
+
+module.exports = arc

package/src/primitives/arc.test.js

@@ -0,0 +1,223 @@
+const test = require('ava')
+
+const { TAU } = require('../maths/constants')
+const path2 = require('../geometries/path2')
+
+const comparePoints = require('../../test/helpers/comparePoints')
+
+const { arc } = require('./index')
+
+test('arc (defaults)', (t) => {
+  const geometry = arc()
+  const obs = path2.toPoints(geometry)
+
+  t.notThrows(() => path2.validate(geometry))
+  t.deepEqual(obs.length, 33)
+})
+
+test('arc (options)', (t) => {
+  // test center
+  let exp = [
+    [3, 2],
+    [2.9324722294043557, 2.361241666187153],
+    [2.739008917220659, 2.6736956436465573],
+    [2.4457383557765384, 2.8951632913550625],
+    [2.092268359463302, 2.9957341762950342],
+    [1.7263370099279172, 2.961825643172819],
+    [1.3973653636207437, 2.7980172272802397],
+    [1.1497828642703858, 2.526432162877356],
+    [1.017026900316098, 2.1837495178165702],
+    [1.017026900316098, 1.8162504821834298],
+    [1.149782864270386, 1.4735678371226442],
+    [1.3973653636207435, 1.2019827727197605],
+    [1.726337009927917, 1.0381743568271808],
+    [2.0922683594633016, 1.0042658237049653],
+    [2.4457383557765384, 1.1048367086449378],
+    [2.739008917220659, 1.326304356353443],
+    [2.9324722294043557, 1.6387583338128469]
+  ]
+  let geometry = arc({ center: [2, 2], segments: 16 })
+  let obs = path2.toPoints(geometry)
+
+  t.notThrows(() => path2.validate(geometry))
+  t.deepEqual(obs.length, 17)
+  t.true(comparePoints(obs, exp))
+
+  // test radius
+  exp = [
+    [2, 0],
+    [1.8649444588087116, 0.7224833323743058],
+    [1.4780178344413182, 1.3473912872931144],
+    [0.8914767115530766, 1.7903265827101247],
+    [0.18453671892660403, 1.991468352590069],
+    [-0.5473259801441658, 1.923651286345638],
+    [-1.2052692727585126, 1.5960344545604792],
+    [-1.7004342714592284, 1.0528643257547114],
+    [-1.9659461993678036, 0.36749903563314074],
+    [-1.9659461993678036, -0.36749903563314024],
+    [-1.7004342714592282, -1.0528643257547117],
+    [-1.205269272758513, -1.596034454560479],
+    [-0.5473259801441662, -1.923651286345638],
+    [0.1845367189266031, -1.9914683525900692],
+    [0.8914767115530771, -1.7903265827101245],
+    [1.4780178344413184, -1.3473912872931142],
+    [1.8649444588087116, -0.7224833323743061]
+  ]
+  geometry = arc({ radius: 2, segments: 16 })
+  obs = path2.toPoints(geometry)
+
+  t.notThrows(() => path2.validate(geometry))
+  t.deepEqual(obs.length, 17)
+  t.true(comparePoints(obs, exp))
+
+  // test startAngle
+  exp = [
+    [6.123233995736766e-17, 1],
+    [-0.3546048870425357, 0.9350162426854148],
+    [-0.6631226582407953, 0.748510748171101],
+    [-0.8854560256532098, 0.4647231720437687],
+    [-0.992708874098054, 0.12053668025532308],
+    [-0.970941817426052, -0.23931566428755788],
+    [-0.8229838658936566, -0.5680647467311556],
+    [-0.5680647467311559, -0.8229838658936564],
+    [-0.23931566428755774, -0.970941817426052],
+    [0.1205366802553232, -0.992708874098054],
+    [0.4647231720437688, -0.8854560256532098],
+    [0.7485107481711007, -0.6631226582407955],
+    [0.9350162426854147, -0.35460488704253595],
+    [1, -2.4492935982947064e-16]
+  ]
+  geometry = arc({ startAngle: TAU / 4, segments: 16 })
+  obs = path2.toPoints(geometry)
+
+  t.notThrows(() => path2.validate(geometry))
+  t.deepEqual(obs.length, 14)
+  t.true(comparePoints(obs, exp))
+
+  // test endAngle
+  exp = [
+    [1, 0],
+    [0.9510565162951535, 0.3090169943749474],
+    [0.8090169943749475, 0.5877852522924731],
+    [0.5877852522924731, 0.8090169943749475],
+    [0.30901699437494745, 0.9510565162951535],
+    [6.123233995736766e-17, 1]
+  ]
+  geometry = arc({ endAngle: TAU / 4, segments: 16 })
+  obs = path2.toPoints(geometry)
+
+  t.notThrows(() => path2.validate(geometry))
+  t.deepEqual(obs.length, 6)
+  t.true(comparePoints(obs, exp))
+
+  // test makeTangent
+  exp = [
+    [1, 0],
+    [0.9957341762950345, 0.09226835946330199],
+    [0.8999557329057603, 0.43598128263728936],
+    [0.6896020498551045, 0.7241885202318785],
+    [0.391453692861967, 0.9201978082699006],
+    [0.04346855052920052, 0.9990547958520045],
+    [-0.31005066355011174, 0.9507200355689026],
+    [-0.6240966815770753, 0.781347126470996],
+    [-0.858687650595474, 0.5124992865505523],
+    [-0.9839573055048071, 0.1784040945262181],
+    [-0.9839573055048071, -0.1784040945262183],
+    [-0.8586876505954741, -0.5124992865505521],
+    [-0.6240966815770755, -0.7813471264709959],
+    [-0.3100506635501122, -0.9507200355689025],
+    [0.04346855052920005, -0.9990547958520045],
+    [0.39145369286196696, -0.9201978082699006],
+    [0.6896020498551043, -0.7241885202318787],
+    [0.8999557329057604, -0.435981282637289],
+    [0.9957341762950345, -0.09226835946330197]
+  ]
+  geometry = arc({ makeTangent: true, segments: 16 })
+  obs = path2.toPoints(geometry)
+
+  t.notThrows(() => path2.validate(geometry))
+  t.deepEqual(obs.length, 19)
+  t.true(comparePoints(obs, exp))
+
+  // test segments
+  exp = [
+    [1, 0],
+    [0.766044443118978, 0.6427876096865393],
+    [0.17364817766693041, 0.984807753012208],
+    [-0.4999999999999998, 0.8660254037844387],
+    [-0.9396926207859083, 0.3420201433256689],
+    [-0.9396926207859084, -0.34202014332566866],
+    [-0.5000000000000004, -0.8660254037844385],
+    [0.17364817766692997, -0.9848077530122081],
+    [0.7660444431189778, -0.6427876096865396]
+  ]
+  geometry = arc({ segments: 8 })
+  obs = path2.toPoints(geometry)
+
+  t.notThrows(() => path2.validate(geometry))
+  t.deepEqual(obs.length, 9)
+  t.true(comparePoints(obs, exp))
+})
+
+test('arc (rotations)', (t) => {
+  let exp = [
+    [6.123233995736766e-17, 1],
+    [-0.30901699437494734, 0.9510565162951536],
+    [-0.587785252292473, 0.8090169943749475],
+    [-0.8090169943749473, 0.5877852522924732],
+    [-0.9510565162951535, 0.3090169943749475],
+    [-1, 1.2246467991473532e-16]
+  ]
+  let geometry = arc({ startAngle: TAU / 4, endAngle: TAU / 2, segments: 16 })
+  let obs = path2.toPoints(geometry)
+
+  t.notThrows(() => path2.validate(geometry))
+  t.deepEqual(obs.length, 6)
+  t.true(comparePoints(obs, exp))
+
+  exp = [
+    [-1, 1.2246467991473532e-16],
+    [-0.9396926207859084, -0.34202014332566866],
+    [-0.7660444431189781, -0.6427876096865393],
+    [-0.5000000000000004, -0.8660254037844385],
+    [-0.17364817766693033, -0.984807753012208],
+    [0.17364817766692997, -0.9848077530122081],
+    [0.49999999999999933, -0.866025403784439],
+    [0.7660444431189778, -0.6427876096865396],
+    [0.9396926207859084, -0.3420201433256686],
+    [1, -2.4492935982947064e-16]
+  ]
+  geometry = arc({ startAngle: TAU / 2, endAngle: TAU, segments: 16 })
+  obs = path2.toPoints(geometry)
+
+  t.notThrows(() => path2.validate(geometry))
+  t.deepEqual(obs.length, 10)
+  t.true(comparePoints(obs, exp))
+
+  exp = [
+    [-1.8369701987210297e-16, -1],
+    [0.34202014332566816, -0.9396926207859085],
+    [0.6427876096865393, -0.7660444431189781],
+    [0.8660254037844384, -0.5000000000000004],
+    [0.984807753012208, -0.1736481776669304],
+    [0.9848077530122081, 0.17364817766692991],
+    [0.866025403784439, 0.4999999999999993],
+    [0.6427876096865396, 0.7660444431189778],
+    [0.34202014332566866, 0.9396926207859084],
+    [3.061616997868383e-16, 1]
+  ]
+  geometry = arc({ startAngle: TAU * 0.75, endAngle: TAU / 4, segments: 16 })
+  obs = path2.toPoints(geometry)
+
+  t.notThrows(() => path2.validate(geometry))
+  t.deepEqual(obs.length, 10)
+  t.true(comparePoints(obs, exp))
+
+  exp = [[-1.8369701987210297e-16, -1]]
+  geometry = arc({ startAngle: TAU * 0.75, endAngle: 270.000000005 * 0.017453292519943295, segments: 16 })
+  obs = path2.toPoints(geometry)
+
+  t.notThrows(() => path2.validate(geometry))
+  t.deepEqual(obs.length, 1)
+  t.true(comparePoints(obs, exp))
+})

package/src/primitives/circle.d.ts

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

package/src/primitives/circle.js

@@ -0,0 +1,38 @@
+const { TAU } = require('../maths/constants')
+
+const ellipse = require('./ellipse')
+
+const { isGTE } = require('./commonChecks')
+
+/**
+ * Construct a circle in two dimensional space where all points are at the same distance from the center.
+ * @see [ellipse]{@link module:modeling/primitives.ellipse} for more options
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0]] - center of circle
+ * @param {Number} [options.radius=1] - radius of circle
+ * @param {Number} [options.startAngle=0] - start angle of circle, in radians
+ * @param {Number} [options.endAngle=TAU] - end angle of circle, in radians
+ * @param {Number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {geom2} new 2D geometry
+ * @alias module:modeling/primitives.circle
+ * @example
+ * let myshape = circle({radius: 10})
+ */
+const circle = (options) => {
+  const defaults = {
+    center: [0, 0],
+    radius: 1,
+    startAngle: 0,
+    endAngle: TAU,
+    segments: 32
+  }
+  let { center, radius, startAngle, endAngle, segments } = Object.assign({}, defaults, options)
+
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
+
+  radius = [radius, radius]
+
+  return ellipse({ center, radius, startAngle, endAngle, segments })
+}
+
+module.exports = circle