@jbroll/jscad-modeling 2.12.7

package/src/primitives/polygon.js

@@ -0,0 +1,81 @@
+const geom2 = require('../geometries/geom2')
+
+/**
+ * Construct a polygon in two dimensional space from a list of points, or a list of points and paths.
+ *
+ * NOTE: The ordering of points is important, and must define a counter clockwise rotation of points.
+ *
+ * @param {Object} options - options for construction
+ * @param {Array} options.points - points of the polygon : either flat or nested array of 2D points
+ * @param {Array} [options.paths] - paths of the polygon : either flat or nested array of point indexes
+ * @param {String} [options.orientation='counterclockwise'] - orientation of points
+ * @returns {geom2} new 2D geometry
+ * @alias module:modeling/primitives.polygon
+ *
+ * @example
+ * let roof = [[10,11], [0,11], [5,20]]
+ * let wall = [[0,0], [10,0], [10,10], [0,10]]
+ *
+ * let poly = polygon({ points: roof })
+ * or
+ * let poly = polygon({ points: [roof, wall] })
+ * or
+ * let poly = polygon({ points: roof, paths: [0, 1, 2] })
+ * or
+ * let poly = polygon({ points: [roof, wall], paths: [[0, 1, 2], [3, 4, 5, 6]] })
+ */
+const polygon = (options) => {
+  const defaults = {
+    points: [],
+    paths: [],
+    orientation: 'counterclockwise'
+  }
+  const { points, paths, orientation } = Object.assign({}, defaults, options)
+
+  if (!(Array.isArray(points) && Array.isArray(paths))) throw new Error('points and paths must be arrays')
+
+  let listofpolys = points
+  if (Array.isArray(points[0])) {
+    if (!Array.isArray(points[0][0])) {
+      // points is an array of something... convert to list
+      listofpolys = [points]
+    }
+  }
+
+  listofpolys.forEach((list, i) => {
+    if (!Array.isArray(list)) throw new Error('list of points ' + i + ' must be an array')
+    if (list.length < 3) throw new Error('list of points ' + i + ' must contain three or more points')
+    list.forEach((point, j) => {
+      if (!Array.isArray(point)) throw new Error('list of points ' + i + ', point ' + j + ' must be an array')
+      if (point.length < 2) throw new Error('list of points ' + i + ', point ' + j + ' must contain by X and Y values')
+    })
+  })
+
+  let listofpaths = paths
+  if (paths.length === 0) {
+    // create a list of paths based on the points
+    let count = 0
+    listofpaths = listofpolys.map((list) => list.map((point) => count++))
+  }
+
+  // flatten the listofpoints for indexed access
+  const allpoints = []
+  listofpolys.forEach((list) => list.forEach((point) => allpoints.push(point)))
+
+  // convert the list of paths into a list of sides, and accumulate
+  let sides = []
+  listofpaths.forEach((path) => {
+    const setofpoints = path.map((index) => allpoints[index])
+    const geometry = geom2.fromPoints(setofpoints)
+    sides = sides.concat(geom2.toSides(geometry))
+  })
+
+  // convert the list of sides into a geometry
+  let geometry = geom2.create(sides)
+  if (orientation === 'clockwise') {
+    geometry = geom2.reverse(geometry)
+  }
+  return geometry
+}
+
+module.exports = polygon

package/src/primitives/polygon.test.js

