@jscad/modeling 2.12.0 → 2.12.2

package/package.json

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

package/src/geometries/geom2/transform.js

@@ -1,5 +1,7 @@
 const mat4 = require('../../maths/mat4')
 
+const reverse = require('./reverse.js')
+
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the sides, as this function only adjusts the transforms.
@@ -14,7 +16,13 @@ const mat4 = require('../../maths/mat4')
  */
 const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
-  return Object.assign({}, geometry, { transforms })
+  const transformed = Object.assign({}, geometry, { transforms })
+  // determine if the transform is mirroring in 2D
+  if (matrix[0] * matrix[5] - matrix[4] * matrix[1] < 0) {
+    // reverse the order to preserve the orientation
+    return reverse(transformed)
+  }
+  return transformed
 }
 
 module.exports = transform

package/src/geometries/geom2/transform.test.js

@@ -2,7 +2,13 @@ const test = require('ava')
 
 const mat4 = require('../../maths/mat4')
 
-const { transform, fromPoints, toSides } = require('./index')
+const { measureArea } = require('../../measurements/index.js')
+
+const { mirrorX, mirrorY, mirrorZ } = require('../../operations/transforms/index.js')
+
+const { square } = require('../../primitives/index.js')
+
+const { fromPoints, transform, toOutlines, toSides } = require('./index.js')
 
 const { comparePoints, compareVectors } = require('../../../test/helpers/')
 
@@ -51,3 +57,54 @@ test('transform: adjusts the transforms of geom2', (t) => {
   t.true(comparePoints(another.sides[2], expected.sides[2]))
   t.true(compareVectors(another.transforms, expected.transforms))
 })
+
+test('transform: geom2 mirrorX', (t) => {
+  const geometry = square()
+  const transformed = mirrorX(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we reversed the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[-1, 1], [-1, -1], [1, -1], [1, 1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[1, 1], [-1, 1]],
+    [[-1, 1], [-1, -1]],
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]]
+  ])
+})
+
+test('transform: geom2 mirrorY', (t) => {
+  const geometry = square()
+  const transformed = mirrorY(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we reversed the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[1, -1], [1, 1], [-1, 1], [-1, -1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]],
+    [[1, 1], [-1, 1]],
+    [[-1, 1], [-1, -1]]
+  ])
+})
+
+test('transform: geom2 mirrorZ', (t) => {
+  const geometry = square()
+  const transformed = mirrorZ(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we DIDN'T reverse the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[-1, -1], [1, -1], [1, 1], [-1, 1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[-1, 1], [-1, -1]],
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]],
+    [[1, 1], [-1, 1]]
+  ])
+})

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/maths/plane/fromNoisyPoints.d.ts

@@ -0,0 +1,6 @@
+import Plane from './type'
+import Vec3 from '../vec3/type'
+
+export default fromNoisyPoints
+
+declare function fromNoisyPoints(out: Plane, ...vertices: Array<Vec3>): Plane

package/src/maths/plane/fromNoisyPoints.js

