@jscad/modeling 2.12.1 → 2.12.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.12.1",
+  "version": "2.12.2",
   "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": "5fbb5fea458c28b0d96450dde9231e1d4d8ce6a4"
 }

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/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,7 @@
+import { Geom2, Geom3 } from '../../geometries/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export default scission
+
+declare function scission(...geometries: RecursiveArray<Geom2>): Geom2
+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/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)