@@ -0,0 +1,63 @@
+const test = require('ava')
+
+const geom2 = require('../geometries/geom2')
+const measureArea = require('../measurements/measureArea')
+
+const { polygon } = require('./index')
+
+const comparePoints = require('../../test/helpers/comparePoints')
+
+test('polygon: providing only object.points creates expected geometry', (t) => {
+  let geometry = polygon({ points: [[0, 0], [100, 0], [130, 50], [30, 50]] })
+
+  let obs = geom2.toPoints(geometry)
+  let exp = [[0, 0], [100, 0], [130, 50], [30, 50]]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.true(comparePoints(obs, exp))
+
+  geometry = polygon({ points: [[[0, 0], [100, 0], [0, 100]], [[10, 10], [80, 10], [10, 80]]] })
+
+  obs = geom2.toPoints(geometry)
+  exp = [[0, 0], [100, 0], [10, 80], [10, 10], [80, 10], [0, 100]]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.true(comparePoints(obs, exp))
+})
+
+test('polygon: providing object.points (array) and object.path (array) creates expected geometry', (t) => {
+  let geometry = polygon({ points: [[0, 0], [100, 0], [130, 50], [30, 50]], paths: [[3, 2, 1, 0]] })
+
+  let obs = geom2.toPoints(geometry)
+  let exp = [[30, 50], [130, 50], [100, 0], [0, 0]]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.true(comparePoints(obs, exp))
+
+  // multiple paths
+  geometry = polygon({ points: [[0, 0], [100, 0], [0, 100], [10, 10], [80, 10], [10, 80]], paths: [[0, 1, 2], [3, 4, 5]] })
+
+  obs = geom2.toPoints(geometry)
+  exp = [[0, 0], [100, 0], [10, 80], [10, 10], [80, 10], [0, 100]]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.true(comparePoints(obs, exp))
+
+  // multiple points and paths
+  geometry = polygon({ points: [[[0, 0], [100, 0], [0, 100]], [[10, 10], [80, 10], [10, 80]]], paths: [[0, 1, 2], [3, 4, 5]] })
+
+  obs = geom2.toPoints(geometry)
+  exp = [[0, 0], [100, 0], [10, 80], [10, 10], [80, 10], [0, 100]]
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.true(comparePoints(obs, exp))
+})
+
+test('polygon: clockwise points', (t) => {
+  const poly = polygon({
+    points: [[-10, -0], [-10, -10], [-15, -5]],
+    orientation: 'clockwise'
+  })
+  t.is(poly.sides.length, 3)
+  t.is(measureArea(poly), 25)
+})

package/src/primitives/polyhedron.d.ts

@@ -0,0 +1,14 @@
+import Vec3 from '../maths/vec3/type'
+import Geom3 from '../geometries/geom3/type'
+import { RGB, RGBA } from '../colors/types'
+
+export default polyhedron
+
+export interface PolyhedronOptions {
+  points: Array<Vec3>
+  faces: Array<Array<number>>
+  colors?: Array<RGB | RGBA>
+  orientation?: 'outward' | 'inward'
+}
+
+declare function polyhedron(options: PolyhedronOptions): Geom3

package/src/primitives/polyhedron.js

@@ -0,0 +1,72 @@
+const geom3 = require('../geometries/geom3')
+const poly3 = require('../geometries/poly3')
+
+const { isNumberArray } = require('./commonChecks')
+
+/**
+ * Construct a polyhedron in three dimensional space from the given set of 3D points and faces.
+ *
+ * The faces can define outward or inward facing polygons (orientation).
+ * However, each face must define a counter clockwise rotation of points which follows the right hand rule.
+ * @param {Object} options - options for construction
+ * @param {Array} options.points - list of points in 3D space
+ * @param {Array} options.faces - list of faces, where each face is a set of indexes into the points
+ * @param {Array} [options.colors=undefined] - list of RGBA colors to apply to each face
+ * @param {String} [options.orientation='outward'] - orientation of faces
+ * @returns {geom3} new 3D geometry
+ * @alias module:modeling/primitives.polyhedron
+ *
+ * @example
+ * let mypoints = [ [10, 10, 0], [10, -10, 0], [-10, -10, 0], [-10, 10, 0], [0, 0, 10] ]
+ * let myfaces = [ [0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3] ]
+ * let myshape = polyhedron({points: mypoints, faces: myfaces, orientation: 'inward'})
+ */
+const polyhedron = (options) => {
+  const defaults = {
+    points: [],
+    faces: [],
+    colors: undefined,
+    orientation: 'outward'
+  }
+  const { points, faces, colors, orientation } = Object.assign({}, defaults, options)
+
+  if (!(Array.isArray(points) && Array.isArray(faces))) {
+    throw new Error('points and faces must be arrays')
+  }
+  if (points.length < 3) {
+    throw new Error('three or more points are required')
+  }
+  if (faces.length < 1) {
+    throw new Error('one or more faces are required')
+  }
+  if (colors) {
+    if (!Array.isArray(colors)) {
+      throw new Error('colors must be an array')
+    }
+    if (colors.length !== faces.length) {
+      throw new Error('faces and colors must have the same length')
+    }
+  }
+  points.forEach((point, i) => {
+    if (!isNumberArray(point, 3)) throw new Error(`point ${i} must be an array of X, Y, Z values`)
+  })
+  faces.forEach((face, i) => {
+    if (face.length < 3) throw new Error(`face ${i} must contain 3 or more indexes`)
+    if (!isNumberArray(face, face.length)) throw new Error(`face ${i} must be an array of numbers`)
+  })
+
+  // invert the faces if orientation is inwards, as all internals expect outwarding facing polygons
+  if (orientation !== 'outward') {
+    faces.forEach((face) => face.reverse())
+  }
+
+  const polygons = faces.map((face, findex) => {
+    const polygon = poly3.create(face.map((pindex) => points[pindex]))
+    if (colors && colors[findex]) polygon.color = colors[findex]
+    return polygon
+  })
+
+  return geom3.create(polygons)
+}
+
+module.exports = polyhedron

