@jscad/vtree 2.0.14 → 2.0.18

package/CHANGELOG.md

@@ -3,6 +3,38 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.0.18](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/vtree@2.0.17...@jscad/vtree@2.0.18) (2022-04-03)
+
+**Note:** Version bump only for package @jscad/vtree
+
+
+
+
+
+## [2.0.17](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/vtree@2.0.16...@jscad/vtree@2.0.17) (2022-04-03)
+
+**Note:** Version bump only for package @jscad/vtree
+
+
+
+
+
+## [2.0.16](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/vtree@2.0.15...@jscad/vtree@2.0.16) (2022-03-13)
+
+**Note:** Version bump only for package @jscad/vtree
+
+
+
+
+
+## [2.0.15](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/vtree@2.0.14...@jscad/vtree@2.0.15) (2022-03-06)
+
+**Note:** Version bump only for package @jscad/vtree
+
+
+
+
+
 ## [2.0.14](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/vtree@2.0.13...@jscad/vtree@2.0.14) (2022-02-19)
 
 **Note:** Version bump only for package @jscad/vtree

package/README.md

@@ -39,13 +39,13 @@ Some people (need to find their names again, sorry folks !) mentioned AST based
     * do diffs of the previous tree structure to determine the changed parts
  * make use of caching when possible:
     * caching of all possible variants of objects is not really feasable (there are infinite possible sizes of even a single cube() for example)
-    * but it should be possible to at least cache some of the 'previous versions' of a design before things change again (since not everything changes at once)
+    * but it should be possible to at least cache some 'previous versions' of a design before things change again (since not everything changes at once)
     * perhaps cache each geometry in the csg tree
 
 
 This repository will contain code that tries to explore these possibilities.
 
->It is also important to mention that some of the experiments here are also inspired by Maker.js by Dan Marshall, particularly the use of 'pojo' (plain old javascript objects) as a way to define shapes
+>It is also important to mention that some experiments here are also inspired by Maker.js by Dan Marshall, particularly the use of 'pojo' (plain old javascript objects) as a way to define shapes
 
 ## running the benchmarks
 

package/core/api-measurements.js

@@ -3,19 +3,17 @@ const { toArray } = require('./arrays')
 const cacheWithInvalidation = require('./cacheWithInvalidation')
 const cachedGenerator = require('./geometry-generator-cached')
 
