@jscad/modeling 2.12.2 → 2.12.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.12.2",
+  "version": "2.12.4",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -61,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "5fbb5fea458c28b0d96450dde9231e1d4d8ce6a4"
+  "gitHead": "ce4978ee40c30803cba05d1c96ba8b6aaf3abc61"
 }

package/src/geometries/geom3/fromPointsConvex.test.js

@@ -3,24 +3,29 @@ const test = require('ava')
 const { fromPointsConvex, validate } = require('./index')
 
 test('fromPointsConvex (uniquePoints)', (t) => {
-  let out = []
-  for(x=-9;x<=9;++x)
-    for(y=-9;y<=9;++y)
-     for(z=-9;z<=9;++z)
-        if (x*x+y*y+z*z <= 96)
-          out.push([x,y,z])
+  const out = []
+  for (let x = -9; x <= 9; ++x) {
+    for (let y = -9; y <= 9; ++y) {
+      for (let z = -9; z <= 9; ++z) {
+        if (x * x + y * y + z * z <= 96) out.push([x, y, z])
+      }
+    }
+  }
 
-  let obs = fromPointsConvex(out)
+  const obs = fromPointsConvex(out)
   validate(obs)
+
   t.is(obs.polygons.length, 170)
-  t.true(obs.polygons.every((f) => ([3,4,8,9].indexOf(f.vertices.length) !== -1)))
-  let c = [0,0,0,0,0,0,0,0,0,0]
+  t.true(obs.polygons.every((f) => ([3, 4, 8, 9].indexOf(f.vertices.length) !== -1)))
+
+  const c = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
   obs.polygons.forEach((f) => c[f.vertices.length]++)
-  t.is(c[3], 120);
-  t.is(c[4], 24);
-  t.is(c[8], 18);
-  t.is(c[9], 8);
-  let edges2 = 336*2
+  t.is(c[3], 120)
+  t.is(c[4], 24)
+  t.is(c[8], 18)
+  t.is(c[9], 8)
+
+  let edges2 = 336 * 2
   obs.polygons.forEach((f) => edges2 -= f.vertices.length)
-  t.is(edges2, 0);
+  t.is(edges2, 0)
 })

package/src/geometries/poly3/type.d.ts

@@ -1,3 +1,4 @@
+import Plane from '../../maths/plane/type'
 import Vec3 from '../../maths/vec3/type'
 import { Color } from '../types'
 
@@ -6,4 +7,5 @@ export default Poly3
 declare interface Poly3 {
   vertices: Array<Vec3>
   color?: Color
+  plane?: Plane
 }

package/src/maths/OrthoNormalBasis.js

@@ -21,128 +21,6 @@ const OrthoNormalBasis = function (plane, rightvector) {
   this.planeorigin = vec3.scale(vec3.create(), plane, plane[3])
 }
 
