add trace inside/outside and step down. fix op reorder persistence. fix missing fields in upgraded ops

src/geo/base.js

@@ -15,6 +15,24 @@
 
     function time() { return Date.now() }
 
+    function lerp(from, to, maxInc) {
+        let dir = Math.sign(to - from);
+        let delta = Math.abs(to - from);
+        let steps = Math.floor(delta / maxInc);
+        let rem = delta % maxInc;
+        let per = delta / steps;
+        if (rem) {
+            steps++;
+            per = delta / steps;
+        }
+        let out = [];
+        while (steps-- > 0) {
+            from += per * dir;
+            out.push(from);
+        }
+        return out;
+    };
+
     function numOrDefault(num, def) {
         return num !== undefined ? num : def;
     }
@@ -377,6 +395,7 @@
 
     BASE.util = {
         sqr,
+        lerp,
         time,
         round,
         area2,

src/kiri/conf.js

@@ -450,6 +450,7 @@
                     camTraceSpindle: 1000,
                     camTraceType: "follow",
                     camTraceOver: 0.5,
+                    camTraceDown: 0,
                     camTraceSpeed: 250,
                     camTracePlunge: 200,
                     camDrillTool: 1000,

src/kiri/main.js

@@ -184,8 +184,11 @@
         trace: [
             { name: "follow" },
             { name: "clear" }
-            // { name: "out" },
+        ],
-            // { name: "in" }
+        traceoff: [
+            { name: "center" },
+            { name: "inside" },
+            { name: "outside" }
         ],
         zanchor: [
             { name: "top" },

src/mode/cam/client.js

@@ -270,6 +270,7 @@
             listel.innerHTML = html.join('');
             let bounds = [];
             let unpop = null;
+            // drag and drop re-ordering
             for (let [id, rec] of Object.entries(bind)) {
                 $(`${id}-x`).onmousedown = (ev) => {
                     ev.stopPropagation();
@@ -293,9 +294,9 @@
                     if (unpop) unpop();
                     unpop = func.unpop = el.unpop;
                     inside = true;
-                    poprec.use(rec);
                     // pointer to current rec for trace editing
                     poppedRec = rec;
+                    poprec.use(rec);
                     hoveredOp = el;
                     el.appendChild(poprec.div);
                     // option click event appears latent
@@ -326,6 +327,7 @@
                     let tracker = UI.tracker;
                     tracker.style.display = 'block';
                     let cancel = tracker.onmouseup = (ev) => {
+                        oplist = current.process.ops;
                         clist.remove("drag");
                         tracker.style.display = 'none';
                         if (ev) {
@@ -858,17 +860,21 @@
 
         createPopOp('trace', {
             mode:    'camTraceType',
+            offset:  'camTraceOffset',
             spindle: 'camTraceSpindle',
             tool:    'camTraceTool',
             step:    'camTraceOver',
+            down:    'camTraceDown',
             rate:    'camTraceSpeed',
             plunge:  'camTracePlunge'
         }).inputs = {
             tool:     UC.newSelect(LANG.cc_tool, {}, "tools"),
             sep:      UC.newBlank({class:"pop-sep"}),
             mode:     UC.newSelect(LANG.cu_type_s, {title:LANG.cu_type_l}, "trace"),
+            offset:   UC.newSelect(LANG.cc_offs_s, {title: LANG.cc_offs_l, show:() => (poppedRec.mode === 'follow')}, "traceoff"),
             spindle:  UC.newInput(LANG.cc_spnd_s, {title:LANG.cc_spnd_l, convert:UC.toInt, show:hasSpindle}),
             step:     UC.newInput(LANG.cc_sovr_s, {title:LANG.cc_sovr_l, convert:UC.toFloat, bound:UC.bound(0.01,1.0), show:(op) => popOp.trace.rec.mode === "clear"}),
+            down:     UC.newInput(LANG.cc_sdwn_s, {title:LANG.cc_sdwn_l, convert:UC.toFloat, units:true}),
             rate:     UC.newInput(LANG.cc_feed_s, {title:LANG.cc_feed_l, convert:UC.toInt, units:true}),
             plunge:   UC.newInput(LANG.cc_plng_s, {title:LANG.cc_plng_l, convert:UC.toInt, units:true}),
             sep:      UC.newBlank({class:"pop-sep"}),
@@ -930,6 +936,14 @@
             div: UC.newElement('div', { id:`${type}-op`, class:"cam-pop-op" }),
             use: (rec) => {
                 op.rec = rec;
+                for (let [key, val] of Object.entries(op.inputs)) {
+                    let type = val.type;
+                    let from = map[key];
+                    if (!rec[key] && type && from) {
+                        let newval = current.process[from];
+                        rec[key] = current.process[from];
+                    }
+                }
                 API.util.rec2ui(rec, op.inputs);
                 op.hideshow();
             },

src/mode/cam/ops.js

@@ -683,9 +683,9 @@
 
         slice(progress) {
             let { op, state } = this;
-            let { settings, widget, sliceAll, updateToolDiams } = state;
+            let { settings, widget, sliceAll, updateToolDiams, zMax } = state;
             let { process } = settings;
-            let { tool, rate, plunge } = op;
+            let { tool, rate, down, plunge, offset } = op;
             // generate tracing offsets from chosen features
             let sliceOut = this.sliceOut = [];
             let areas = op.areas[widget.id] || [];
@@ -705,15 +705,49 @@
                 sliceOut.push(slice);
                 return slice;
             }
+            function followZ(poly) {
+                let slice = newSliceOut(poly.getZ());
+                slice.camTrace = { tool, rate, plunge };
+                slice.camLines = [ poly ];
+                slice.output()
+                    .setLayer("follow", {line: 0xaa00aa}, false)
+                    .addPolys(slice.camLines)
+            }
+            function clearZ(polys, z) {
+                let slice = newSliceOut(z = parseFloat(z));
+                slice.camTrace = { tool, rate, plunge };
+                POLY.offset(POLY.nest(polys), -toolOver, {
+                    count:999, outs: slice.camLines = [], flat:true, z
+                });
+                slice.camLines = POLY.flatten(slice.camLines, null, true);
+                POLY.setWinding(slice.camLines, cutdir, false);
+                slice.output()
+                    .setLayer("clear", {line: 0xaa00aa}, false)
+                    .addPolys(slice.camLines)
+            }
             switch (op.mode) {
                 case "follow":
                     for (let poly of polys) {
-                        let slice = newSliceOut(poly.getZ());
+                        let offdist = 0;
-                        slice.camTrace = { tool, rate, plunge };
+                        switch (offset) {
-                        slice.camLines = [ poly ];
+                            case "outside": offdist = toolDiam / 2; break;
-                        slice.output()
+                            case "inside": offdist = -toolDiam / 2; break;
-                            .setLayer("follow", {line: 0xaa00aa}, false)
+                        }
-                            .addPolys(slice.camLines)
+                        if (offdist) {
+                            let pnew = POLY.offset([poly], offdist)[0];
+                            if (pnew) {
+                                poly = pnew.setZ(poly.getZ());
+                            } else {
+                                continue;
+                            }
+                        }
+                        if (down) {
+                            for (let z of BASE.util.lerp(zMax, poly.getZ(), down)) {
+                                followZ(poly.clone().setZ(z));
+                            }
+                        } else {
+                            followZ(poly);
+                        }
                     }
                     break;
                 case "clear":
@@ -722,17 +756,14 @@
                         let z = poly.getZ();
                         (zmap[z] = zmap[z] || []).push(poly);
                     }
-                    for (let [z, polys] of Object.entries(zmap)) {
+                    for (let [zv, polys] of Object.entries(zmap)) {
-                        let slice = newSliceOut(z = parseFloat(z));
+                        if (down) {
-                        slice.camTrace = { tool, rate, plunge };
+                            for (let z of BASE.util.lerp(zMax, zv, down)) {
-                        POLY.offset(POLY.nest(polys), -toolOver, {
+                                clearZ(polys, z);
-                            count:999, outs: slice.camLines = [], flat:true, z
+                            }
-                        });
+                        } else {
-                        slice.camLines = POLY.flatten(slice.camLines, null, true);
+                            clearZ(polys, z);
-                        POLY.setWinding(slice.camLines, cutdir, false);
+                        }
-                        slice.output()
-                            .setLayer("clear", {line: 0xaa00aa}, false)
-                            .addPolys(slice.camLines)
                     }
             }
         }

web/kiri/lang/en.js

@@ -262,6 +262,8 @@ kiri.lang['en-us'] = {
 
     // CNC COMMON terms
     cc_tool:        "tool",
+    cc_offs_s:      "offset",
+    cc_offs_l:      "offset tool center\nfrom chosen path",
     cc_spnd_s:      "spindle rpm",
     cc_spnd_l:      "spindle speed in\nrevolutions / minute",
     cc_sovr_s:      "step over",