add fdm scarf seams and min layer time

notes.md

@@ -31,27 +31,21 @@
 * `B` multi-extruder rendering of raft fails to offset the rest of the print
 * `B` multi-extruder purge blocks fail to generate properly for rafts
 
-* `F` min layer time
+* `F` new parameter to cap output flow rate (on printer device)
-* `F` separate bridging speed / fan control
+* `F` new parameters for bridging speed / bridge fan control
-* `F` elephant foot compensation
+* `F` new base paremeter for hole and perimeter compensation
-* `F` inner / outer perimeter compensation
+* `F` new parameters for inner / outer perimeter compensation
-* `F` better thin-wall (like arachne)
-* `F` add scarf seams
-* `F` add 'random' and 'seam' start point options
 * `F` convert ranges to z offsets while continuing to show layer #
 * `F` support pillar top/bottom should conform to part
 * `F` more explicit line width control with ranges and min/max adaptive
 * `F` test outlining solid projected areas (internally)
 * `F` gradient infill https://www.youtube.com/watch?v=hq53gsYREHU&feature=emb_logo
-* `F` feather sharp tips by reducing extrusion in area of overlap
 * `F` segment large flat areas on first layer to mitigate peeling
 * `F` option to support interior bridges when 0% infill
 * `F` calculate filament use per extruder per print
 * `F` expand internal supporting flats / solids before projection (threshold)
 
-* `P` reduce fan speed, feed rate, and extrusion factor for bridges
 * `P` auto purge pillars when quick layers are detected for extra cooling
-* `P` extruder + filament max flow rate cap in planner
 * `P` solid fill the tops of supports for down facing flats
 
 # FDM - BELT
@@ -91,8 +85,8 @@
 * `F` ease-in and ease-out especially on tab cut-out start/stop
 * `F` maintain several part orientations + op chains in a single profile
 
+* `P` outer outside corners as arc moves
 * `P` improve parser - do not require spaced tokens and support implied G0 / G1
-* `P` outer corner arc moves
 * `P` log Z interpolation for contour XYZ moves
 * `P` option to start with the smallest poly by area on layer change
 * `P` redo all path route / planning in prepare to account for terrain before camOut

src/geo/polygon.js

@@ -2324,9 +2324,12 @@ export class Polygon {
         return obj;
     }
 