package/src/primitives/polyhedron.test.js

@@ -0,0 +1,44 @@
+const test = require('ava')
+
+const { polyhedron } = require('./index')
+
+const geom3 = require('../geometries/geom3')
+
+const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoints')
+
+test('polyhedron (points and faces)', (t) => {
+  // points and faces form a cube
+  let points = [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1], [1, -1, 1], [1, -1, -1], [1, 1, -1], [1, 1, 1]]
+  let faces = [[0, 1, 2, 3], [5, 6, 7, 4], [0, 5, 4, 1], [3, 2, 7, 6], [0, 3, 6, 5], [1, 4, 7, 2]]
+  const colors = [[0, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1], [0.5, 0.5, 0.5, 1], [1, 1, 1, 1]]
+  let obs = polyhedron({ points, faces, colors })
+  let pts = geom3.toPoints(obs)
+  let 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.deepEqual(pts.length, 6)
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  // test orientation
+  points = [[10, 10, 0], [10, -10, 0], [-10, -10, 0], [-10, 10, 0], [0, 0, 10]]
+  faces = [[0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3]]
+  obs = polyhedron({ points: points, faces: faces, orientation: 'inward' })
+  pts = geom3.toPoints(obs)
+  exp = [
+    [[0, 0, 10], [10, -10, 0], [10, 10, 0]],
+    [[0, 0, 10], [-10, -10, 0], [10, -10, 0]],
+    [[0, 0, 10], [-10, 10, 0], [-10, -10, 0]],
+    [[0, 0, 10], [10, 10, 0], [-10, 10, 0]],
+    [[-10, 10, 0], [10, 10, 0], [10, -10, 0]],
+    [[-10, 10, 0], [10, -10, 0], [-10, -10, 0]]
+  ]
+  t.notThrows(() => geom3.validate(obs))
+  t.deepEqual(pts.length, 6)
+  t.true(comparePolygonsAsPoints(pts, exp))
+})

package/src/primitives/rectangle.d.ts

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

package/src/primitives/rectangle.js

@@ -0,0 +1,44 @@
+const vec2 = require('../maths/vec2')
+
+const geom2 = require('../geometries/geom2')
+
+const { isNumberArray } = require('./commonChecks')
+
+/**
+ * Construct an axis-aligned rectangle in two dimensional space with four sides at right angles.
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0]] - center of rectangle
+ * @param {Array} [options.size=[2,2]] - dimension of rectangle, width and length
+ * @returns {geom2} new 2D geometry
+ * @alias module:modeling/primitives.rectangle
+ *
+ * @example
+ * let myshape = rectangle({size: [10, 20]})
+ */
+const rectangle = (options) => {
+  const defaults = {
+    center: [0, 0],
+    size: [2, 2]
+  }
+  const { center, size } = 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 any size is zero return empty geometry
+  if (size[0] === 0 || size[1] === 0) return geom2.create()
+
+  const point = [size[0] / 2, size[1] / 2]
+  const pswap = [point[0], -point[1]]
+
+  const points = [
+    vec2.subtract(vec2.create(), center, point),
+    vec2.add(vec2.create(), center, pswap),
+    vec2.add(vec2.create(), center, point),
+    vec2.subtract(vec2.create(), center, pswap)
+  ]
+  return geom2.fromPoints(points)
+}
+
+module.exports = rectangle