@@ -0,0 +1,106 @@
+const vec3 = require('../vec3')
+const fromNormalAndPoint = require('./fromNormalAndPoint')
+
+/**
+ * Create a best-fit plane from the given noisy vertices.
+ *
+ * NOTE: There are two possible orientations for every plane.
+ *       This function always produces positive orientations.
+ *
+ * See http://www.ilikebigbits.com for the original discussion
+ *
+ * @param {Plane} out - receiving plane
+ * @param {Array} vertices - list of vertices in any order or position
+ * @returns {Plane} out
+ * @alias module:modeling/maths/plane.fromNoisyPoints
+ */
+const fromNoisyPoints = (out, ...vertices) => {
+  out[0] = 0.0
+  out[1] = 0.0
+  out[2] = 0.0
+  out[3] = 0.0
+
+  // calculate the centroid of the vertices
+  // NOTE: out is the centriod
+  const n = vertices.length
+  vertices.forEach((v) => {
+    vec3.add(out, out, v)
+  })
+  vec3.scale(out, out, 1.0 / n)
+
+  // Calculate full 3x3 covariance matrix, excluding symmetries
+  let xx = 0.0
+  let xy = 0.0
+  let xz = 0.0
+  let yy = 0.0
+  let yz = 0.0
+  let zz = 0.0
+
+  const vn = vec3.create()
+  vertices.forEach((v) => {
+    // NOTE: out is the centriod
+    vec3.subtract(vn, v, out)
+    xx += vn[0] * vn[0]
+    xy += vn[0] * vn[1]
+    xz += vn[0] * vn[2]
+    yy += vn[1] * vn[1]
+    yz += vn[1] * vn[2]
+    zz += vn[2] * vn[2]
+  })
+
+  xx /= n
+  xy /= n
+  xz /= n
+  yy /= n
+  yz /= n
+  zz /= n
+
+  // Calculate the smallest Eigenvector of the covariance matrix
+  // which becomes the plane normal
+
+  vn[0] = 0.0
+  vn[1] = 0.0
+  vn[2] = 0.0
+
+  // weighted directional vector
+  const wdv = vec3.create()
+
+  // X axis
+  let det = yy * zz - yz * yz
+  wdv[0] = det
+  wdv[1] = xz * yz - xy * zz
+  wdv[2] = xy * yz - xz * yy
+
+  let weight = det * det
+  vec3.add(vn, vn, vec3.scale(wdv, wdv, weight))
+
+  // Y axis
+  det = xx * zz - xz * xz
+  wdv[0] = xz * yz - xy * zz
+  wdv[1] = det
+  wdv[2] = xy * xz - yz * xx
+
+  weight = det * det
+  if (vec3.dot(vn, wdv) < 0.0) {
+    weight = -weight
+  }
+  vec3.add(vn, vn, vec3.scale(wdv, wdv, weight))
+
+  // Z axis
+  det = xx * yy - xy * xy
+  wdv[0] = xy * yz - xz * yy
+  wdv[1] = xy * xz - yz * xx
+  wdv[2] = det
+
+  weight = det * det
+  if (vec3.dot(vn, wdv) < 0.0) {
+    weight = -weight
+  }
+  vec3.add(vn, vn, vec3.scale(wdv, wdv, weight))
+
+  // create the plane from normal and centriod
+  // NOTE: out is the centriod
+  return fromNormalAndPoint(out, vn, out)
+}
+
+module.exports = fromNoisyPoints

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