-// Get an orthonormal basis for the standard XYZ planes.
-// Parameters: the names of two 3D axes. The 2d x axis will map to the first given 3D axis, the 2d y
-// axis will map to the second.
-// Prepend the axis with a "-" to invert the direction of this axis.
-// For example: OrthoNormalBasis.GetCartesian("-Y","Z")
-//   will return an orthonormal basis where the 2d X axis maps to the 3D inverted Y axis, and
-//   the 2d Y axis maps to the 3D Z axis.
-OrthoNormalBasis.GetCartesian = function (xaxisid, yaxisid) {
-  const axisid = xaxisid + '/' + yaxisid
-  let planenormal, rightvector
-  if (axisid === 'X/Y') {
-    planenormal = [0, 0, 1]
-    rightvector = [1, 0, 0]
-  } else if (axisid === 'Y/-X') {
-    planenormal = [0, 0, 1]
-    rightvector = [0, 1, 0]
-  } else if (axisid === '-X/-Y') {
-    planenormal = [0, 0, 1]
-    rightvector = [-1, 0, 0]
-  } else if (axisid === '-Y/X') {
-    planenormal = [0, 0, 1]
-    rightvector = [0, -1, 0]
-  } else if (axisid === '-X/Y') {
-    planenormal = [0, 0, -1]
-    rightvector = [-1, 0, 0]
-  } else if (axisid === '-Y/-X') {
-    planenormal = [0, 0, -1]
-    rightvector = [0, -1, 0]
-  } else if (axisid === 'X/-Y') {
-    planenormal = [0, 0, -1]
-    rightvector = [1, 0, 0]
-  } else if (axisid === 'Y/X') {
-    planenormal = [0, 0, -1]
-    rightvector = [0, 1, 0]
-  } else if (axisid === 'X/Z') {
-    planenormal = [0, -1, 0]
-    rightvector = [1, 0, 0]
-  } else if (axisid === 'Z/-X') {
-    planenormal = [0, -1, 0]
-    rightvector = [0, 0, 1]
-  } else if (axisid === '-X/-Z') {
-    planenormal = [0, -1, 0]
-    rightvector = [-1, 0, 0]
-  } else if (axisid === '-Z/X') {
-    planenormal = [0, -1, 0]
-    rightvector = [0, 0, -1]
-  } else if (axisid === '-X/Z') {
-    planenormal = [0, 1, 0]
-    rightvector = [-1, 0, 0]
-  } else if (axisid === '-Z/-X') {
-    planenormal = [0, 1, 0]
-    rightvector = [0, 0, -1]
-  } else if (axisid === 'X/-Z') {
-    planenormal = [0, 1, 0]
-    rightvector = [1, 0, 0]
-  } else if (axisid === 'Z/X') {
-    planenormal = [0, 1, 0]
-    rightvector = [0, 0, 1]
-  } else if (axisid === 'Y/Z') {
-    planenormal = [1, 0, 0]
-    rightvector = [0, 1, 0]
-  } else if (axisid === 'Z/-Y') {
-    planenormal = [1, 0, 0]
-    rightvector = [0, 0, 1]
-  } else if (axisid === '-Y/-Z') {
-    planenormal = [1, 0, 0]
-    rightvector = [0, -1, 0]
-  } else if (axisid === '-Z/Y') {
-    planenormal = [1, 0, 0]
-    rightvector = [0, 0, -1]
-  } else if (axisid === '-Y/Z') {
-    planenormal = [-1, 0, 0]
-    rightvector = [0, -1, 0]
-  } else if (axisid === '-Z/-Y') {
-    planenormal = [-1, 0, 0]
-    rightvector = [0, 0, -1]
-  } else if (axisid === 'Y/-Z') {
-    planenormal = [-1, 0, 0]
-    rightvector = [0, 1, 0]
-  } else if (axisid === 'Z/Y') {
-    planenormal = [-1, 0, 0]
-    rightvector = [0, 0, 1]
-  } else {
-    throw new Error('OrthoNormalBasis.GetCartesian: invalid combination of axis identifiers. Should pass two string arguments from [X,Y,Z,-X,-Y,-Z], being two different axes.')
-  }
-  return new OrthoNormalBasis(new Plane(new Vector3D(planenormal), 0), new Vector3D(rightvector))
-}
-
-/*
-// test code for OrthoNormalBasis.GetCartesian()
-OrthoNormalBasis.GetCartesian_Test=function() {
-  let axisnames=["X","Y","Z","-X","-Y","-Z"];
-  let axisvectors=[[1,0,0], [0,1,0], [0,0,1], [-1,0,0], [0,-1,0], [0,0,-1]];
-  for(let axis1=0; axis1 < 3; axis1++) {
-    for(let axis1inverted=0; axis1inverted < 2; axis1inverted++) {
-      let axis1name=axisnames[axis1+3*axis1inverted];
-      let axis1vector=axisvectors[axis1+3*axis1inverted];
-      for(let axis2=0; axis2 < 3; axis2++) {
-        if(axis2 != axis1) {
-          for(let axis2inverted=0; axis2inverted < 2; axis2inverted++) {
-            let axis2name=axisnames[axis2+3*axis2inverted];
-            let axis2vector=axisvectors[axis2+3*axis2inverted];
-            let orthobasis=OrthoNormalBasis.GetCartesian(axis1name, axis2name);
-            let test1=orthobasis.to3D(new Vector2D([1,0]));
-            let test2=orthobasis.to3D(new Vector2D([0,1]));
-            let expected1=new Vector3D(axis1vector);
-            let expected2=new Vector3D(axis2vector);
-            let d1=test1.distanceTo(expected1);
-            let d2=test2.distanceTo(expected2);
-            if( (d1 > 0.01) || (d2 > 0.01) ) {
-              throw new Error("Wrong!");
-  }}}}}}
-  throw new Error("OK");
-};
-*/
-
-// The z=0 plane, with the 3D x and y vectors mapped to the 2D x and y vector
-OrthoNormalBasis.Z0Plane = function () {
-  const plane = new Plane(new Vector3D([0, 0, 1]), 0)
-  return new OrthoNormalBasis(plane, new Vector3D([1, 0, 0]))
-}
-
 OrthoNormalBasis.prototype = {
 
   getProjectionMatrix: function () {
@@ -175,32 +53,6 @@ OrthoNormalBasis.prototype = {
     const v3 = vec3.add(v1, v1, this.planeorigin)
     const v4 = vec3.add(v2, v2, v3)
     return v4
-  },
-
-  line3Dto2D: function (line3d) {
-    const a = line3d.point
-    const b = line3d.direction.plus(a)
-    const a2d = this.to2D(a)
-    const b2d = this.to2D(b)
-    return Line2D.fromPoints(a2d, b2d)
-  },
-
-  line2Dto3D: function (line2d) {
-    const a = line2d.origin()
-    const b = line2d.direction().plus(a)
-    const a3d = this.to3D(a)
-    const b3d = this.to3D(b)
-    return Line3D.fromPoints(a3d, b3d)
-  },
-
-  transform: function (matrix4x4) {
-    // todo: this may not work properly in case of mirroring
-    const newplane = this.plane.transform(matrix4x4)
-    const rightpointTransformed = this.u.transform(matrix4x4)
-    const originTransformed = new Vector3D(0, 0, 0).transform(matrix4x4)
-    const newrighthandvector = rightpointTransformed.minus(originTransformed)
-    const newbasis = new OrthoNormalBasis(newplane, newrighthandvector)
-    return newbasis
   }
 }
 

package/src/operations/booleans/scission.d.ts

@@ -3,5 +3,4 @@ import RecursiveArray from '../../utils/recursiveArray'
 
 export default scission
 
-declare function scission(...geometries: RecursiveArray<Geom2>): Geom2
-declare function scission(...geometries: RecursiveArray<Geom3>): Geom3
+declare function scission(...geometries: RecursiveArray<Geom3>): Geom3[]

package/src/operations/hulls/hull.test.js

@@ -2,7 +2,9 @@ const test = require('ava')
 
 const { geom2, geom3, path2 } = require('../../geometries')
 
-const { sphere, cuboid, ellipsoid } = require('../../primitives')
+const { measureVolume } = require('../../measurements')
+
+const { sphere, cuboid, ellipsoid, torus } = require('../../primitives')
 
 const { center } = require('../transforms/center')
 
@@ -274,3 +276,9 @@ test('hull (multiple, overlapping, geom3)', (t) => {
   t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 92)
 })