package/src/primitives/rectangle.test.js

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

package/src/primitives/roundedCuboid.d.ts

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

package/src/primitives/roundedCuboid.js

@@ -0,0 +1,193 @@
+const { EPS, TAU } = require('../maths/constants')
+
+const vec2 = require('../maths/vec2')
+const vec3 = require('../maths/vec3')
+
+const geom3 = require('../geometries/geom3')
+const poly3 = require('../geometries/poly3')
+
+const { sin, cos } = require('../maths/utils/trigonometry')
+
+const { isGTE, isNumberArray } = require('./commonChecks')
+const cuboid = require('./cuboid')
+
+const createCorners = (center, size, radius, segments, slice, positive) => {
+  const pitch = (TAU / 4) * slice / segments
+  const cospitch = cos(pitch)
+  const sinpitch = sin(pitch)
+
+  const layersegments = segments - slice
+  let layerradius = radius * cospitch
+  let layeroffset = size[2] - (radius - (radius * sinpitch))
+  if (!positive) layeroffset = (radius - (radius * sinpitch)) - size[2]
+
+  layerradius = layerradius > EPS ? layerradius : 0
+
+  const corner0 = vec3.add(vec3.create(), center, [size[0] - radius, size[1] - radius, layeroffset])
+  const corner1 = vec3.add(vec3.create(), center, [radius - size[0], size[1] - radius, layeroffset])
+  const corner2 = vec3.add(vec3.create(), center, [radius - size[0], radius - size[1], layeroffset])
+  const corner3 = vec3.add(vec3.create(), center, [size[0] - radius, radius - size[1], layeroffset])
+  const corner0Points = []
+  const corner1Points = []
+  const corner2Points = []
+  const corner3Points = []
+  for (let i = 0; i <= layersegments; i++) {
+    const radians = layersegments > 0 ? TAU / 4 * i / layersegments : 0
+    const point2d = vec2.fromAngleRadians(vec2.create(), radians)
+    vec2.scale(point2d, point2d, layerradius)
+    const point3d = vec3.fromVec2(vec3.create(), point2d)
+    corner0Points.push(vec3.add(vec3.create(), corner0, point3d))
+    vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
+    corner1Points.push(vec3.add(vec3.create(), corner1, point3d))
+    vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
+    corner2Points.push(vec3.add(vec3.create(), corner2, point3d))
+    vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
+    corner3Points.push(vec3.add(vec3.create(), corner3, point3d))
+  }
+  if (!positive) {
+    corner0Points.reverse()
+    corner1Points.reverse()
+    corner2Points.reverse()
+    corner3Points.reverse()
+    return [corner3Points, corner2Points, corner1Points, corner0Points]
+  }
+  return [corner0Points, corner1Points, corner2Points, corner3Points]
+}
+
+const stitchCorners = (previousCorners, currentCorners) => {
+  const polygons = []
+  for (let i = 0; i < previousCorners.length; i++) {
+    const previous = previousCorners[i]
+    const current = currentCorners[i]
+    for (let j = 0; j < (previous.length - 1); j++) {
+      polygons.push(poly3.create([previous[j], previous[j + 1], current[j]]))
+
+      if (j < (current.length - 1)) {
+        polygons.push(poly3.create([current[j], previous[j + 1], current[j + 1]]))
+      }
+    }
+  }
+  return polygons
+}
+
+const stitchWalls = (previousCorners, currentCorners) => {
+  const polygons = []
+  for (let i = 0; i < previousCorners.length; i++) {
+    let previous = previousCorners[i]
+    let current = currentCorners[i]
+    const p0 = previous[previous.length - 1]
+    const c0 = current[current.length - 1]
+
+    const j = (i + 1) % previousCorners.length
+    previous = previousCorners[j]
+    current = currentCorners[j]
+    const p1 = previous[0]
+    const c1 = current[0]
+
+    polygons.push(poly3.create([p0, p1, c1, c0]))
+  }
+  return polygons
+}
+
+const stitchSides = (bottomCorners, topCorners) => {
+  // make a copy and reverse the bottom corners
+  bottomCorners = [bottomCorners[3], bottomCorners[2], bottomCorners[1], bottomCorners[0]]
+  bottomCorners = bottomCorners.map((corner) => corner.slice().reverse())
+
+  const bottomPoints = []
+  bottomCorners.forEach((corner) => {
+    corner.forEach((point) => bottomPoints.push(point))
+  })
+
+  const topPoints = []
+  topCorners.forEach((corner) => {
+    corner.forEach((point) => topPoints.push(point))
+  })
+
+  const polygons = []
+  for (let i = 0; i < topPoints.length; i++) {
+    const j = (i + 1) % topPoints.length
+    polygons.push(poly3.create([bottomPoints[i], bottomPoints[j], topPoints[j], topPoints[i]]))
+  }
+  return polygons
+}
+
+/**
+ * Construct an axis-aligned solid cuboid in three dimensional space with rounded corners.
+ * @param {Object} [options] - options for construction
+ * @param {Array} [options.center=[0,0,0]] - center of rounded cube
+ * @param {Array} [options.size=[2,2,2]] - dimension of rounded cube; width, depth, height
+ * @param {Number} [options.roundRadius=0.2] - radius of rounded edges
+ * @param {Number} [options.segments=32] - number of segments to create per full rotation
+ * @returns {geom3} new 3D geometry
+ * @alias module:modeling/primitives.roundedCuboid
+ *
+ * @example
+ * let mycube = roundedCuboid({size: [10, 20, 10], roundRadius: 2, segments: 16})
+ */
+const roundedCuboid = (options) => {
+  const defaults = {
+    center: [0, 0, 0],
+    size: [2, 2, 2],
+    roundRadius: 0.2,
+    segments: 32
+  }
+  let { center, size, roundRadius, segments } = 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 X, Y and Z 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 || size[2] === 0) return geom3.create()
+
+  // if roundRadius is zero, return cuboid
+  if (roundRadius === 0) return cuboid({ center, size })
+
+  size = size.map((v) => v / 2) // convert to radius
+
+  if (roundRadius > (size[0] - EPS) ||
+      roundRadius > (size[1] - EPS) ||
+      roundRadius > (size[2] - EPS)) throw new Error('roundRadius must be smaller than the radius of all dimensions')
+
+  segments = Math.floor(segments / 4)
+
+  let prevCornersPos = null
+  let prevCornersNeg = null
+  let polygons = []
+  for (let slice = 0; slice <= segments; slice++) {
+    const cornersPos = createCorners(center, size, roundRadius, segments, slice, true)
+    const cornersNeg = createCorners(center, size, roundRadius, segments, slice, false)
+
+    if (slice === 0) {
+      polygons = polygons.concat(stitchSides(cornersNeg, cornersPos))
+    }
+
+    if (prevCornersPos) {
+      polygons = polygons.concat(stitchCorners(prevCornersPos, cornersPos),
+        stitchWalls(prevCornersPos, cornersPos))
+    }
+    if (prevCornersNeg) {
+      polygons = polygons.concat(stitchCorners(prevCornersNeg, cornersNeg),
+        stitchWalls(prevCornersNeg, cornersNeg))
+    }
+
+    if (slice === segments) {
+      // add the top
+      let points = cornersPos.map((corner) => corner[0])
+      polygons.push(poly3.create(points))
+      // add the bottom
+      points = cornersNeg.map((corner) => corner[0])
+      polygons.push(poly3.create(points))
+    }
+
+    prevCornersPos = cornersPos
+    prevCornersNeg = cornersNeg
+  }
+
+  return geom3.create(polygons)
+}
+
+module.exports = roundedCuboid