@@ -0,0 +1,24 @@
+const test = require('ava')
+const { fromNoisyPoints, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('plane: fromNoisyPoints() should return a new plane with correct values', (t) => {
+  const obs1 = fromNoisyPoints(create(), [0, 0, 0], [1, 0, 0], [1, 1, 0])
+  t.true(compareVectors(obs1, [0, 0, 1, 0]))
+
+  const obs2 = fromNoisyPoints(obs1, [0, 6, 0], [0, 2, 2], [0, 6, 6])
+  t.true(compareVectors(obs2, [1, 0, 0, 0]))
+
+  // same vertices results in an invalid plane
+  const obs3 = fromNoisyPoints(obs1, [0, 6, 0], [0, 6, 0], [0, 6, 0])
+  t.true(compareVectors(obs3, [0 / 0, 0 / 0, 0 / 0, 0 / 0]))
+
+  // co-linear vertices
+  const obs4 = fromNoisyPoints(obs1, [0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0])
+  t.true(compareVectors(obs4, [0, 0, 1, 0]))
+
+  // random vertices
+  const obs5 = fromNoisyPoints(obs1, [0, 0, 0], [5, 1, -2], [3, -2, 4], [1, 1, 0])
+  t.true(compareVectors(obs5, [0.08054818365229491, 0.8764542170444571, 0.47469990050062555, 0.4185833634679763]))
+})

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

@@ -5,6 +5,7 @@ export { default as equals } from './equals'
 export { default as flip } from './flip'
 export { default as fromNormalAndPoint } from './fromNormalAndPoint'
 export { default as fromValues } from './fromValues'
+export { default as fromNoisyPoints } from './fromNoisyPoints'
 export { default as fromPoints } from './fromPoints'
 export { default as fromPointsRandom } from './fromPointsRandom'
 export { default as signedDistanceToPoint } from './signedDistanceToPoint'

package/src/maths/plane/index.js

@@ -32,6 +32,7 @@ module.exports = {
    * @function fromValues
    */
   fromValues: require('../vec4/fromValues'),
+  fromNoisyPoints: require('./fromNoisyPoints'),
   fromPoints: require('./fromPoints'),
   fromPointsRandom: require('./fromPointsRandom'),
   projectionOfPoint: require('./projectionOfPoint'),

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/operations/extrusions/extrudeRotate.js

@@ -93,7 +93,7 @@ const extrudeRotate = (options, geometry) => {
         return [point0, point1]
       })
       // recreate the geometry from the (-) capped points
-      geometry = geom2.reverse(geom2.create(shapeSides))
+      geometry = geom2.create(shapeSides)
       geometry = mirrorX(geometry)
     } else if (pointsWithPositiveX.length >= pointsWithNegativeX.length) {
       shapeSides = shapeSides.map((side) => {

package/src/operations/transforms/mirror.test.js

@@ -2,6 +2,8 @@ const test = require('ava')
 
 const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
 
+const { measureArea } = require('../../measurements')
+
 const { geom2, geom3, path2 } = require('../../geometries')
 
 const { mirror, mirrorX, mirrorY, mirrorZ } = require('./index')
@@ -40,25 +42,29 @@ test('mirror: mirroring of geom2 about X/Y produces expected changes to points',
   // mirror about X
   let mirrored = mirror({ normal: [1, 0, 0] }, geometry)
   let obs = geom2.toPoints(mirrored)
-  let exp = [[5, -5], [0, 5], [-10, -5]]
+  let exp = [[0, 5], [5, -5], [-10, -5]]
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorX(geometry)
   obs = geom2.toPoints(mirrored)
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   // mirror about Y
   mirrored = mirror({ normal: [0, 1, 0] }, geometry)
   obs = geom2.toPoints(mirrored)
-  exp = [[-5, 5], [0, -5], [10, 5]]
+  exp = [[0, -5], [-5, 5], [10, 5]]
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = geom2.toPoints(mirrored)
   t.notThrows(() => geom2.validate(mirrored))
+  t.is(measureArea(mirrored), measureArea(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -146,7 +152,7 @@ test('mirror: mirroring of multiple objects produces an array of mirrored object
   t.true(comparePoints(obs, exp))
 
   obs = geom2.toPoints(mirrored[2])
-  exp = [[-5, 5], [0, -5], [10, 5]]
+  exp = [[0, -5], [-5, 5], [10, 5]]
   t.notThrows(() => geom2.validate(mirrored[2]))
   t.true(comparePoints(obs, exp))
 })

package/src/primitives/polygon.d.ts

@@ -6,6 +6,7 @@ export default polygon
 export interface PolygonOptions {
   points: Array<Vec2> | Array<Array<Vec2>>
   paths?: Array<number> | Array<Array<number>>
+  orientation?: 'counterclockwise' | 'clockwise'
 }
 
 declare function polygon(options: PolygonOptions): Geom2

package/src/primitives/polygon.js

@@ -2,10 +2,13 @@ const geom2 = require('../geometries/geom2')
 
 /**
  * Construct a polygon in two dimensional space from a list of points, or a list of points and paths.
- * NOTE: The ordering of points is VERY IMPORTANT.
+ *
+ * NOTE: The ordering of points is important, and must define a counter clockwise rotation of points.
+ *
  * @param {Object} options - options for construction
  * @param {Array} options.points - points of the polygon : either flat or nested array of 2D points
  * @param {Array} [options.paths] - paths of the polygon : either flat or nested array of point indexes
+ * @param {String} [options.orientation='counterclockwise'] - orientation of points
  * @returns {geom2} new 2D geometry
  * @alias module:modeling/primitives.polygon
  *
@@ -24,9 +27,10 @@ const geom2 = require('../geometries/geom2')
 const polygon = (options) => {
   const defaults = {
     points: [],
-    paths: []
+    paths: [],
+    orientation: 'counterclockwise'
   }
-  const { points, paths } = Object.assign({}, defaults, options)
+  const { points, paths, orientation } = Object.assign({}, defaults, options)
 
   if (!(Array.isArray(points) && Array.isArray(paths))) throw new Error('points and paths must be arrays')
 
@@ -58,13 +62,20 @@ const polygon = (options) => {
   const allpoints = []
   listofpolys.forEach((list) => list.forEach((point) => allpoints.push(point)))
 
+  // convert the list of paths into a list of sides, and accumulate
   let sides = []
   listofpaths.forEach((path) => {
     const setofpoints = path.map((index) => allpoints[index])
     const geometry = geom2.fromPoints(setofpoints)
     sides = sides.concat(geom2.toSides(geometry))
   })
-  return geom2.create(sides)
+
+  // convert the list of sides into a geometry
+  let geometry =  geom2.create(sides)
+  if (orientation == "clockwise") {
+    geometry = geom2.reverse(geometry)
+  }
+  return geometry
 }
 
 module.exports = polygon

package/src/primitives/polygon.test.js

@@ -1,6 +1,7 @@
 const test = require('ava')
 
 const geom2 = require('../geometries/geom2')
+const measureArea = require('../measurements/measureArea')
 
 const { polygon } = require('./index')
 
@@ -51,3 +52,12 @@ test('polygon: providing object.points (array) and object.path (array) creates e
   t.notThrows(() => geom2.validate(geometry))
   t.true(comparePoints(obs, exp))
 })
+
+test('polygon: clockwise points', (t) => {
+  const poly = polygon({
+    points: [[-10, -0], [-10, -10], [-15, -5]],
+    orientation: "clockwise",
+  })
+  t.is(poly.sides.length, 3)
+  t.is(measureArea(poly), 25)
+})

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)