@jscad/modeling 2.12.5 → 2.12.6

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.12.6](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/modeling@2.12.5...@jscad/modeling@2.12.6) (2025-09-20)
+
+
+### Bug Fixes
+
+* **modeling:** corrected handling of pitch vs height in extrudeHelical ([074f05a](https://github.com/jscad/OpenJSCAD.org/commit/074f05aa5432fbdc8277088e9a45f003f2f978c7))
+
+
+
+
+
 ## [2.12.5](https://github.com/jscad/OpenJSCAD.org/compare/@jscad/modeling@2.12.4...@jscad/modeling@2.12.5) (2024-12-29)
 
 **Note:** Version bump only for package @jscad/modeling

package/dist/jscad-modeling.min.js

@@ -923,7 +923,7 @@ const pointInTriangle=(n,a,e,r,i,o,t,x)=>(i-t)*(a-x)-(n-t)*(o-x)>=0&&(n-t)*(r-x)
 const mat4=require("../../maths/mat4"),geom2=require("../../geometries/geom2"),geom3=require("../../geometries/geom3"),poly3=require("../../geometries/poly3"),slice=require("./slice"),repairSlice=require("./slice/repair"),extrudeWalls=require("./extrudeWalls"),defaultCallback=(e,r,l)=>{let t=null;return geom2.isA(l)&&(t=slice.fromSides(geom2.toSides(l))),poly3.isA(l)&&(t=slice.fromPoints(poly3.toPoints(l))),0===e||1===e?slice.transform(mat4.fromTranslation(mat4.create(),[0,0,e]),t):null},extrudeFromSlices=(e,r)=>{const l={numberOfSlices:2,capStart:!0,capEnd:!0,close:!1,repair:!0,callback:defaultCallback},{numberOfSlices:t,capStart:o,capEnd:c,close:s,repair:i,callback:a}=Object.assign({},l,e);if(t<2)throw new Error("numberOfSlices must be 2 or more");i&&(r=repairSlice(r));const n=t-1;let u=null,m=null,f=null,g=[];for(let e=0;e<t;e++){const l=a(e/n,e,r);if(l){if(!slice.isA(l))throw new Error("the callback function must return slice objects");if(0===slice.toEdges(l).length)throw new Error("the callback function must return slices with one or more edges");f&&(g=g.concat(extrudeWalls(f,l))),0===e&&(u=l),e===t-1&&(m=l),f=l}}if(c){const e=slice.toPolygons(m);g=g.concat(e)}if(o){const e=slice.toPolygons(u).map(poly3.invert);g=g.concat(e)}return o||c||s&&!slice.equals(m,u)&&(g=g.concat(extrudeWalls(m,u))),geom3.create(g)};module.exports=extrudeFromSlices;
 
 },{"../../geometries/geom2":25,"../../geometries/geom3":41,"../../geometries/poly3":79,"../../maths/mat4":143,"./extrudeWalls":317,"./slice":326,"./slice/repair":328}],309:[function(require,module,exports){
-const{TAU:TAU}=require("../../maths/constants"),slice=require("./slice"),mat4=require("../../maths/mat4"),extrudeFromSlices=require("./extrudeFromSlices"),geom2=require("../../geometries/geom2"),extrudeHelical=(e,t)=>{const r={angle:TAU,startAngle:0,pitch:10,endOffset:0,segmentsPerRotation:32},{angle:a,endOffset:s,segmentsPerRotation:o,startAngle:i}=Object.assign({},r,e);let n;n=!e.pitch&&e.height?e.height/(a/TAU):e.pitch?e.pitch:r.pitch;if(o<3)throw new Error("The number of segments per rotation needs to be at least 3.");const m=geom2.toSides(t);if(0===m.length)throw new Error("the given geometry cannot be empty");const c=m.filter(e=>e[0][0]>=0);let l=slice.fromSides(m);0===c.length&&(l=slice.reverse(l));const h=Math.round(o/TAU*Math.abs(a)),g=h>=2?h:2,u=mat4.create();let f;return extrudeFromSlices({numberOfSlices:g+1,callback:(e,t,r)=>{const o=i+a/g*t,m=s/g*t,c=(o-i)/TAU*n;return mat4.multiply(u,mat4.fromTranslation(mat4.create(),[m,0,c*Math.sign(a)]),mat4.fromXRotation(mat4.create(),-TAU/4*Math.sign(a))),f=mat4.create(),mat4.multiply(f,mat4.fromZRotation(mat4.create(),o),u),slice.transform(f,r)}},l)};module.exports=extrudeHelical;
+const{TAU:TAU}=require("../../maths/constants"),mat4=require("../../maths/mat4"),geom2=require("../../geometries/geom2"),extrudeFromSlices=require("./extrudeFromSlices"),slice=require("./slice"),extrudeHelical=(e,t)=>{const r={angle:TAU,startAngle:0,pitch:10,height:0,endOffset:0,segmentsPerRotation:32};let{angle:a,startAngle:s,pitch:o,height:n,endOffset:i,segmentsPerRotation:m}=Object.assign({},r,e);0!=n&&(o=n/(a/TAU));if(m<3)throw new Error("The number of segments per rotation needs to be at least 3.");const l=geom2.toSides(t);if(0===l.length)throw new Error("The given geometry cannot be empty");const c=l.filter(e=>e[0][0]>=0);let g=slice.fromSides(l);0===c.length&&(g=slice.reverse(g));const h=Math.round(m/TAU*Math.abs(a)),u=h>=2?h:2,f=mat4.create(),d=mat4.create();return extrudeFromSlices({numberOfSlices:u+1,callback:(e,t,r)=>{const n=s+a/u*t,m=i/u*t,l=(n-s)/TAU*o;return mat4.multiply(f,mat4.fromTranslation(mat4.create(),[m,0,l*Math.sign(a)]),mat4.fromXRotation(mat4.create(),-TAU/4*Math.sign(a))),mat4.multiply(d,mat4.fromZRotation(mat4.create(),n),f),slice.transform(d,r)}},g)};module.exports=extrudeHelical;
 
 },{"../../geometries/geom2":25,"../../maths/constants":94,"../../maths/mat4":143,"./extrudeFromSlices":308,"./slice":326}],310:[function(require,module,exports){
 const flatten=require("../../utils/flatten"),geom2=require("../../geometries/geom2"),path2=require("../../geometries/path2"),extrudeLinearGeom2=require("./extrudeLinearGeom2"),extrudeLinearPath2=require("./extrudeLinearPath2"),extrudeLinear=(e,...t)=>{const{height:r,twistAngle:i,twistSteps:n,repair:a}=Object.assign({},{height:1,twistAngle:0,twistSteps:1,repair:!0},e);if(0===(t=flatten(t)).length)throw new Error("wrong number of arguments");e={offset:[0,0,r],twistAngle:i,twistSteps:n,repair:a};const s=t.map(t=>path2.isA(t)?extrudeLinearPath2(e,t):geom2.isA(t)?extrudeLinearGeom2(e,t):t);return 1===s.length?s[0]:s};module.exports=extrudeLinear;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.12.5",
+  "version": "2.12.6",
   "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": "d8010c4f1d70685404a510d604f8b6d5c362f93a"
+  "gitHead": "11a9a2d9235d804360116f776076c9f3237a3eb0"
 }

package/src/operations/extrusions/extrudeHelical.js

@@ -1,16 +1,18 @@
 const { TAU } = require('../../maths/constants')
-const slice = require('./slice')
 const mat4 = require('../../maths/mat4')
-const extrudeFromSlices = require('./extrudeFromSlices')
+
 const geom2 = require('../../geometries/geom2')
 
+const extrudeFromSlices = require('./extrudeFromSlices')
+const slice = require('./slice')
+
 /**
  * Perform a helical extrude of the geometry, using the given options.
  *
  * @param {Object} options - options for extrusion
- * @param {Number} [options.angle=TAU] - angle of the extrusion (RADIANS) positive for right-hand rotation, negative for left-hand
+ * @param {Number} [options.angle=TAU] - angle of the extrusion (RADIANS); positive for right-hand rotation, negative for left-hand
  * @param {Number} [options.startAngle=0] - start angle of the extrusion (RADIANS)
- * @param {Number} [options.pitch=10] - elevation gain for each turn
+ * @param {Number} [options.pitch=10] - elevation gain for each full rotation
  * @param {Number} [options.height] - total height of the helix path. Ignored if pitch is set.
  * @param {Number} [options.endOffset=0] - offset the final radius of the extrusion, allowing for tapered helix, and or spiral
  * @param {Number} [options.segmentsPerRotation=32] - number of segments per full rotation of the extrusion
@@ -20,24 +22,23 @@ const geom2 = require('../../geometries/geom2')
  *
  * @example
  * const myshape = circle({size: 3, center: [10, 0]}) // position for extrusion about Z
- * const mycoil = extrudeHelical({angle: TAU*2, pitch: 10, segmentsPerRotation: 64}, myshape))
+ * const mycoil = extrudeHelical({angle: TAU * 2, pitch: 10, segmentsPerRotation: 64}, myshape))
  */
 const extrudeHelical = (options, geometry) => {
   const defaults = {
     angle: TAU,
     startAngle: 0,
     pitch: 10,
+    height: 0,
     endOffset: 0,
     segmentsPerRotation: 32
   }
-  const { angle, endOffset, segmentsPerRotation, startAngle } = Object.assign({}, defaults, options)
-
-  let pitch
-  // ignore height if pitch is set
-  if (!options.pitch && options.height) {
-    pitch = options.height / (angle / TAU)
-  } else {
-    pitch = options.pitch ? options.pitch : defaults.pitch
+  let { angle, startAngle, pitch, height, endOffset, segmentsPerRotation } = Object.assign({}, defaults, options)
+
+  // calculate pitch from height if available
+  if (height != 0) {
+    // height / number of full rotations
+    pitch = height / (angle / TAU)
   }
 
   // needs at least 3 segments for each revolution
@@ -46,7 +47,7 @@ const extrudeHelical = (options, geometry) => {
   if (segmentsPerRotation < minNumberOfSegments) { throw new Error('The number of segments per rotation needs to be at least 3.') }
 
   const shapeSides = geom2.toSides(geometry)
-  if (shapeSides.length === 0) throw new Error('the given geometry cannot be empty')
+  if (shapeSides.length === 0) throw new Error('The given geometry cannot be empty')
 
   // const pointsWithNegativeX = shapeSides.filter((s) => (s[0][0] < 0))
   const pointsWithPositiveX = shapeSides.filter((s) => (s[0][0] >= 0))
@@ -60,9 +61,11 @@ const extrudeHelical = (options, geometry) => {
 
   const calculatedSegments = Math.round(segmentsPerRotation / TAU * Math.abs(angle))
   const segments = calculatedSegments >= 2 ? calculatedSegments : 2
+
   // define transform matrix variables for performance increase
   const step1 = mat4.create()
-  let matrix
+  const step2 = mat4.create()
+
   const sliceCallback = (progress, index, base) => {
     const zRotation = startAngle + angle / segments * index
     const xOffset = endOffset / segments * index
@@ -84,14 +87,13 @@ const extrudeHelical = (options, geometry) => {
       mat4.fromXRotation(mat4.create(), -TAU / 4 * Math.sign(angle)) // rotate the slice correctly to not create inside-out polygon
     )
 
-    matrix = mat4.create()
     mat4.multiply(
-      matrix,
+      step2,
       // finally rotate around Z axis
       mat4.fromZRotation(mat4.create(), zRotation),
       step1
     )
-    return slice.transform(matrix, base)
+    return slice.transform(step2, base)
   }
 
   return extrudeFromSlices(

package/src/operations/extrusions/extrudeHelical.test.js

@@ -34,7 +34,17 @@ test('extrudeHelical: (pitch) extruding of a circle produces an expected geom3',
   const geometry2 = circle({ size: 3, center: [10, 0] })
   for (const index of [...Array(20).keys()]) {
     // also test negative pitches
-    const geometry3 = extrudeHelical({ pitch: startPitch + index }, geometry2)
+    const geometry3 = extrudeHelical({ pitch: startPitch + index, startAngle: TAU * index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
+})
+
+test('extrudeHelical: (height) extruding of a circle produces an expected geom3', (t) => {
+  const startHeight = -5
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(10).keys()]) {
+    // also test negative heights
+    const geometry3 = extrudeHelical({ height: startHeight + index, angle: TAU * (index + 1) }, geometry2)
     t.notThrows(() => geom3.validate(geometry3))
   }
 })
@@ -49,12 +59,12 @@ test('extrudeHelical: (endRadiusOffset) extruding of a circle produces an expect
   }
 })
 
-test('extrudeHelical: (segments) extruding of a circle produces an expected geom3', (t) => {
+test('extrudeHelical: (segmentsPerRotation) extruding of a circle produces an expected geom3', (t) => {
   const startSegments = 3
   const geometry2 = circle({ size: 3, center: [10, 0] })
   for (const index of [...Array(30).keys()]) {
     // also test negative pitches
-    const geometry3 = extrudeHelical({ segments: startSegments + index }, geometry2)
+    const geometry3 = extrudeHelical({ segmentsPerRotation: startSegments + index }, geometry2)
     t.notThrows(() => geom3.validate(geometry3))
   }
 })