@jbroll/jscad-modeling 2.12.7

package/src/primitives/roundedRectangle.js

@@ -0,0 +1,76 @@
+const { EPS, TAU } = require('../maths/constants')
+
+const vec2 = require('../maths/vec2')
+
+const geom2 = require('../geometries/geom2')
+
+const { isGTE, isNumberArray } = require('./commonChecks')
+const rectangle = require('./rectangle')
+
+/**
+ * Construct an axis-aligned rectangle in two dimensional space with rounded corners.
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0]] - center of rounded rectangle
+ * @param {Array} [options.size=[2,2]] - dimension of rounded rectangle; width and length
+ * @param {Number} [options.roundRadius=0.2] - round radius of corners
+ * @param {Number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {geom2} new 2D geometry
+ * @alias module:modeling/primitives.roundedRectangle
+ *
+ * @example
+ * let myshape = roundedRectangle({size: [10, 20], roundRadius: 2})
+ */
+const roundedRectangle = (options) => {
+  const defaults = {
+    center: [0, 0],
+    size: [2, 2],
+    roundRadius: 0.2,
+    segments: 32
+  }
+  let { center, size, roundRadius, segments } = Object.assign({}, defaults, options)
+
+  if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
+  if (!isNumberArray(size, 2)) throw new Error('size must be an array of X and Y values')
+  if (!size.every((n) => n >= 0)) throw new Error('size values must be positive')
+  if (!isGTE(roundRadius, 0)) throw new Error('roundRadius must be positive')
+  if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
+
+  // if any size is zero return empty geometry
+  if (size[0] === 0 || size[1] === 0) return geom2.create()
+
+  // if roundRadius is zero, return rectangle
+  if (roundRadius === 0) return rectangle({ center, size })
+
+  size = size.map((v) => v / 2) // convert to radius
+
+  if (roundRadius > (size[0] - EPS) ||
+      roundRadius > (size[1] - EPS)) throw new Error('roundRadius must be smaller than the radius of all dimensions')
+
+  const cornersegments = Math.floor(segments / 4)
+
+  // create sets of points that define the corners
+  const corner0 = vec2.add(vec2.create(), center, [size[0] - roundRadius, size[1] - roundRadius])
+  const corner1 = vec2.add(vec2.create(), center, [roundRadius - size[0], size[1] - roundRadius])
+  const corner2 = vec2.add(vec2.create(), center, [roundRadius - size[0], roundRadius - size[1]])
+  const corner3 = vec2.add(vec2.create(), center, [size[0] - roundRadius, roundRadius - size[1]])
+  const corner0Points = []
+  const corner1Points = []
+  const corner2Points = []
+  const corner3Points = []
+  for (let i = 0; i <= cornersegments; i++) {
+    const radians = TAU / 4 * i / cornersegments
+    const point = vec2.fromAngleRadians(vec2.create(), radians)
+    vec2.scale(point, point, roundRadius)
+    corner0Points.push(vec2.add(vec2.create(), corner0, point))
+    vec2.rotate(point, point, vec2.create(), TAU / 4)
+    corner1Points.push(vec2.add(vec2.create(), corner1, point))
+    vec2.rotate(point, point, vec2.create(), TAU / 4)
+    corner2Points.push(vec2.add(vec2.create(), corner2, point))
+    vec2.rotate(point, point, vec2.create(), TAU / 4)
+    corner3Points.push(vec2.add(vec2.create(), corner3, point))
+  }
+
+  return geom2.fromPoints(corner0Points.concat(corner1Points, corner2Points, corner3Points))
+}
+
+module.exports = roundedRectangle

package/src/primitives/roundedRectangle.test.js