+
+test('hull (single, unconvex, geom3)', (t) => {
+  const geometry = torus()
+  const obs = hull(geometry)
+  t.assert(measureVolume(obs) > measureVolume(geometry))
+})

package/src/operations/hulls/hullGeom2.js

@@ -7,6 +7,9 @@ const toUniquePoints = require('./toUniquePoints')
 
 /*
  * Create a convex hull of the given geom2 geometries.
+ *
+ * NOTE: The given geometries must be valid geom2 geometries.
+ *
  * @param {...geometries} geometries - list of geom2 geometries
  * @returns {geom2} new geometry
  */

package/src/operations/hulls/hullGeom3.js

@@ -1,32 +1,27 @@
 const flatten = require('../../utils/flatten')
 
 const geom3 = require('../../geometries/geom3')
-const poly3 = require('../../geometries/poly3')
 
-const quickhull = require('./quickhull')
 const toUniquePoints = require('./toUniquePoints')
+const hullPoints3 = require('./hullPoints3')
 
 /*
- * Create a convex hull of the given geometries (geom3).
+ * Create a convex hull of the given geom3 geometries.
+ *
+ * NOTE: The given geometries must be valid geom3 geometries.
+ *
  * @param {...geometries} geometries - list of geom3 geometries
  * @returns {geom3} new geometry
  */
 const hullGeom3 = (...geometries) => {
   geometries = flatten(geometries)
 
-  if (geometries.length === 1) return geometries[0]
-
   // extract the unique vertices from the geometries
   const unique = toUniquePoints(geometries)
 
-  const faces = quickhull(unique, { skipTriangulation: true })
-
-  const polygons = faces.map((face) => {
-    const vertices = face.map((index) => unique[index])
-    return poly3.create(vertices)
-  })
+  if (unique.length === 0) return geom3.create()
 
-  return geom3.create(polygons)
+  return geom3.create(hullPoints3(unique))
 }
 
 module.exports = hullGeom3