-    // split long straight lines into segments no longer than max
+    // split long straight lines into segments no longer than `max`
-    // and return a new polygon
+    // and return a new polygon. optionally `mark` points with their
-    segment(max = 1, mark, wrap) {
+    // derived segment start point (hinting for thin walls), `wrap`
+    // the poly first point by appending to the end (adaptive walls),
+    // or stopping segmentation at `maxoff`
+    segment(max = 1, mark = false, wrap = false, maxoff = Infinity) {
         const newp = [];
         const points = this.points;
         const length = points.length;
@@ -2339,9 +2342,13 @@ export class Polygon {
             const dl = Math.sqrt(dx * dx + dy * dy);
             newp.push(p1);
             if (mark) p1.segment = p1;
-            if (dl < max) {
+            // if segment shorter than max (delta) or
+            // maxoff is exhausted (only segmenting up to some length)
+            // then skip sub-segmenting the current segment
+            if (dl < max || maxoff < 0) {
                 continue;
             }
+            maxoff -= dl;
             const div = dl / max;
             const fit = div | 0;
             const add = fit - 1;

src/kiri/core/conf.js

@@ -327,8 +327,10 @@ export const conf = {
                 outputRetractDwell: 20,
                 outputBrimCount: 2,
                 outputBrimOffset: 2,
+                outputScarfLength: 0,
                 outputShortPoly: 100.0,
                 outputMinSpeed: 10.0,
+                outputMinLayerTime: 0,
                 outputCoastDist: 0,
                 outputPurgeTower: 0,
                 outputBeltFirst: false,

src/kiri/core/print.js

@@ -98,6 +98,7 @@ class Print {
      * @param {Array} output - the array to print to
      * @param {Object} [options] - optional parameters
      * @param {boolean} [options.ccw] - set the polygon to be counter-clockwise
+     * @param {boolean} [options.scarf] - scarf seam permitted
      * @param {number} [options.extrude] - extrude factor for the polygon
      * @param {number} [options.rate] - print speed in mm/s
      * @param {number} [options.coast] - distance to coast at the end of the polygon
@@ -128,6 +129,7 @@ class Print {
             closest = options.simple ? poly.first() : poly.findClosestPointTo(startPoint),
             perimeter = poly.perimeter(),
             close = !options.open,
+            scarf = !poly.open ? (options.scarf ?? 0) : false,
             tool = options.tool,
             last = startPoint,
             first = true;
@@ -137,8 +139,70 @@ class Print {
             printSpeed = minSpeed + (printSpeed - minSpeed) * (perimeter / process.outputShortPoly);
         }
 
+        // if not starting at first point in poly, rotate to move start to index = 0
+        let pp = poly.points;
+        if (closest.index > 0) {
+            let cio = pp.indexOf(closest.point);
+            pp = poly.points = [ ...pp.slice(cio), ...pp.slice(0, cio) ];
+        }
+
+        // scarf sanity checks
+        if (scarf) {
+            // cancel scarf for thin wall polys
+            if (pp.filter(p => p.skip || p.moved).length) {
+                scarf = 0;
+            } else {
+                // cancel scarf if any point.z differs
+                let z0 = pp[0].z;
+                let zd = 0;
+                for (let p of pp) zd += Math.abs(p.z - z0);
+                if (zd) scarf = 0;
+            }
+            // console.log({ scarf });
+        }
+
+        // when creating scarf seams, segment poly up to seam length
+        // create array of step up points at start of poly with increasing z
+        // and increasing shellMult and then append the same points on the back
+        // end of the poly with fixed z and decreasing shellMult
+        if (scarf) {
+            let epz = Math.max(...poly.points.map(p => p.z));
+            let spz = startPoint.z;
+            poly = poly.segment(options.nozzleSize ?? 0.4, false, false, scarf * 2);
+            pp = poly.points;
+            let lp, sp = [];
+            for (let p of pp) {
+                let d = lp?.distTo2D(p) ?? 0;
+                sp.push(lp = p);
+                scarf -= d;
+                if (scarf <= 0) break;
+            }
+            let scale = 0.25; // flow compensation on overlap
+            let mid = (1 / sp.length) * 0.75; // flow compensation (- half step)
+            let zd = (epz - spz) / sp.length;
+            let zi = 1;
+            for (let p of sp) {
+                p.z -= zd * (sp.length - zi);
+                p.moved = (((zi++) / sp.length) * scale) - 1 - mid;
+            }
+            let esp = sp.map(p => p.clone()); // ending scarf points
+            for (let p of esp) {
+                p.z = epz;
+                p.moved = (((--zi) / esp.length) * scale) - 1 - mid;
+            }
+            esp.pop(); // stop short to prevent overlap bulge
+            pp.push(...esp);
+            // console.log({ poly, spz, epz, zd, sp, esp });
+            scarf = true;
+        }
+
+        // scarf manages its own close point
+        if (close && !scarf) {
+            pp.push(pp[0]);
+        }
+
         let lpo;
-        poly.forEachPoint((point, pos, points, count) => {
+        for (let point of pp) {
             if (point.skip && lpo?.skip) {
                 scope.addOutput(output, point, 0, moveSpeed, tool);
             } else if (first) {
@@ -154,7 +218,8 @@ class Print {
                 first = false;
             } else {
                 let seglen = last.distTo2D(point);
-                if (coastDist && shellMult && perimeter - seglen <= coastDist) {
+                // cancel coast when using scarf seam
+                if (!scarf && coastDist && shellMult && perimeter - seglen <= coastDist) {
                     let delta = perimeter - coastDist;
                     let offset = seglen - delta;
                     let offPoint = last.offsetPointFrom(point, offset)
@@ -168,7 +233,7 @@ class Print {
                 scope.addOutput(output, point, multOut, printSpeed, tool);
             }
             last = lpo = point;
-        }, close, closest.index);
+        }
 
         this.lastPoly = poly;
 

src/kiri/core/render.js

@@ -181,8 +181,8 @@ async function path(levels, update, opts = {}) {
                 return;
             }
 
-            if (lastOut) { // if last outpoint is defined
+            // if last outpoint is defined
-
+            if (lastOut) {
                 if (arrowAll || lastOut.emit !== out.emit) {
                     heads.push({p1: lastOutPoint, p2: outPoint});
                 }
@@ -200,13 +200,10 @@ async function path(levels, update, opts = {}) {
                         current.color = color(out);
                         pushPrint(out.tool, current);
                     }
-
                     out.arcPoints.forEach(p => {
                         current.push(p);
                     })
-
                     current.push(outPoint);
-
                 } else if (out.emit) {
                     // explicity G1 in CAM mode
                     // just a non-move in other modes

src/kiri/mode/fdm/init-menu.js

@@ -102,6 +102,7 @@ export function menu() {
     _____:               newGroup(LANG.fc_menu, $('fdm-cool'), { modes:FDM, driven, hideable, separator, group:"fdm-cool" }),
     outputFanLayer:      newInput(LANG.ou_fanl_s, { title:LANG.ou_fanl_l, convert:toInt,   bound:bound(0,255) }),
     outputFanSpeed:      newInput(LANG.ou_fans_s, {title:LANG.ou_fans_l, convert:toInt, bound:bound(0,255)}),
+    outputMinLayerTime:  newInput(LANG.ou_layt_s, { title:LANG.ou_layt_l, convert:toInt,   bound:bound(0,200) }),
     _____:               newGroup(LANG.sp_menu, $('fdm-support'), { modes:FDM, driven, hideable, separator, group:"fdm-supp" }),
     sliceSupportNozzle:  newSelect(LANG.sp_nozl_s, {title:LANG.sp_nozl_l, show:isMultiHead}, "extruders"),
     sliceSupportDensity: newInput(LANG.sp_dens_s, {title:LANG.sp_dens_l, convert:toFloat, bound:bound(0.0,1.0)}),
@@ -177,6 +178,7 @@ export function menu() {
     outputRetractDwell:  newInput(LANG.ad_rdwl_s, {title:LANG.ad_rdwl_l, convert:toInt}),
     outputMinSpeed:      newInput(LANG.ad_mins_s, {title:LANG.ad_mins_l, convert:toFloat, bound:bound(1,200)}),
     outputPurgeTower:    newInput(LANG.ad_purg_s, {title:LANG.ad_purg_l, convert:toInt,   bound:bound(0,1000)}),
+    outputScarfLength:   newInput(LANG.ad_scar_s, {title:LANG.ad_scar_l, convert:toFloat, bound:bound(0,1000)}),
     outputShortPoly:     newInput(LANG.ad_spol_s, {title:LANG.ad_spol_l, convert:toFloat, bound:bound(0,10000)}),
     outputCoastDist:     newInput(LANG.ad_scst_s, {title:LANG.ad_scst_l, convert:toFloat, bound:bound(0.0,10)}),
     zHopDistance:        newInput(LANG.ad_zhop_s, {title:LANG.ad_zhop_l, convert:toFloat, bound:bound(0,3.0)}),

src/kiri/mode/fdm/prepare.js

@@ -800,6 +800,8 @@ function slicePrintPath(print, slice, startPoint, offset, output, opt = {}) {
         process = opt.params || settings.process,
         originCenter = device.originCenter || bedRound,
         extruder = parseInt(slice.extruder || 0),
+        scarfLength = process.outputScarfLength || 0,
+        minLayerTime = process.outputMinLayerTime || 0,
         nozzleSize = process.sliceLineWidth || device.extruders[extruder].extNozzle,
         firstLayer = (opt.first || false) && !opt.support,
         thinWall = nozzleSize * (opt.thinWall || 1.75),
@@ -1036,8 +1038,8 @@ function slicePrintPath(print, slice, startPoint, offset, output, opt = {}) {
         return false;
     }
 
-    // solid infill
+    // output shell wall
-    function outputTraces(poly, opt = {}) {
+    function outputTraces(poly, opt = {}, traceNo = 0) {
         if (!poly) return;
         if (Array.isArray(poly)) {
             if (opt.sort) {
@@ -1070,26 +1072,28 @@ function slicePrintPath(print, slice, startPoint, offset, output, opt = {}) {
                     if (next) {
                         last = next;
                         polys.remove(next);
-                        outputTraces(next, opt);
+                        outputTraces(next, opt, traceNo++);
                     } else {
                         last = null;
                     }
                 }
             } else {
                 outputOrderClosest(poly, function(next) {
-                    outputTraces(next, opt);
+                    outputTraces(next, opt, traceNo++);
                 }, null);
             }
         } else {
             let finishShell = poly.depth === 0 && !firstLayer;
             startPoint = print.polyPrintPath(poly, startPoint, preout, {
-                ccw: opt.shell && process.outputAlternating && slice.index % 2,
-                tool: extruder,
-                rate: finishShell ? finishSpeed : printSpeed,
                 accel: finishShell,
-                wipe: process.outputWipeDistance || 0,
+                ccw: opt.shell && process.outputAlternating && slice.index % 2,
                 coast: firstLayer ? 0 : coastDist,
                 extrude: numOrDefault(opt.extrude, shellMult),
+                nozzleSize,
+                rate: finishShell ? finishSpeed : printSpeed,
+                scarf: (traceNo === 0 && z - startPoint?.z > 1e-3) ? scarfLength : 0,
+                tool: extruder,
+                wipe: process.outputWipeDistance || 0,
                 onfirst: function(firstPoint) {
                     let from = seedPoint || startPoint;
                     if (from.distTo2D(firstPoint) > retractDist) {
@@ -1570,6 +1574,28 @@ function slicePrintPath(print, slice, startPoint, offset, output, opt = {}) {
         }
     }
 
+    // adjust layer output speeds (by slowing them down)
+    // if layer print time is less than minimum (required for cooling)
+    if (minLayerTime) {
+        let lp, td = 0, tt = 0;
+        for (let p of preout) {
+            if (!p.emit) continue;
+            let mms = p.speed ?? 1;
+            let dst = lp?.distTo2D(p.point) ?? 0;
+            if (dst) {
+                tt += (dst/mms);
+                td += dst;
+            }
+            lp = p.point;
+        }
+        if (tt < minLayerTime) {
+            let fact = tt / minLayerTime;
+            for (let p of preout) {
+                if (p.emit) p.speed *= fact;
+            }
+        }
+    }
+
     // offset print points
     for (let i=0; i<preout.length; i++) {
         preout[i].point = preout[i].point.add(offset);

web/kiri/lang/en.js

@@ -765,8 +765,10 @@ self.lang['en-us'] = {
     ou_exml_l:      ["extrusion multiplier","0.0 - 2.0"],
     ou_fanl_s:      "fan on layer",
     ou_fanl_l:      ["layer # to turn on fan","layers start at 0"],
-    ou_fans_s:      "fan speed",
+    ou_fans_s:      "fan on speed",
     ou_fans_l:      "0 - 255",
+    ou_layt_s:      "min layer time",
+    ou_layt_l:      ["minimum allowable layer print time in seconds. printing will be slowed if the layer would outerwise complete in fewer seconds.","0 = disabled"],
 
     // OUTPUT CAM
     ou_toll_s:      "precision",
@@ -862,6 +864,8 @@ self.lang['en-us'] = {
     ad_msol_l:      ["minimum area (mm^2)","required to keep solid","must be > 0.1"],
     ad_mins_s:      "min speed",
     ad_mins_l:      ["minimum speed","for short segments"],
+    ad_scar_s:      "scarf length",
+    ad_scar_l:      ["ease up length for scarf joint","0 = disabled"],
     ad_spol_s:      "short path",
     ad_spol_l:      ["polygons shorter than this","will have their print speed","scaled down to min speed","in millimeters"],
     ad_arct_s:      "arc tolerance",