@jscad/modeling 2.12.1 → 2.12.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.12.1",
+  "version": "2.12.3",
   "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": "e07bb27d61f638348c73cc1383dfb5339060a02a"
+  "gitHead": "4627312c2337120447a607ff3ac3da10056ce132"
 }

package/src/geometries/geom3/fromPointsConvex.d.ts

@@ -0,0 +1,6 @@
+import Geom3 from './type'
+import Vec3 from '../../maths/vec3/type'
+
+export default fromPointsConvex
+
+declare function fromPointsConvex(points: Array<Array<Vec3>>): Geom3

package/src/geometries/geom3/fromPointsConvex.js

@@ -0,0 +1,26 @@
+const quickhull = require('../../operations/hulls/quickhull')
+const create = require('./create')
+const poly3 = require('../poly3')
+
+/**
+ * Construct a new convex 3D geometry from a list of unique points.
+ * @param {Array} uniquePoints - list of points to construct convex 3D geometry
+ * @returns {geom3} a new geometry
+ * @alias module:modeling/geometries/geom3.fromPointsConvex
+ */
+const fromPointsConvex = (uniquePoints) => {
+  if (!Array.isArray(uniquePoints)) {
+    throw new Error('the given points must be an array')
+  }
+
+  const faces = quickhull(uniquePoints, { skipTriangulation: true })
+
+  const polygons = faces.map((face) => {
+    const vertices = face.map((index) => uniquePoints[index])
+    return poly3.create(vertices)
+  })
+
+  return create(polygons)
+}
+
+module.exports = fromPointsConvex

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

@@ -0,0 +1,26 @@
+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])
+
+  let 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]
+  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
+  obs.polygons.forEach((f) => edges2 -= f.vertices.length)
+  t.is(edges2, 0);
+})

package/src/geometries/geom3/index.d.ts

@@ -1,5 +1,6 @@
 export { default as clone } from './clone'
 export { default as create } from './create'
+export { default as fromPointsConvex } from './fromPointsConvex'
 export { default as fromPoints } from './fromPoints'
 export { default as fromCompactBinary } from './fromCompactBinary'
 export { default as invert } from './invert'

package/src/geometries/geom3/index.js

@@ -23,6 +23,7 @@
 module.exports = {
   clone: require('./clone'),
   create: require('./create'),
+  fromPointsConvex: require('./fromPointsConvex'),
   fromPoints: require('./fromPoints'),
   fromCompactBinary: require('./fromCompactBinary'),
   invert: require('./invert'),

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/mat4/index.d.ts

@@ -12,6 +12,7 @@ export { default as fromXRotation } from './fromXRotation'
 export { default as fromYRotation } from './fromYRotation'
 export { default as fromZRotation } from './fromZRotation'
 export { default as identity } from './identity'
+export { default as isIdentity } from './isIdentity'
 export { default as isMirroring } from './isMirroring'
 export { default as mirrorByPlane } from './mirrorByPlane'
 export { default as multiply } from './multiply'

package/src/maths/mat4/isIdentity.d.ts

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default isIdentity
+
+declare function isIdentity(matrix: Mat4): boolean

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

@@ -1,5 +1,6 @@
 export { default as intersect } from './intersect'
 export { default as subtract } from './subtract'
 export { default as union } from './union'
+export { default as scission } from './scission'
 
 export as namespace booleans

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

@@ -0,0 +1,6 @@
+import { Geom2, Geom3 } from '../../geometries/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export default scission
+
+declare function scission(...geometries: RecursiveArray<Geom3>): Geom3[]

package/src/operations/booleans/trees/splitPolygonByPlane.d.ts

@@ -0,0 +1,33 @@
+import { Poly3 } from '../../../geometries/types';
+import { Plane } from '../../../maths/types';
+
+enum ResType
+{
+    coplanar_front = 0,
+    coplanar_back = 1,
+    front = 2,
+    back = 3,
+    spanning = 4,
+}
+
+
+interface SplitRes
+{
+    type: ResType,
+    front: Poly3,
+    back: Poly3;
+}
+
+// Returns object:
+// .type:
+//   0: coplanar-front
+//   1: coplanar-back
+//   2: front
+//   3: back
+//   4: spanning
+// In case the polygon is spanning, returns:
+// .front: a Polygon3 of the front part
+// .back: a Polygon3 of the back part
+declare function splitPolygonByPlane(plane: Plane, polygon: Poly3): SplitRes;
+
+export default splitPolygonByPlane;

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/roundedCuboid.js

@@ -150,7 +150,7 @@ const roundedCuboid = (options) => {
 
   if (roundRadius > (size[0] - EPS) ||
       roundRadius > (size[1] - EPS) ||
-      roundRadius > (size[2] - EPS)) throw new Error('roundRadius must be smaller then the radius of all dimensions')
+      roundRadius > (size[2] - EPS)) throw new Error('roundRadius must be smaller than the radius of all dimensions')
 
   segments = Math.floor(segments / 4)
 

package/src/primitives/roundedCylinder.js

@@ -38,7 +38,7 @@ const roundedCylinder = (options) => {
   if (!isGTE(height, 0)) throw new Error('height must be positive')
   if (!isGTE(radius, 0)) throw new Error('radius must be positive')
   if (!isGTE(roundRadius, 0)) throw new Error('roundRadius must be positive')
-  if (roundRadius > radius) throw new Error('roundRadius must be smaller then the radius')
+  if (roundRadius > radius) throw new Error('roundRadius must be smaller than the radius')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
   // if size is zero return empty geometry

package/src/primitives/roundedRectangle.js

@@ -44,7 +44,7 @@ const roundedRectangle = (options) => {
   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 then the radius of all dimensions')
+      roundRadius > (size[1] - EPS)) throw new Error('roundRadius must be smaller than the radius of all dimensions')
 
   const cornersegments = Math.floor(segments / 4)