@@ -0,0 +1,124 @@
+const test = require('ava')
+
+const { roundedRectangle } = require('./index')
+
+const geom2 = require('../geometries/geom2')
+
+const comparePoints = require('../../test/helpers/comparePoints')
+
+test('roundedRectangle (defaults)', (t) => {
+  const geometry = roundedRectangle()
+  const obs = geom2.toPoints(geometry)
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 36)
+})
+
+test('roundedRectangle (zero size)', (t) => {
+  const obs = roundedRectangle({ size: [1, 0] })
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 0)
+})
+
+test('roundedRectangle (zero radius)', (t) => {
+  const obs = roundedRectangle({ roundRadius: 0 })
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.deepEqual(pts.length, 4)
+})
+
+test('roundedRectangle (options)', (t) => {
+  // test center
+  let geometry = roundedRectangle({ center: [4, 5], segments: 16 })
+  let obs = geom2.toPoints(geometry)
+  let exp = [
+    [5, 5.8],
+    [4.984775906502257, 5.876536686473018],
+    [4.941421356237309, 5.941421356237309],
+    [4.876536686473018, 5.984775906502257],
+    [4.8, 6],
+    [3.2, 6],
+    [3.1234633135269823, 5.984775906502257],
+    [3.0585786437626905, 5.941421356237309],
+    [3.015224093497743, 5.876536686473018],
+    [3, 5.8],
+    [3, 4.2],
+    [3.015224093497743, 4.123463313526982],
+    [3.0585786437626905, 4.058578643762691],
+    [3.1234633135269823, 4.015224093497743],
+    [3.2, 4],
+    [4.8, 4],
+    [4.876536686473018, 4.015224093497743],
+    [4.941421356237309, 4.058578643762691],
+    [4.984775906502257, 4.123463313526982],
+    [5, 4.2]
+  ]
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 20)
+  t.true(comparePoints(obs, exp))
+
+  // test size
+  geometry = roundedRectangle({ size: [10, 6], segments: 16 })
+  obs = geom2.toPoints(geometry)
+  exp = [
+    [5, 2.8],
+    [4.984775906502257, 2.8765366864730177],
+    [4.941421356237309, 2.9414213562373095],
+    [4.876536686473018, 2.984775906502257],
+    [4.8, 3],
+    [-4.8, 3],
+    [-4.876536686473018, 2.984775906502257],
+    [-4.941421356237309, 2.9414213562373095],
+    [-4.984775906502257, 2.8765366864730177],
+    [-5, 2.8],
+    [-5, -2.8],
+    [-4.984775906502257, -2.8765366864730177],
+    [-4.941421356237309, -2.9414213562373095],
+    [-4.876536686473018, -2.984775906502257],
+    [-4.8, -3],
+    [4.8, -3],
+    [4.876536686473018, -2.984775906502257],
+    [4.941421356237309, -2.9414213562373095],
+    [4.984775906502257, -2.8765366864730177],
+    [5, -2.8]
+  ]
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 20)
+  t.true(comparePoints(obs, exp))
+
+  // test roundRadius
+  geometry = roundedRectangle({ size: [10, 6], roundRadius: 2, segments: 16 })
+  obs = geom2.toPoints(geometry)
+  exp = [
+    [5, 1],
+    [4.847759065022574, 1.7653668647301797],
+    [4.414213562373095, 2.414213562373095],
+    [3.7653668647301797, 2.8477590650225735],
+    [3, 3],
+    [-3, 3],
+    [-3.7653668647301792, 2.8477590650225735],
+    [-4.414213562373095, 2.414213562373095],
+    [-4.847759065022574, 1.7653668647301797],
+    [-5, 1.0000000000000002],
+    [-5, -0.9999999999999998],
+    [-4.847759065022574, -1.7653668647301792],
+    [-4.414213562373095, -2.414213562373095],
+    [-3.76536686473018, -2.8477590650225735],
+    [-3.0000000000000004, -3],
+    [2.9999999999999996, -3],
+    [3.7653668647301792, -2.8477590650225735],
+    [4.414213562373095, -2.414213562373095],
+    [4.847759065022574, -1.7653668647301801],
+    [5, -1.0000000000000004]
+  ]
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 20)
+  t.true(comparePoints(obs, exp))
+
+  // test segments
+  geometry = roundedRectangle({ size: [10, 6], roundRadius: 2, segments: 64 })
+  obs = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 68)
+})

package/src/primitives/sphere.d.ts

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

package/src/primitives/sphere.js

