@jscad/modeling 2.5.2 → 2.7.0

package/src/maths/plane/fromPoints.test.js

@@ -13,4 +13,8 @@ test('plane: fromPoints() should return a new plane with correct values', (t) =>
   // planes created from the same points results in an invalid plane
   const obs3 = fromPoints(obs1, [0, 6, 0], [0, 6, 0], [0, 6, 0])
   t.true(compareVectors(obs3, [0 / 0, 0 / 0, 0 / 0, 0 / 0]))
+
+  // polygon with co-linear vertices
+  const obs4 = fromPoints(obs1, [0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0])
+  t.true(compareVectors(obs4, [0, 0, 1, 0]))
 })

package/src/maths/utils/index.d.ts

@@ -1,6 +1,5 @@
 export { default as aboutEqualNormals } from './aboutEqualNormals'
 export { default as area } from './area'
-export { default as clamp } from './clamp'
 export { default as interpolateBetween2DPointsForY } from './interpolateBetween2DPointsForY'
 export { default as intersect } from './intersect'
 export { default as solve2Linear } from './solve2Linear'

package/src/maths/utils/index.js

@@ -7,7 +7,6 @@
 module.exports = {
   aboutEqualNormals: require('./aboutEqualNormals'),
   area: require('./area'),
-  clamp: require('./clamp'),
   interpolateBetween2DPointsForY: require('./interpolateBetween2DPointsForY'),
   intersect: require('./intersect'),
   solve2Linear: require('./solve2Linear')

package/src/maths/vec2/rotate.js

@@ -10,7 +10,7 @@
  */
 const rotate = (out, vector, origin, radians) => {
   const x = vector[0] - origin[0]
-  const y = vector[1] - origin[0]
+  const y = vector[1] - origin[1]
   const c = Math.cos(radians)
   const s = Math.sin(radians)
 

package/src/maths/vec2/rotate.test.js

@@ -22,7 +22,7 @@ test('vec2: rotate() called with three paramerters should update a vec2 with cor
   t.true(compareVectors(ret3, [2, -1], 1e-15))
 
   const obs4 = fromValues(0, 0)
-  const ret4 = rotate(obs4, [-1, 2], [0, 0], -radians)
-  t.true(compareVectors(obs4, [2, 1], 1e-15))
-  t.true(compareVectors(ret4, [2, 1], 1e-15))
+  const ret4 = rotate(obs4, [-1, 2], [-3, -3], -radians)
+  t.true(compareVectors(obs4, [2, -5], 1e-15))
+  t.true(compareVectors(ret4, [2, -5], 1e-15))
 })

package/src/measurements/index.js

@@ -1,6 +1,5 @@
 /**
  * All shapes (primitives or the results of operations) can be measured, e.g. calculate volume, etc.
- * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/measurements
  * @example
  * const { measureArea, measureBoundingBox, measureVolume } = require('@jscad/modeling').measurements
@@ -12,6 +11,10 @@ module.exports = {
   measureAggregateVolume: require('./measureAggregateVolume'),
   measureArea: require('./measureArea'),
   measureBoundingBox: require('./measureBoundingBox'),
+  measureBoundingSphere: require('./measureBoundingSphere'),
+  measureCenter: require('./measureCenter'),
+  measureCenterOfMass: require('./measureCenterOfMass'),
+  measureDimensions: require('./measureDimensions'),
   measureEpsilon: require('./measureEpsilon'),
   measureVolume: require('./measureVolume')
 }

package/src/measurements/measureBoundingBox.js

@@ -2,6 +2,7 @@ const flatten = require('../utils/flatten')
 
 const vec2 = require('../maths/vec2')
 const vec3 = require('../maths/vec3')
+const mat4 = require('../maths/mat4')
 
 const geom2 = require('../geometries/geom2')
 const geom3 = require('../geometries/geom3')
@@ -11,86 +12,129 @@ const poly3 = require('../geometries/poly3')
 const cache = new WeakMap()
 
 /*
- * Measure the min and max bounds of the given (path2) geometry.
- * @return {Array[]} the min and max bounds for the geometry
+ * Measure the min and max bounds of the given (path2) geometry.points.
+ * @return {Array[]} the min and max bounds for the geometry.points
  */
-const measureBoundingBoxOfPath2 = (geometry) => {
-  let boundingBox = cache.get(geometry)
+const measureBoundingBoxOfPath2Points = (points) => {
+  let boundingBox = cache.get(points)
   if (boundingBox) return boundingBox
 
-  const points = path2.toPoints(geometry)
-
   let minpoint
   if (points.length === 0) {
     minpoint = vec2.create()
   } else {
     minpoint = vec2.clone(points[0])
   }
-  let maxpoint = vec2.clone(minpoint)
+  const maxpoint = vec2.clone(minpoint)
 
   points.forEach((point) => {
     vec2.min(minpoint, minpoint, point)
     vec2.max(maxpoint, maxpoint, point)
   })
-  minpoint = [minpoint[0], minpoint[1], 0]
-  maxpoint = [maxpoint[0], maxpoint[1], 0]
-
-  boundingBox = [minpoint, maxpoint]
-
-  cache.set(geometry, boundingBox)
+  boundingBox = [[minpoint[0], minpoint[1], 0], [maxpoint[0], maxpoint[1], 0]]
 
+  cache.set(points, boundingBox)
   return boundingBox
 }
 
 /*
- * Measure the min and max bounds of the given (geom2) geometry.
+ * Measure the min and max bounds of the given (path2) geometry.
  * @return {Array[]} the min and max bounds for the geometry
  */
-const measureBoundingBoxOfGeom2 = (geometry) => {
+const measureBoundingBoxOfPath2 = (geometry) => {
   let boundingBox = cache.get(geometry)
   if (boundingBox) return boundingBox
 
-  const points = geom2.toPoints(geometry)
-
-  let minpoint
-  if (points.length === 0) {
-    minpoint = vec2.create()
+  if (mat4.isOnlyTransformScale(geometry.transforms)) {
+    // get boundingBox of original points and transform it
+    boundingBox = transformBoundingBox(measureBoundingBoxOfPath2Points(geometry.points), geometry.transforms)
   } else {
-    minpoint = vec2.clone(points[0])
+    // transform the points and then caclulate the boundingBox
+    boundingBox = measureBoundingBoxOfPath2Points(path2.toPoints(geometry))
   }
-  let maxpoint = vec2.clone(minpoint)
 
-  points.forEach((point) => {
-    vec2.min(minpoint, minpoint, point)
-    vec2.max(maxpoint, maxpoint, point)
-  })
+  cache.set(geometry, boundingBox)
+  return boundingBox
+}
 
-  minpoint = [minpoint[0], minpoint[1], 0]
-  maxpoint = [maxpoint[0], maxpoint[1], 0]
+/*
+ * Measure the min and max bounds of the given (geom2) geometry.points/sides.
+ * @return {Array[]} the min and max bounds for the geometr.points/sidesy
+ */
+const measureBoundingBoxOfGeom2Points = ({ points, sides }) => {
+  const cacheKey = points || sides
 
-  boundingBox = [minpoint, maxpoint]
+  let boundingBox = cache.get(cacheKey)
+  if (boundingBox) return boundingBox
 
-  cache.set(geometry, boundingBox)
+  let minpoint, maxpoint
+
+  if (points) {
+    if (points.length === 0) {
+      minpoint = vec2.create()
+    } else {
+      minpoint = vec2.clone(points[0])
+    }
+    maxpoint = vec2.clone(minpoint)
+
+    points.forEach((point) => {
+      vec2.min(minpoint, minpoint, point)
+      vec2.max(maxpoint, maxpoint, point)
+    })
+  } else { // sides
+    // to avoid calling costly toPoints, we take advantage of the knowlege how the toPoints works
+    if (sides.length === 0) {
+      minpoint = vec2.create()
+    } else {
+      minpoint = vec2.clone(sides[0][0])
+    }
+    maxpoint = vec2.clone(minpoint)
+
+    sides.forEach((side) => {
+      vec2.min(minpoint, minpoint, side[0])
+      vec2.max(maxpoint, maxpoint, side[0])
+    })
+  }
+  boundingBox = [[minpoint[0], minpoint[1], 0], [maxpoint[0], maxpoint[1], 0]]
 
+  cache.set(cacheKey, boundingBox)
   return boundingBox
 }
 
 /*
- * Measure the min and max bounds of the given (geom3) geometry.
+ * Measure the min and max bounds of the given (geom2) geometry.
  * @return {Array[]} the min and max bounds for the geometry
  */
-const measureBoundingBoxOfGeom3 = (geometry) => {
+const measureBoundingBoxOfGeom2 = (geometry) => {
   let boundingBox = cache.get(geometry)
   if (boundingBox) return boundingBox
 
-  const polygons = geom3.toPolygons(geometry)
+  if (mat4.isOnlyTransformScale(geometry.transforms)) {
+    // get boundingBox of original points and transform it
+    boundingBox = transformBoundingBox(measureBoundingBoxOfGeom2Points(geometry), geometry.transforms)
+  } else {
+    // transform the points and then caclulate the boundingBox
+    boundingBox = measureBoundingBoxOfGeom2Points({ points: geom2.toPoints(geometry) })
+  }
+
+  cache.set(geometry, boundingBox)
+  return boundingBox
+}
+
+/*
+ * Measure the min and max bounds of the given (geom3) geometry.polygons.
+ * @return {Array[]} the min and max bounds for the geometry.polygons
+ */
+const measureBoundingBoxOfGeom3Polygons = (polygons) => {
+  let boundingBox = cache.get(polygons)
+  if (boundingBox) return boundingBox
 
-  let minpoint = vec3.create()
+  const minpoint = vec3.create()
   if (polygons.length > 0) {
     const points = poly3.toPoints(polygons[0])
     vec3.copy(minpoint, points[0])
   }
-  let maxpoint = vec3.clone(minpoint)
+  const maxpoint = vec3.clone(minpoint)
 
   polygons.forEach((polygon) => {
     poly3.toPoints(polygon).forEach((point) => {
@@ -99,13 +143,59 @@ const measureBoundingBoxOfGeom3 = (geometry) => {
     })
   })
 
-  minpoint = [minpoint[0], minpoint[1], minpoint[2]]
-  maxpoint = [maxpoint[0], maxpoint[1], maxpoint[2]]
+  boundingBox = [[minpoint[0], minpoint[1], minpoint[2]], [maxpoint[0], maxpoint[1], maxpoint[2]]]
 
-  boundingBox = [minpoint, maxpoint]
+  cache.set(polygons, boundingBox)
+  return boundingBox
+}
+
+/*
+ * Measure the min and max bounds of the given (geom3) geometry.
+ * @return {Array[]} the min and max bounds for the geometry
+ */
+const measureBoundingBoxOfGeom3 = (geometry) => {
+  let boundingBox = cache.get(geometry)
+  if (boundingBox) return boundingBox
+
+  if (mat4.isOnlyTransformScale(geometry.transforms)) {
+    // get boundingBox of original points and transform it
+    boundingBox = transformBoundingBox(measureBoundingBoxOfGeom3Polygons(geometry.polygons), geometry.transforms)
+  } else {
+    // transform the points and then caclulate the boundingBox
+    boundingBox = measureBoundingBoxOfGeom3Polygons(geom3.toPolygons(geometry))
+  }
 
   cache.set(geometry, boundingBox)
+  return boundingBox
+}
 
+/*
+ * swap values if specific axis value in the second vector has lower value than the axis value in first vector
+ */
+const fixBound = (i, v1, v2) => {
+  if (v1[i] > v2[i]) {
+    const tmp = v1[i]
+    v1[i] = v2[i]
+    v2[i] = tmp
+  }
+}
+
+/*
+ * Transform the given bounding box
+ */
+const transformBoundingBox = (boundingBox, transforms) => {
+  if (!mat4.isIdentity(transforms)) {
+    vec3.transform(boundingBox[0], boundingBox[0], transforms)
+    vec3.transform(boundingBox[1], boundingBox[1], transforms)
+
+    // we now have a new 2 vectors:  [v1,v2] => [ [x1,y1,z1],  [x2,y2,z2] ]
+    // transform can move bounding box corner in such way that it is no longer true that
+    //  - v1 = [min(x1,x2),min(y1,y2),min(z1,z2)]
+    //  - v2 = [max(x1,x2),max(y1,y2),max(z1,z2)]
+    fixBound(0, ...boundingBox) // swap x, if higher value is in first vector
+    fixBound(1, ...boundingBox) // swap y, if higher value is in first vector
+    fixBound(2, ...boundingBox) // swap z, if higher value is in first vector
+  }
   return boundingBox
 }
 

package/src/measurements/measureBoundingBox.test.js

@@ -4,6 +4,8 @@ const { geom2, geom3, path2 } = require('../geometries')
 
 const { line, rectangle, cuboid } = require('../primitives')
 
+const { mirror } = require('../operations/transforms')
+
 const { measureBoundingBox } = require('./index')
 
 test('measureBoundingBox (single objects)', (t) => {
@@ -56,3 +58,9 @@ test('measureBoundingBox (multiple objects)', (t) => {
   allbounds = measureBoundingBox(aline, arect, acube, o)
   t.deepEqual(allbounds, [[[10, 10, 0], [15, 15, 0]], [[-5, -10, 0], [5, 10, 0]], [[-1, -1, -1], [1, 1, 1]], [[0, 0, 0], [0, 0, 0]]])
 })
+
+test('measureBoundingBox invert', (t) => {
+  const acube = mirror({}, cuboid())
+  const cbounds = measureBoundingBox(acube)
+  t.deepEqual(cbounds, [[-1, -1, -1], [1, 1, 1]])
+})

package/src/measurements/measureBoundingSphere.js

@@ -0,0 +1,146 @@
+const flatten = require('../utils/flatten')
+
+const vec2 = require('../maths/vec2')
+const vec3 = require('../maths/vec3')
+
+const geom2 = require('../geometries/geom2')
+const geom3 = require('../geometries/geom3')
+const path2 = require('../geometries/path2')
+const poly3 = require('../geometries/poly3')
+
+const cacheOfBoundingSpheres = new WeakMap()
+
+/*
+ * Measure the bounding sphere of the given (path2) geometry.
+ * @return {[[x, y, z], radius]} the bounding sphere for the geometry
+ */
+const measureBoundingSphereOfPath2 = (geometry) => {
+  let boundingSphere = cacheOfBoundingSpheres.get(geometry)
+  if (boundingSphere !== undefined) return boundingSphere
+
+  const centroid = vec3.create()
+  let radius = 0
+
+  const points = path2.toPoints(geometry)
+
+  if (points.length > 0) {
+    // calculate the centriod of the geometry
+    let numPoints = 0
+    const temp = vec3.create()
+    points.forEach((point) => {
+      vec3.add(centroid, centroid, vec3.fromVec2(temp, point, 0))
+      numPoints++
+    })
+    vec3.scale(centroid, centroid, 1 / numPoints)
+
+    // find the farthest point from the centroid
+    points.forEach((point) => {
+      radius = Math.max(radius, vec2.squaredDistance(centroid, point))
+    })
+    radius = Math.sqrt(radius)
+  }
+
+  boundingSphere = [centroid, radius]
+  cacheOfBoundingSpheres.set(geometry, boundingSphere)
+
+  return boundingSphere
+}
+
+/*
+ * Measure the bounding sphere of the given (geom2) geometry.
+ * @return {[[x, y, z], radius]} the bounding sphere for the geometry
+ */
+const measureBoundingSphereOfGeom2 = (geometry) => {
+  let boundingSphere = cacheOfBoundingSpheres.get(geometry)
+  if (boundingSphere !== undefined) return boundingSphere
+
+  const centroid = vec3.create()
+  let radius = 0
+
+  const sides = geom2.toSides(geometry)
+
+  if (sides.length > 0) {
+    // calculate the centriod of the geometry
+    let numPoints = 0
+    const temp = vec3.create()
+    sides.forEach((side) => {
+      vec3.add(centroid, centroid, vec3.fromVec2(temp, side[0], 0))
+      numPoints++
+    })
+    vec3.scale(centroid, centroid, 1 / numPoints)
+
+    // find the farthest point from the centroid
+    sides.forEach((side) => {
+      radius = Math.max(radius, vec2.squaredDistance(centroid, side[0]))
+    })
+    radius = Math.sqrt(radius)
+  }
+
+  boundingSphere = [centroid, radius]
+  cacheOfBoundingSpheres.set(geometry, boundingSphere)
+
+  return boundingSphere
+}
+
+/*
+ * Measure the bounding sphere of the given (geom3) geometry.
+ * @return {[[x, y, z], radius]} the bounding sphere for the geometry
+ */
+const measureBoundingSphereOfGeom3 = (geometry) => {
+  let boundingSphere = cacheOfBoundingSpheres.get(geometry)
+  if (boundingSphere !== undefined) return boundingSphere
+
+  const centroid = vec3.create()
+  let radius = 0
+
+  const polygons = geom3.toPolygons(geometry)
+
+  if (polygons.length > 0) {
+    // calculate the centriod of the geometry
+    let numPoints = 0
+    polygons.forEach((polygon) => {
+      poly3.toPoints(polygon).forEach((point) => {
+        vec3.add(centroid, centroid, point)
+        numPoints++
+      })
+    })
+    vec3.scale(centroid, centroid, 1 / numPoints)
+
+    // find the farthest point from the centroid
+    polygons.forEach((polygon) => {
+      poly3.toPoints(polygon).forEach((point) => {
+        radius = Math.max(radius, vec3.squaredDistance(centroid, point))
+      })
+    })
+    radius = Math.sqrt(radius)
+  }
+
+  boundingSphere = [centroid, radius]
+  cacheOfBoundingSpheres.set(geometry, boundingSphere)
+
+  return boundingSphere
+}
+
+/**
+ * Measure the (aproximate) bounding sphere of the given geometries.
+ * @see https://en.wikipedia.org/wiki/Bounding_sphere
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Array} the bounding sphere for each geometry, i.e. [centroid, radius]
+ * @alias module:modeling/measurements.measureBoundingSphere
+ *
+ * @example
+ * let bounds = measureBoundingSphere(cube())
+ */
+const measureBoundingSphere = (...geometries) => {
+  geometries = flatten(geometries)
+
+  const results = geometries.map((geometry) => {
+    if (path2.isA(geometry)) return measureBoundingSphereOfPath2(geometry)
+    if (geom2.isA(geometry)) return measureBoundingSphereOfGeom2(geometry)
+    if (geom3.isA(geometry)) return measureBoundingSphereOfGeom3(geometry)
+    return [[0, 0, 0], 0]
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureBoundingSphere

package/src/measurements/measureBoundingSphere.test.js

@@ -0,0 +1,59 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../geometries')
+
+const { line, rectangle, ellipsoid } = require('../primitives')
+
+const { measureBoundingSphere } = require('./index')
+
+test('measureBoundingSphere (single objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle()
+  const aellipsoid = ellipsoid({ radius: [5, 10, 15], center: [5, 5, 5] })
+
+  const apath2 = path2.create()
+  const ageom2 = geom2.create()
+  const ageom3 = geom3.create()
+
+  const n = null
+  const o = {}
+  const x = 'hi'
+
+  const lbounds = measureBoundingSphere(aline)
+  const rbounds = measureBoundingSphere(arect)
+  const cbounds = measureBoundingSphere(aellipsoid)
+
+  const p2bounds = measureBoundingSphere(apath2)
+  const g2bounds = measureBoundingSphere(ageom2)
+  const g3bounds = measureBoundingSphere(ageom3)
+
+  const nbounds = measureBoundingSphere(n)
+  const obounds = measureBoundingSphere(o)
+  const xbounds = measureBoundingSphere(x)
+
+  t.deepEqual(lbounds, [[12.5, 12.5, 0], 3.5355339059327378])
+  t.deepEqual(rbounds, [[0, 0, 0], 1.4142135623730951])
+  t.deepEqual(cbounds, [[5.000000000000018, 4.999999999999983, 5.000000000000001], 15])
+
+  t.deepEqual(p2bounds, [[0, 0, 0], 0])
+  t.deepEqual(g2bounds, [[0, 0, 0], 0])
+  t.deepEqual(g3bounds, [[0, 0, 0], 0])
+
+  t.deepEqual(nbounds, [[0, 0, 0], 0])
+  t.deepEqual(obounds, [[0, 0, 0], 0])
+  t.deepEqual(xbounds, [[0, 0, 0], 0])
+})
+
+test('measureBoundingSphere (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle()
+  const aellipsoid = ellipsoid({ radius: [5, 10, 15], center: [5, 5, 5] })
+  const o = {}
+
+  let allbounds = measureBoundingSphere(aline, arect, aellipsoid, o)
+  t.deepEqual(allbounds, [[[12.5, 12.5, 0], 3.5355339059327378], [[0, 0, 0], 1.4142135623730951], [[5.000000000000018, 4.999999999999983, 5.000000000000001], 15], [[0, 0, 0], 0]])
+
+  // test caching
+  allbounds = measureBoundingSphere(aline, arect, aellipsoid, o)
+  t.deepEqual(allbounds, [[[12.5, 12.5, 0], 3.5355339059327378], [[0, 0, 0], 1.4142135623730951], [[5.000000000000018, 4.999999999999983, 5.000000000000001], 15], [[0, 0, 0], 0]])
+})

package/src/measurements/measureCenter.js

@@ -0,0 +1,28 @@
+const flatten = require('../utils/flatten')
+
+const measureBoundingBox = require('./measureBoundingBox')
+
+/**
+ * Measure the center of the given geometries.
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Array} the center point for each geometry, i.e. [X, Y, Z]
+ * @alias module:modeling/measurements.measureCenter
+ *
+ * @example
+ * let center = measureCenter(sphere())
+ */
+const measureCenter = (...geometries) => {
+  geometries = flatten(geometries)
+
+  const results = geometries.map((geometry) => {
+    const bounds = measureBoundingBox(geometry)
+    return [
+      (bounds[0][0] + ((bounds[1][0] - bounds[0][0]) / 2)),
+      (bounds[0][1] + ((bounds[1][1] - bounds[0][1]) / 2)),
+      (bounds[0][2] + ((bounds[1][2] - bounds[0][2]) / 2))
+    ]
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureCenter

package/src/measurements/measureCenter.test.js

@@ -0,0 +1,58 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../geometries')
+
+const { line, rectangle, cuboid } = require('../primitives')
+
+const { measureCenter } = require('./index')
+
+test('measureCenter (single objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ center: [5, 5] })
+  const acube = cuboid({ center: [-5, -5, -5] })
+
+  const apath2 = path2.create()
+  const ageom2 = geom2.create()
+  const ageom3 = geom3.create()
+
+  const n = null
+  const o = {}
+  const x = 'hi'
+
+  const lcenter = measureCenter(aline)
+  const rcenter = measureCenter(arect)
+  const ccenter = measureCenter(acube)
+
+  const p2center = measureCenter(apath2)
+  const g2center = measureCenter(ageom2)
+  const g3center = measureCenter(ageom3)
+
+  const ncenter = measureCenter(n)
+  const ocenter = measureCenter(o)
+  const xcenter = measureCenter(x)
+
+  t.deepEqual(lcenter, [12.5, 12.5, 0])
+  t.deepEqual(rcenter, [5, 5, 0])
+  t.deepEqual(ccenter, [-5, -5, -5])
+
+  t.deepEqual(p2center, [0, 0, 0])
+  t.deepEqual(g2center, [0, 0, 0])
+  t.deepEqual(g3center, [0, 0, 0])
+
+  t.deepEqual(ncenter, [0, 0, 0])
+  t.deepEqual(ocenter, [0, 0, 0])
+  t.deepEqual(xcenter, [0, 0, 0])
+})
+
+test('measureCenter (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ size: [10, 20] })
+  const acube = cuboid({ center: [-5, -5, -5] })
+  const o = {}
+
+  let allcenters = measureCenter(aline, arect, acube, o)
+  t.deepEqual(allcenters, [[12.5, 12.5, 0], [0, 0, 0], [-5, -5, -5], [0, 0, 0]])
+
+  allcenters = measureCenter(aline, arect, acube, o)
+  t.deepEqual(allcenters, [[12.5, 12.5, 0], [0, 0, 0], [-5, -5, -5], [0, 0, 0]])
+})