package/src/operations/hulls/hullPath2.js

@@ -6,7 +6,10 @@ const hullPoints2 = require('./hullPoints2')
 const toUniquePoints = require('./toUniquePoints')
 
 /*
- * Create a convex hull of the given geometries (path2).
+ * Create a convex hull of the given path2 geometries.
+ *
+ * NOTE: The given geometries must be valid path2 geometry.
+ *
  * @param {...geometries} geometries - list of path2 geometries
  * @returns {path2} new geometry
  */

package/src/operations/hulls/hullPoints2.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from '../../maths/vec2/type'
+
+export default hullPoints2
+
+declare function hullPoints2(uniquePoints: Array<Vec2>): Array<Vec2>

package/src/operations/hulls/hullPoints2.js

@@ -1,10 +1,12 @@
 const vec2 = require('../../maths/vec2')
 
-/*
+/**
  * Create a convex hull of the given set of points, where each point is an array of [x,y].
- * Uses https://en.wikipedia.org/wiki/Graham_scan
+ * @see https://en.wikipedia.org/wiki/Graham_scan
+ *
  * @param {Array} uniquePoints - list of UNIQUE points from which to create a hull
  * @returns {Array} a list of points that form the hull
+ * @alias module:modeling/hulls.hullPoints2
  */
 const hullPoints2 = (uniquePoints) => {
   // find min point

package/src/operations/hulls/hullPoints3.d.ts

@@ -0,0 +1,6 @@
+import Vec3 from '../../maths/vec3/type'
+import Poly3 from '../../geometries/poly3/type'
+
+export default hullPoints3
+
+declare function hullPoints3(uniquePoints: Array<Vec3>): Array<Poly3>

package/src/operations/hulls/hullPoints3.js

@@ -0,0 +1,23 @@
+const poly3 = require('../../geometries/poly3')
+
+const quickhull = require('./quickhull')
+
+/**
+ * Create a convex hull of the given set of points, where each point is an array of [x,y,z].
+ *
+ * @param {Array} uniquePoints - list of UNIQUE points from which to create a hull
+ * @returns {Array} a list of polygons (poly3)
+ * @alias module:modeling/hulls.hullPoints3
+ */
+const hullPoints3 = (uniquePoints) => {
+  const faces = quickhull(uniquePoints, { skipTriangulation: true })
+
+  const polygons = faces.map((face) => {
+    const vertices = face.map((index) => uniquePoints[index])
+    return poly3.create(vertices)
+  })
+
+  return polygons
+}
+
+module.exports = hullPoints3

package/src/operations/hulls/index.d.ts

@@ -1,4 +1,6 @@
 export { default as hull } from './hull'
 export { default as hullChain } from './hullChain'
+export { default as hullPoints2 } from './hullPoints2'
+export { default as hullPoints3 } from './hullPoints3'
 
 export as namespace hulls

package/src/operations/hulls/index.js

@@ -8,5 +8,7 @@
  */
 module.exports = {
   hull: require('./hull'),
-  hullChain: require('./hullChain')
+  hullChain: require('./hullChain'),
+  hullPoints2: require('./hullPoints2'),
+  hullPoints3: require('./hullPoints3')
 }

package/src/primitives/polygon.js

@@ -71,8 +71,8 @@ const polygon = (options) => {
   })
 
   // convert the list of sides into a geometry
-  let geometry =  geom2.create(sides)
-  if (orientation == "clockwise") {
+  let geometry = geom2.create(sides)
+  if (orientation === 'clockwise') {
     geometry = geom2.reverse(geometry)
   }
   return geometry

package/src/primitives/polygon.test.js

@@ -56,7 +56,7 @@ test('polygon: providing object.points (array) and object.path (array) creates e
 test('polygon: clockwise points', (t) => {
   const poly = polygon({
     points: [[-10, -0], [-10, -10], [-15, -5]],
-    orientation: "clockwise",
+    orientation: 'clockwise'
   })
   t.is(poly.sides.length, 3)
   t.is(measureArea(poly), 25)