@@ -0,0 +1,35 @@
+const ellipsoid = require('./ellipsoid')
+
+const { isGTE } = require('./commonChecks')
+
+/**
+ * Construct a sphere in three dimensional space where all points are at the same distance from the center.
+ * @see [ellipsoid]{@link module:modeling/primitives.ellipsoid} for more options
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0,0]] - center of sphere
+ * @param {Number} [options.radius=1] - radius of sphere
+ * @param {Number} [options.segments=32] - number of segments to create per full rotation
+ * @param {Array} [options.axes] -  an array with three vectors for the x, y and z base vectors
+ * @returns {geom3} new 3D geometry
+ * @alias module:modeling/primitives.sphere
+ *
+ * @example
+ * let myshape = sphere({radius: 5})
+ */
+const sphere = (options) => {
+  const defaults = {
+    center: [0, 0, 0],
+    radius: 1,
+    segments: 32,
+    axes: [[1, 0, 0], [0, -1, 0], [0, 0, 1]]
+  }
+  let { center, radius, segments, axes } = Object.assign({}, defaults, options)
+
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
+
+  radius = [radius, radius, radius]
+
+  return ellipsoid({ center, radius, segments, axes })
+}
+
+module.exports = sphere

package/src/primitives/sphere.test.js

@@ -0,0 +1,172 @@
+const test = require('ava')
+
+const geom3 = require('../geometries/geom3')
+
+const { sphere } = require('./index')
+
+const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+
+test('sphere (defaults)', (t) => {
+  const obs = sphere()
+  const pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 512)
+})
+
+test('sphere (options)', (t) => {
+  // test radius
+  let obs = sphere({ radius: 5, segments: 12 })
+  let pts = geom3.toPoints(obs)
+  let exp = []
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 72)
+  // t.true(comparePolygonsAsPoints(pts, exp))
+
+  // test segments
+  obs = sphere({ segments: 8 })
+  pts = geom3.toPoints(obs)
+  exp = [
+    [[1, 0, 0], [0.7071067811865476, -0.7071067811865475, 0],
+      [0.5000000000000001, -0.5, -0.7071067811865475], [0.7071067811865476, 0, -0.7071067811865475]],
+    [[0.7071067811865476, 0, 0.7071067811865475], [0.5000000000000001, -0.5, 0.7071067811865475],
+      [0.7071067811865476, -0.7071067811865475, 0], [1, 0, 0]],
+    [[0.7071067811865476, 0, -0.7071067811865475], [0.5000000000000001, -0.5, -0.7071067811865475], [0, 0, -1]],
+    [[0, 0, 1], [0.5000000000000001, -0.5, 0.7071067811865475], [0.7071067811865476, 0, 0.7071067811865475]],
+    [[0.7071067811865476, -0.7071067811865475, 0], [0, -1, 0],
+      [0, -0.7071067811865476, -0.7071067811865475], [0.5000000000000001, -0.5, -0.7071067811865475]],
+    [[0.5000000000000001, -0.5, 0.7071067811865475], [0, -0.7071067811865476, 0.7071067811865475],
+      [0, -1, 0], [0.7071067811865476, -0.7071067811865475, 0]],
+    [[0.5000000000000001, -0.5, -0.7071067811865475],
+      [0, -0.7071067811865476, -0.7071067811865475], [0, 0, -1]],
+    [[0, 0, 1], [0, -0.7071067811865476, 0.7071067811865475],
+      [0.5000000000000001, -0.5, 0.7071067811865475]],
+    [[0, -1, 0], [-0.7071067811865475, -0.7071067811865476, 0],
+      [-0.5, -0.5000000000000001, -0.7071067811865475],
+      [0, -0.7071067811865476, -0.7071067811865475]],
+    [[0, -0.7071067811865476, 0.7071067811865475],
+      [-0.5, -0.5000000000000001, 0.7071067811865475],
+      [-0.7071067811865475, -0.7071067811865476, 0], [0, -1, 0]],
+    [[0, -0.7071067811865476, -0.7071067811865475],
+      [-0.5, -0.5000000000000001, -0.7071067811865475], [0, 0, -1]],
+    [[0, 0, 1], [-0.5, -0.5000000000000001, 0.7071067811865475],
+      [0, -0.7071067811865476, 0.7071067811865475]],
+    [[-0.7071067811865475, -0.7071067811865476, 0], [-1, 0, 0],
+      [-0.7071067811865476, 0, -0.7071067811865475],
+      [-0.5, -0.5000000000000001, -0.7071067811865475]],
+    [[-0.5, -0.5000000000000001, 0.7071067811865475],
+      [-0.7071067811865476, 0, 0.7071067811865475], [-1, 0, 0],
+      [-0.7071067811865475, -0.7071067811865476, 0]],
+    [[-0.5, -0.5000000000000001, -0.7071067811865475],
+      [-0.7071067811865476, 0, -0.7071067811865475], [0, 0, -1]],
+    [[0, 0, 1], [-0.7071067811865476, 0, 0.7071067811865475],
+      [-0.5, -0.5000000000000001, 0.7071067811865475]],
+    [[-1, 0, 0], [-0.7071067811865477, 0.7071067811865475, 0],
+      [-0.5000000000000001, 0.5, -0.7071067811865475],
+      [-0.7071067811865476, 0, -0.7071067811865475]],
+    [[-0.7071067811865476, 0, 0.7071067811865475],
+      [-0.5000000000000001, 0.5, 0.7071067811865475],
+      [-0.7071067811865477, 0.7071067811865475, 0], [-1, 0, 0]],
+    [[-0.7071067811865476, 0, -0.7071067811865475],
+      [-0.5000000000000001, 0.5, -0.7071067811865475], [0, 0, -1]],
+    [[0, 0, 1], [-0.5000000000000001, 0.5, 0.7071067811865475],
+      [-0.7071067811865476, 0, 0.7071067811865475]],
+    [[-0.7071067811865477, 0.7071067811865475, 0], [0, 1, 0],
+      [0, 0.7071067811865476, -0.7071067811865475],
+      [-0.5000000000000001, 0.5, -0.7071067811865475]],
+    [[-0.5000000000000001, 0.5, 0.7071067811865475],
+      [0, 0.7071067811865476, 0.7071067811865475], [0, 1, 0],
+      [-0.7071067811865477, 0.7071067811865475, 0]],
+    [[-0.5000000000000001, 0.5, -0.7071067811865475],
+      [0, 0.7071067811865476, -0.7071067811865475], [0, 0, -1]],
+    [[0, 0, 1], [0, 0.7071067811865476, 0.7071067811865475],
+      [-0.5000000000000001, 0.5, 0.7071067811865475]],
+    [[0, 1, 0], [0.7071067811865474, 0.7071067811865477, 0],
+      [0.4999999999999999, 0.5000000000000001, -0.7071067811865475],
+      [0, 0.7071067811865476, -0.7071067811865475]],
+    [[0, 0.7071067811865476, 0.7071067811865475],
+      [0.4999999999999999, 0.5000000000000001, 0.7071067811865475],
+      [0.7071067811865474, 0.7071067811865477, 0], [0, 1, 0]],
+    [[0, 0.7071067811865476, -0.7071067811865475],
+      [0.4999999999999999, 0.5000000000000001, -0.7071067811865475], [0, 0, -1]],
+    [[0, 0, 1], [0.4999999999999999, 0.5000000000000001, 0.7071067811865475],
+      [0, 0.7071067811865476, 0.7071067811865475]],
+    [[0.7071067811865474, 0.7071067811865477, 0], [1, 0, 0],
+      [0.7071067811865476, 0, -0.7071067811865475],
+      [0.4999999999999999, 0.5000000000000001, -0.7071067811865475]],
+    [[0.4999999999999999, 0.5000000000000001, 0.7071067811865475],
+      [0.7071067811865476, 0, 0.7071067811865475], [1, 0, 0],
+      [0.7071067811865474, 0.7071067811865477, 0]],
+    [[0.4999999999999999, 0.5000000000000001, -0.7071067811865475],
+      [0.7071067811865476, 0, -0.7071067811865475], [0, 0, -1]],
+    [[0, 0, 1], [0.7071067811865476, 0, 0.7071067811865475],
+      [0.4999999999999999, 0.5000000000000001, 0.7071067811865475]]
+  ]
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 32)
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  // test center
+  obs = sphere({ center: [-3, 5, 7], segments: 8 })
+  pts = geom3.toPoints(obs)
+  exp = [
+    [[-2, 5, 7], [-2.2928932188134525, 4.292893218813452, 7],
+      [-2.5, 4.5, 6.292893218813452], [-2.2928932188134525, 5, 6.292893218813452]],
+    [[-2.2928932188134525, 5, 7.707106781186548], [-2.5, 4.5, 7.707106781186548],
+      [-2.2928932188134525, 4.292893218813452, 7], [-2, 5, 7]],
+    [[-2.2928932188134525, 5, 6.292893218813452], [-2.5, 4.5, 6.292893218813452], [-3, 5, 6]],
+    [[-3, 5, 8], [-2.5, 4.5, 7.707106781186548], [-2.2928932188134525, 5, 7.707106781186548]],
+    [[-2.2928932188134525, 4.292893218813452, 7], [-3, 4, 7],
+      [-3, 4.292893218813452, 6.292893218813452], [-2.5, 4.5, 6.292893218813452]],
+    [[-2.5, 4.5, 7.707106781186548], [-3, 4.292893218813452, 7.707106781186548],
+      [-3, 4, 7], [-2.2928932188134525, 4.292893218813452, 7]],
+    [[-2.5, 4.5, 6.292893218813452], [-3, 4.292893218813452, 6.292893218813452], [-3, 5, 6]],
+    [[-3, 5, 8], [-3, 4.292893218813452, 7.707106781186548], [-2.5, 4.5, 7.707106781186548]],
+    [[-3, 4, 7], [-3.7071067811865475, 4.292893218813452, 7],
+      [-3.5, 4.5, 6.292893218813452], [-3, 4.292893218813452, 6.292893218813452]],
+    [[-3, 4.292893218813452, 7.707106781186548], [-3.5, 4.5, 7.707106781186548],
+      [-3.7071067811865475, 4.292893218813452, 7], [-3, 4, 7]],
+    [[-3, 4.292893218813452, 6.292893218813452], [-3.5, 4.5, 6.292893218813452], [-3, 5, 6]],
+    [[-3, 5, 8], [-3.5, 4.5, 7.707106781186548], [-3, 4.292893218813452, 7.707106781186548]],
+    [[-3.7071067811865475, 4.292893218813452, 7], [-4, 5, 7],
+      [-3.7071067811865475, 5, 6.292893218813452], [-3.5, 4.5, 6.292893218813452]],
+    [[-3.5, 4.5, 7.707106781186548], [-3.7071067811865475, 5, 7.707106781186548],
+      [-4, 5, 7], [-3.7071067811865475, 4.292893218813452, 7]],
+    [[-3.5, 4.5, 6.292893218813452], [-3.7071067811865475, 5, 6.292893218813452], [-3, 5, 6]],
+    [[-3, 5, 8], [-3.7071067811865475, 5, 7.707106781186548], [-3.5, 4.5, 7.707106781186548]],
+    [[-4, 5, 7], [-3.707106781186548, 5.707106781186548, 7],
+      [-3.5, 5.5, 6.292893218813452], [-3.7071067811865475, 5, 6.292893218813452]],
+    [[-3.7071067811865475, 5, 7.707106781186548], [-3.5, 5.5, 7.707106781186548],
+      [-3.707106781186548, 5.707106781186548, 7], [-4, 5, 7]],
+    [[-3.7071067811865475, 5, 6.292893218813452], [-3.5, 5.5, 6.292893218813452], [-3, 5, 6]],
+    [[-3, 5, 8], [-3.5, 5.5, 7.707106781186548], [-3.7071067811865475, 5, 7.707106781186548]],
+    [[-3.707106781186548, 5.707106781186548, 7], [-3, 6, 7],
+      [-3, 5.707106781186548, 6.292893218813452], [-3.5, 5.5, 6.292893218813452]],
+    [[-3.5, 5.5, 7.707106781186548], [-3, 5.707106781186548, 7.707106781186548],
+      [-3, 6, 7], [-3.707106781186548, 5.707106781186548, 7]],
+    [[-3.5, 5.5, 6.292893218813452], [-3, 5.707106781186548, 6.292893218813452], [-3, 5, 6]],
+    [[-3, 5, 8], [-3, 5.707106781186548, 7.707106781186548], [-3.5, 5.5, 7.707106781186548]],
+    [[-3, 6, 7], [-2.2928932188134525, 5.707106781186548, 7],
+      [-2.5, 5.5, 6.292893218813452], [-3, 5.707106781186548, 6.292893218813452]],
+    [[-3, 5.707106781186548, 7.707106781186548], [-2.5, 5.5, 7.707106781186548],
+      [-2.2928932188134525, 5.707106781186548, 7], [-3, 6, 7]],
+    [[-3, 5.707106781186548, 6.292893218813452], [-2.5, 5.5, 6.292893218813452], [-3, 5, 6]],
+    [[-3, 5, 8], [-2.5, 5.5, 7.707106781186548], [-3, 5.707106781186548, 7.707106781186548]],
+    [[-2.2928932188134525, 5.707106781186548, 7], [-2, 5, 7],
+      [-2.2928932188134525, 5, 6.292893218813452], [-2.5, 5.5, 6.292893218813452]],
+    [[-2.5, 5.5, 7.707106781186548], [-2.2928932188134525, 5, 7.707106781186548],
+      [-2, 5, 7], [-2.2928932188134525, 5.707106781186548, 7]],
+    [[-2.5, 5.5, 6.292893218813452], [-2.2928932188134525, 5, 6.292893218813452], [-3, 5, 6]],
+    [[-3, 5, 8], [-2.2928932188134525, 5, 7.707106781186548], [-2.5, 5.5, 7.707106781186548]]
+  ]
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 32)
+  t.true(comparePolygonsAsPoints(pts, exp))
+})
+
+test('sphere (zero radius)', (t) => {
+  const obs = sphere({ radius: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/square.d.ts

@@ -0,0 +1,11 @@
+import Vec2 from '../maths/vec2/type'
+import Geom2 from '../geometries/geom2/type'
+
+export default square
+
+export interface SquareOptions {
+  center?: Vec2
+  size?: number
+}
+
+declare function square(options?: SquareOptions): Geom2

package/src/primitives/square.js

@@ -0,0 +1,31 @@
+const rectangle = require('./rectangle')
+
+const { isGTE } = require('./commonChecks')
+
+/**
+ * Construct an axis-aligned square in two dimensional space with four equal sides at right angles.
+ * @see [rectangle]{@link module:modeling/primitives.rectangle} for more options
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0]] - center of square
+ * @param {Number} [options.size=2] - dimension of square
+ * @returns {geom2} new 2D geometry
+ * @alias module:modeling/primitives.square
+ *
+ * @example
+ * let myshape = square({size: 10})
+ */
+const square = (options) => {
+  const defaults = {
+    center: [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]
+
+  return rectangle({ center, size })
+}
+
+module.exports = square

package/src/primitives/square.test.js

@@ -0,0 +1,51 @@
+const test = require('ava')
+
+const { square } = require('./index')
+
+const geom2 = require('../geometries/geom2')
+
+const comparePoints = require('../../test/helpers/comparePoints')
+
+test('square (defaults)', (t) => {
+  const geometry = square()
+  const obs = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 4)
+})
+
+test('square (options)', (t) => {
+  // test center
+  let obs = square({ size: 7, center: [6.5, 6.5] })
+  let pts = geom2.toPoints(obs)
+  let exp = [
+    [3, 3],
+    [10, 3],
+    [10, 10],
+    [3, 10]
+  ]
+
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+  t.true(comparePoints(pts, exp))
+
+  // test size
+  obs = square({ size: 7 })
+  pts = geom2.toPoints(obs)
+  exp = [
+    [-3.5, -3.5],
+    [3.5, -3.5],
+    [3.5, 3.5],
+    [-3.5, 3.5]
+  ]
+
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+  t.true(comparePoints(pts, exp))
+})
+
+test('square (zero size)', (t) => {
+  const geometry = square({ size: 0 })
+  const obs = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(obs.length, 0)
+})

package/src/primitives/star.d.ts

@@ -0,0 +1,15 @@
+import Vec2 from '../maths/vec2/type'
+import Geom2 from '../geometries/geom2/type'
+
+export default star
+
+export interface StarOptions {
+  center?: Vec2
+  vertices?: number
+  density?: number
+  outerRadius?: number
+  innerRadius?: number
+  startAngle?: number
+}
+
+declare function star(options?: StarOptions): Geom2

package/src/primitives/star.js

@@ -0,0 +1,88 @@
+const { TAU } = require('../maths/constants')
+const vec2 = require('../maths/vec2')
+
+const geom2 = require('../geometries/geom2')
+
+const { isGT, isGTE, isNumberArray } = require('./commonChecks')
+
+// @see http://www.jdawiseman.com/papers/easymath/surds_star_inner_radius.html
+const getRadiusRatio = (vertices, density) => {
+  if (vertices > 0 && density > 1 && density < vertices / 2) {
+    return Math.cos(Math.PI * density / vertices) / Math.cos(Math.PI * (density - 1) / vertices)
+  }
+  return 0
+}
+
+const getPoints = (vertices, radius, startAngle, center) => {
+  const a = TAU / vertices
+
+  const points = []
+  for (let i = 0; i < vertices; i++) {
+    const point = vec2.fromAngleRadians(vec2.create(), a * i + startAngle)
+    vec2.scale(point, point, radius)
+    vec2.add(point, center, point)
+    points.push(point)
+  }
+  return points
+}
+
+/**
+ * Construct a star in two dimensional space.
+ * @see https://en.wikipedia.org/wiki/Star_polygon
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0]] - center of star
+ * @param {Number} [options.vertices=5] - number of vertices (P) on the star
+ * @param {Number} [options.density=2] - density (Q) of star
+ * @param {Number} [options.outerRadius=1] - outer radius of vertices
+ * @param {Number} [options.innerRadius=0] - inner radius of vertices, or zero to calculate
+ * @param {Number} [options.startAngle=0] - starting angle for first vertice, in radians
+ * @returns {geom2} new 2D geometry
+ * @alias module:modeling/primitives.star
+ *
+ * @example
+ * let star1 = star({vertices: 8, outerRadius: 10}) // star with 8/2 density
+ * let star2 = star({vertices: 12, outerRadius: 40, innerRadius: 20}) // star with given radius
+ */
+const star = (options) => {
+  const defaults = {
+    center: [0, 0],
+    vertices: 5,
+    outerRadius: 1,
+    innerRadius: 0,
+    density: 2,
+    startAngle: 0
+  }
+  let { center, vertices, outerRadius, innerRadius, density, startAngle } = Object.assign({}, defaults, options)
+
+  if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
+  if (!isGTE(vertices, 2)) throw new Error('vertices must be two or more')
+  if (!isGT(outerRadius, 0)) throw new Error('outerRadius must be greater than zero')
+  if (!isGTE(innerRadius, 0)) throw new Error('innerRadius must be greater than zero')
+  if (!isGTE(startAngle, 0)) throw new Error('startAngle must be greater than zero')
+
+  // force integers
+  vertices = Math.floor(vertices)
+  density = Math.floor(density)
+
+  startAngle = startAngle % TAU
+
+  if (innerRadius === 0) {
+    if (!isGTE(density, 2)) throw new Error('density must be two or more')
+    innerRadius = outerRadius * getRadiusRatio(vertices, density)
+  }
+
+  const centerv = vec2.clone(center)
+
+  const outerPoints = getPoints(vertices, outerRadius, startAngle, centerv)
+  const innerPoints = getPoints(vertices, innerRadius, startAngle + Math.PI / vertices, centerv)
+
+  const allPoints = []
+  for (let i = 0; i < vertices; i++) {
+    allPoints.push(outerPoints[i])
+    allPoints.push(innerPoints[i])
+  }
+
+  return geom2.fromPoints(allPoints)
+}
+
+module.exports = star