-const makeMeasureArea = specials => {
+const makeMeasureArea = (specials) => {
   const measureArea = (...solids) => {
     // console.log('measure area in overlay api', solids)
     // console.log(arguments[1])
     solids = toArray(solids)
-    // we create a premptive cache
+    // we create a preemptive cache
     const cache = cacheWithInvalidation()
     const operands = cachedGenerator(solids, cache)
 
     const area = operands.reduce((acc, csg) => {
-      const tmpArea = csg.toTriangles().reduce(function (accSub, triPoly) {
-        return accSub + triPoly.getTetraFeatures(['area'])[0]
-      }, 0)
+      const tmpArea = csg.toTriangles().reduce((accSub, triPoly) => accSub + triPoly.getTetraFeatures(['area'])[0], 0)
       return acc + tmpArea
     }, 0)
 
@@ -27,17 +25,15 @@ const makeMeasureArea = specials => {
   return measureArea
 }
 
-const makeMeasureVolume = specials => {
+const makeMeasureVolume = (specials) => {
   const measureVolume = (...solids) => {
     solids = toArray(solids)
-    // we create a premptive cache
+    // we create a preemptive cache
     const cache = cacheWithInvalidation()
     const operands = cachedGenerator(solids, cache)
 
     const volume = operands.reduce((acc, csg) => {
-      const tmpArea = csg.toTriangles().reduce(function (accSub, triPoly) {
-        return accSub + triPoly.getTetraFeatures(['volume'])[0]
-      }, 0)
+      const tmpArea = csg.toTriangles().reduce((accSub, triPoly) => accSub + triPoly.getTetraFeatures(['volume'])[0], 0)
       return acc + tmpArea
     }, 0)
 
@@ -49,9 +45,9 @@ const makeMeasureVolume = specials => {
   return measureVolume
 }
 
-const makeMeasureBounds = specials => {
+const makeMeasureBounds = (specials) => {
   const measureBounds = (solid) => {
-    // we create a premptive cache
+    // we create a preemptive cache
     const cache = cacheWithInvalidation()
     const operands = cachedGenerator([solid], cache)
     const bounds = operands[0].getBounds()

package/core/buildCachedGeometryFromTree.js

@@ -18,9 +18,7 @@ const makeBuildCachedGeometryFromTree = (params) => {
   const { passesBeforeElimination, lookup, lookupCounts } = Object.assign({}, defaults, params)
   const cache = makeCacheWithInvalidation(passesBeforeElimination, lookup, lookupCounts)
 
-  const buildFinalResult = (tree, deep) => {
-    return toArray(dfs(tree, cache))
-  }
+  const buildFinalResult = (tree, deep) => toArray(dfs(tree, cache))
 
   // main function, this can be called every time one needs to generate
   // geometry from the vtree
@@ -50,7 +48,7 @@ const makeBuildCachedGeometryFromTree = (params) => {
 const dfs = (node, cache) => {
   // console.log('dfs', node)
   if (node.children) {
-    flatten(node.children).forEach(function (childNode) {
+    flatten(node.children).forEach((childNode) => {
       dfs(childNode, cache)
     })
   }

package/core/cacheWithInvalidation.js

@@ -27,9 +27,9 @@ const makeCacheWithInvalidation = (passesBeforeElimination = 1, lookup = {}, loo
     const totalHashes = Object.keys(lookup)
     const a = new Set(totalHashes)
     const b = new Set(currentPassHits)
-    const hashesWithNoHits = Array.from(new Set([...a].filter(x => !b.has(x))))
+    const hashesWithNoHits = Array.from(new Set([...a].filter((x) => !b.has(x))))
 
-    hashesWithNoHits.forEach(function (nodeHash, index) {
+    hashesWithNoHits.forEach((nodeHash, index) => {
       lookupCounts[nodeHash] -= 1
       // console.log('hashesWithNoHits', nodeHash, index, lookupCounts[nodeHash])
 

package/core/findDisconnectedSubGraphs.js

@@ -2,7 +2,7 @@
  * the script on which the tree is based returns arrays of data will return those
  * @param  {} root 'findDisconnectedSubGraphs'
  */
-const findDisconnectedSubGraphs = root => {
+const findDisconnectedSubGraphs = (root) => {
   // console.log('findDisconnectedSubGraphs')
   if (Array.isArray(root)) {
     root = { children: root, type: 'root' }
@@ -13,7 +13,7 @@ const findDisconnectedSubGraphs = root => {
   const subTrees = []
   dfs(root, stack, leafs, subTrees)
 
-  // const independantSubtree = root.children
+  // const independentSubtree = root.children
   // console.log('results subTrees', JSON.stringify(subTrees[0]))
   return subTrees[0]
 }
@@ -27,7 +27,7 @@ const dfs = (node, stack = [], leafs = [], subTrees, depth = 0) => {
     leafs.push(node)
   }
   if (node.children) {
-    node.children.forEach(function (childNode) {
+    node.children.forEach((childNode) => {
       // childNode.parent = node
       dfs(childNode, stack, leafs)
     })

package/core/generators/geometry-generator-cached-csg.js

@@ -12,14 +12,14 @@ const { extrudeLinear, extrudeRotate, extrudeFromSlices, extrudeRectangular } =
 const { measureArea, measureVolume, measureBounds } = modeling.measurements
 const { colorize } = modeling.colors
 
-/** genere actual 'genometry' based on vtree node(s)
+/** generate actual geometry based on vtree node(s)
  * @param  {} node
  * @param  {} cache
  */
 const generate = (node, cache) => {
   let operands
   if (Array.isArray(node)) {
-    return flatten(node).map(n => generate(n, cache))
+    return flatten(node).map((n) => generate(n, cache))
   }
 
   const { foundData, nodeHash } = cache.find(node)
@@ -28,11 +28,11 @@ const generate = (node, cache) => {
   }
 
   const nodeWithoutParams = (node, operands, fn) => {
-    operands = flatten(node.children).map(n => generate(n, cache))
+    operands = flatten(node.children).map((n) => generate(n, cache))
     return fn(operands)
   }
   const nodeWithParams = (node, operands, fn) => {
-    operands = flatten(node.children).map(n => generate(n, cache))
+    operands = flatten(node.children).map((n) => generate(n, cache))
     return fn(node.params, operands)
   }
 
@@ -70,18 +70,16 @@ const generate = (node, cache) => {
     extrudeRectangular: () => nodeWithParams(node, operands, extrudeRectangular),
     extrudeFromSlices: () => nodeWithParams(node, operands, extrudeFromSlices),
     // measurements
-    measureArea: () => {
+    measureArea: () =>
       // first generate the actual geometry for the items, then compute
-      return measureArea(flatten(node.children).map(n => generate(n, cache)))
-    },
-    measureVolume: () => {
+      measureArea(flatten(node.children).map((n) => generate(n, cache))),
+    measureVolume: () =>
       // first generate the actual geometry for the items, then compute
-      return measureVolume(flatten(node.children).map(n => generate(n, cache)))
-    },
-    measureBounds: () => {
+      measureVolume(flatten(node.children).map((n) => generate(n, cache))),
+    measureBounds: () =>
       // first generate the actual geometry for the items, then compute
-      return measureBounds(flatten(node.children).map(n => generate(n, cache)))
-    }
+      measureBounds(flatten(node.children).map((n) => generate(n, cache)))
+
   }
 
   const result = lookup[node.type] ? lookup[node.type]() : node

package/core/geometry-generator-cached.js

@@ -10,7 +10,7 @@ const generate = (node, cache) => {
   let result
   let operands
   if (Array.isArray(node)) {
-    return flatten(node).map(n => generate(n, cache))
+    return flatten(node).map((n) => generate(n, cache))
   }
 
   const { foundData, nodeHash } = cache.find(node)
@@ -41,67 +41,67 @@ const generate = (node, cache) => {
       result = square(node)
       break
     case 'union' :
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       result = union(operands)
       break
     case 'difference' :
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       result = difference(operands)
       break
     case 'intersection' :
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       result = intersection(operands)
       break
     case 'translate':
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       // console.log('translate::::', node.params, operands)
       result = translate(node.params, operands)
       break
     case 'rotate':
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       result = rotate(node.params, operands)
       break
     case 'scale':
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       result = scale(node.params, operands)
       break
     case 'contract':
       console.log('contract', node)
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       // FIXME: REALLY NEEDED ???
       operands = union(operands)
       result = contract(node.radius, node.n, operands)
       break
     case 'mirror':
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       result = mirror(node.params, operands)
       break
     case 'hull':
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       result = hull(operands)
       break
     case 'chain_hull':
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       result = chain_hull(operands)
       break
     case 'colorize':
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       result = colorize(node.params, operands)
       break
     case 'linear_extrude':
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       // FIXME: REALLY NEEDED ???
       operands = union(operands)
       result = linear_extrude(node.params, operands)
       break
     case 'rotate_extrude':
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       // FIXME: REALLY NEEDED ???
       operands = union(operands)
       result = rotate_extrude(node.params, operands)
       break
     case 'rectangular_extrude':
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       // operands = flatten(node.children).map(n => generate(n, cache))
       // FIXME: REALLY NEEDED ???
       // operands = union(operands)
@@ -109,11 +109,9 @@ const generate = (node, cache) => {
       break
     case 'measureArea':
       // console.log('actual measure Area')
-      operands = flatten(node.children).map(n => generate(n, cache))
+      operands = flatten(node.children).map((n) => generate(n, cache))
       result = operands.reduce((acc, csg) => {
-        const tmpArea = csg.toTriangles().reduce(function (accSub, triPoly) {
-          return accSub + triPoly.getTetraFeatures(['area'])
-        }, 0)
+        const tmpArea = csg.toTriangles().reduce((accSub, triPoly) => accSub + triPoly.getTetraFeatures(['area']), 0)
         return acc + tmpArea
       }, 0)
       break

package/core/index.js

@@ -1,7 +1,7 @@
 
 const { toArray, flatten } = require('./arrays')
 
-const cube = params => {
+const cube = (params) => {
   /* const defaults = {
     size: [1, 1, 1],
     center: [true, true, true]
@@ -11,7 +11,7 @@ const cube = params => {
   return Object.assign({}, _params, { type: 'cube' })
 }
 
-const sphere = params => {
+const sphere = (params) => {
   /* const defaults = {
     size: 1,
     center: [true, true, true]
@@ -21,7 +21,7 @@ const sphere = params => {
   return Object.assign({}, _params, { type: 'sphere' })
 }
 
-const cylinder = params => {
+const cylinder = (params) => {
   const _params = Object.assign({}, params)
 
   return Object.assign({}, _params, { type: 'cylinder' })
@@ -126,7 +126,7 @@ const measureBounds = require('./api-measurements').makeMeasureBounds(specials)
   // return {type: 'vector_text', params}
 } */
 
-// this is a convenience object, that mimicks the structure of the jscad functional api
+// this is a convenience object, that mimics the structure of the jscad functional api
 const apiClone = {
   primitives3d: {
     cube,
@@ -207,6 +207,6 @@ module.exports = {
   measureVolume,
   measureBounds,
 
-  // seperate
+  // separate
   specials
 }

package/core/modeling/index-old.js

@@ -19,7 +19,7 @@ const measureBounds = require('./api-measurements').makeMeasureBounds(specials)
   // return {type: 'vector_text', params}
 } */
 
-// this is a convenience object, that mimicks the structure of the jscad functional api
+// this is a convenience object, that mimics the structure of the jscad functional api
 const apiClone = {
   primitives3d: {
     cube,
@@ -100,6 +100,6 @@ module.exports = {
   measureVolume,
   measureBounds,
 
-  // seperate
+  // separate
   specials
 }

package/core/modeling/operations/measurements/measureArea.js

@@ -12,7 +12,7 @@ const cachedGenerator = require('../../../generators/geometry-generator-cached-c
  * @param {Object} specials - hash of 'specials'
  * @returns {Function} the actual function made for measuring areas
  **/
-const makeMeasureArea = specials => {
+const makeMeasureArea = (specials) => {
   /**
  * Measure the area of the given geometry.
  *
@@ -22,7 +22,7 @@ const makeMeasureArea = specials => {
  **/
   const _measureArea = (...objects) => {
     objects = flatten(objects)
-    // we create a premptive cache
+    // we create a preemptive cache
     const cache = cacheWithInvalidation()
     const operands = cachedGenerator(objects, cache)
 

package/core/modeling/operations/measurements/measureBounds.js

@@ -11,9 +11,9 @@ const cachedGenerator = require('../../../generators/geometry-generator-cached-c
  * @param {Object} specials - hash of 'specials'
  * @returns {Function} the actual function made for measuring bounds
  **/
-const makeMeasureBounds = specials => {
+const makeMeasureBounds = (specials) => {
   const _measureBounds = (solids) => {
-    // we create a premptive cache
+    // we create a preemptive cache
     const cache = cacheWithInvalidation()
     const operands = cachedGenerator([solids], cache)
     const bounds = measureBounds(operands)

package/core/modeling/operations/measurements/measureVolume.js

@@ -12,10 +12,10 @@ const cachedGenerator = require('../../../generators/geometry-generator-cached-c
  * @param {Object} specials - hash of 'specials'
  * @returns {Function} the actual function made for measuring volumes
  **/
-const makeMeasureVolume = specials => {
+const makeMeasureVolume = (specials) => {
   const _measureVolume = (...objects) => {
     objects = flatten(objects)
-    // we create a premptive cache
+    // we create a preemptive cache
     const cache = cacheWithInvalidation()
     const operands = cachedGenerator(objects, cache)
 

package/core/modeling/primitives/arc.js

@@ -1,3 +1,3 @@
-const arc = params => Object.assign({}, params, { type: 'arc' })
+const arc = (params) => Object.assign({}, params, { type: 'arc' })
 
 module.exports = arc

package/core/modeling/primitives/cuboid.js

@@ -1,5 +1,5 @@
-const cuboid = params => Object.assign({}, params, { type: 'cuboid' })
+const cuboid = (params) => Object.assign({}, params, { type: 'cuboid' })
 
-const cube = params => Object.assign({}, params, { type: 'cube' })
+const cube = (params) => Object.assign({}, params, { type: 'cube' })
 
 module.exports = { cuboid, cube }

package/core/modeling/primitives/cylinderElliptic.js

@@ -1,5 +1,5 @@
-const cylinder = params => Object.assign({}, params, { type: 'cylinder' })
+const cylinder = (params) => Object.assign({}, params, { type: 'cylinder' })
 
-const cylinderElliptic = params => Object.assign({}, params, { type: 'cylinderElliptic' })
+const cylinderElliptic = (params) => Object.assign({}, params, { type: 'cylinderElliptic' })
 
 module.exports = { cylinder, cylinderElliptic }

package/core/modeling/primitives/line.js

@@ -1,3 +1,3 @@
-const line = params => Object.assign({}, params, { type: 'line' })
+const line = (params) => Object.assign({}, params, { type: 'line' })
 
 module.exports = line

package/core/modeling/primitives/rectangle.js

@@ -1,4 +1,4 @@
-const rectangle = params => Object.assign({}, params, { type: 'rectangle' })
+const rectangle = (params) => Object.assign({}, params, { type: 'rectangle' })
 
 const square = (params) => Object.assign({}, params, { type: 'square' })
 

package/core/objectUtils.js

@@ -1,7 +1,5 @@
-const omit = (obj, blacklist) => {
-  return Object.keys(obj)
-    .filter((key) => blacklist.indexOf(key) < 0)
-    .reduce((newObj, key) => Object.assign(newObj, { [key]: obj[key] }), {})
-}
+const omit = (obj, blacklist) => Object.keys(obj)
+  .filter((key) => blacklist.indexOf(key) < 0)
+  .reduce((newObj, key) => Object.assign(newObj, { [key]: obj[key] }), {})
 
 module.exports = { omit }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/vtree",
-  "version": "2.0.14",
+  "version": "2.0.18",
   "description": "Experimental Object Caching for JSCAD",
   "main": "index.js",
   "scripts": {
@@ -18,17 +18,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@jscad/array-utils": "2.1.1",
-    "@jscad/modeling": "2.7.2",
+    "@jscad/array-utils": "2.1.3",
+    "@jscad/modeling": "2.9.2",
     "object-hash": "2.0.3"
   },
   "devDependencies": {
-    "@jscad/io-utils": "2.0.13",
-    "@jscad/stl-serializer": "2.1.3",
+    "@jscad/io-utils": "2.0.17",
+    "@jscad/stl-serializer": "2.1.7",
     "decache": "4.4.0",
     "just-diff": "2.1.1",
     "serialize-to-js": "3.0.2",
     "simple-diff": "1.6.0"
   },
-  "gitHead": "b6c5675d2d9a292e0ba24896bf22d0e9dc5d4270"
+  "gitHead": "0cebde0166c104e3c08cc05d2c03d9defc7eca26"
 }

package/prototyping/examples/basic-base.js

@@ -1,7 +1,5 @@
 const { cube } = require('@jscad/csg/api').primitives3d
 
-function main () {
-  return cube()
-}
+const main = () => cube()
 
 module.exports = main

package/prototyping/examples/basic-vtree.js

@@ -1,7 +1,5 @@
-const { cube, sphere, difference, intersection, union } = require('../../core/index')
+const { cube } = require('../../core/index')
 
-function main () {
-  return cube()
-}
+const main = () => cube()
 
 module.exports = main

package/prototyping/examples/caching-shape-measurements.js

@@ -1,10 +1,10 @@
 const {
   cube, sphere,
-  difference, intersection, union,
-  scale, rotate, translate, measureArea, measureVolume, measureBounds
+  union,
+  measureArea, measureVolume, measureBounds
 } = require('../../core/index')
 
-function main () {
+const main = () => {
   const someCube = cube()
   const someSphere = sphere({ r: 20, fn: 100 })
   const shapesSize = measureArea(union(someCube, someSphere)) * 0.1

package/prototyping/examples/caching-test-vanilla-changed.js

@@ -1,25 +1,22 @@
 const { cube, sphere } = require('@jscad/csg/api').primitives3d
-const { union, difference, intersection } = require('@jscad/csg/api').booleanOps
-const { translate, rotate, scale } = require('@jscad/csg/api').transformations
+const { union } = require('@jscad/csg/api').booleanOps
+const { translate, rotate } = require('@jscad/csg/api').transformations
 
-function foo () {
-  return [
-    cube(),
-    translate([13, 0, 0], cube()),
-    sphere({ fn: 128 })
-  ]
-}
-function main () {
-  return [
-    foo(),
-    cube(),
-    translate([13, 0, 0], cube()),
-    translate([0, 0, 2], sphere()),
-    union(cube(), sphere()),
-    translate([23, 0, 0], cube()),
-    rotate([13, 0, 0], cube()),
-    sphere({ fn: 128 })
-  ]
-}
+const foo = () => [
+  cube(),
+  translate([13, 0, 0], cube()),
+  sphere({ fn: 128 })
+]
+
+const main = () => [
+  foo(),
+  cube(),
+  translate([13, 0, 0], cube()),
+  translate([0, 0, 2], sphere()),
+  union(cube(), sphere()),
+  translate([23, 0, 0], cube()),
+  rotate([13, 0, 0], cube()),
+  sphere({ fn: 128 })
+]
 
 module.exports = main

package/prototyping/examples/caching-test-vanilla-changed2.js

@@ -1,23 +1,20 @@
 const { cube, sphere } = require('@jscad/csg/api').primitives3d
-const { union, difference, intersection } = require('@jscad/csg/api').booleanOps
-const { translate, rotate, scale } = require('@jscad/csg/api').transformations
+const { union } = require('@jscad/csg/api').booleanOps
+const { translate, rotate } = require('@jscad/csg/api').transformations
 
-function foo () {
-  return [
-    cube(),
-    translate([13, 0, 0], cube())
-  ]
-}
-function main () {
-  return [
-    foo(),
-    cube(),
-    translate([13, 0, 0], cube()),
-    translate([0, 0, 2], sphere()),
-    union(cube(), sphere()),
-    translate([23, 0, 0], cube()),
-    rotate([13, 0, 0], cube())
-  ]
-}
+const foo = () => [
+  cube(),
+  translate([13, 0, 0], cube())
+]
+
+const main = () => [
+  foo(),
+  cube(),
+  translate([13, 0, 0], cube()),
+  translate([0, 0, 2], sphere()),
+  union(cube(), sphere()),
+  translate([23, 0, 0], cube()),
+  rotate([13, 0, 0], cube())
+]
 
 module.exports = main