distinguish colors per extruder. fix purge blocks, print gaps, empty slices

js/kiri-driver-fdm.js

@@ -509,7 +509,15 @@ let gs_kiri_fdm = exports;
                     preout.last().retract = true;
                 }
             }
-            // TODO recompute bounds for purge block offsets
+            // recompute bounds for purge block offsets
+            let bbounds = BASE.newBounds();
+            brims.forEach(brim => {
+                bbounds.merge(brim.bounds);
+            });
+            bounds.min.x = Math.min(bounds.min.x, bbounds.minx);
+            bounds.min.y = Math.min(bounds.min.y, bbounds.miny);
+            bounds.max.x = Math.max(bounds.max.x, bbounds.maxx);
+            bounds.max.y = Math.max(bounds.max.y, bbounds.maxy);
         }
 
         let extruders = [];
@@ -520,7 +528,7 @@ let gs_kiri_fdm = exports;
         widgets.forEach(function(widget) {
             maxLayers = Math.max(maxLayers, widget.slices.length);
             let extruder = settings.widget[widget.id].extruder;
-            if (extruders.indexOf(extruder) < 0) {
+            if (!extruders[extruder]) {
                 extruders[extruder] = {};
                 extcount++;
             }
@@ -528,12 +536,12 @@ let gs_kiri_fdm = exports;
 
         let blokpos, walkpos, blok;
         if (bounds.min.x < bounds.min.y) {
-            let dx = ((bounds.max.x - bounds.min.x) - (extcount * 5)) / 2;
+            let dx = ((bounds.max.x - bounds.min.x) - (extcount * 10)) / 2 + 5;
             blokpos = { x:bounds.min.x + dx, y: bounds.max.y + 5};
             walkpos  = { x:10, y:0 };
             blok = { x:9, y:4 };
         } else {
-            let dy = ((bounds.max.y - bounds.min.y) - (extcount * 5)) / 2;
+            let dy = ((bounds.max.y - bounds.min.y) - (extcount * 10)) / 2 + 5;
             blokpos = { x:bounds.max.x + 5, y: bounds.min.y + dy};
             walkpos  = { x:0, y:10 };
             blok = { x:4, y:9 };
@@ -555,6 +563,9 @@ let gs_kiri_fdm = exports;
 
         // generate purge block for given nozzle
         function purge(nozzle, track, layer, start, z, using) {
+            if (extcount < 2) {
+                return start;
+            }
             let rec = track[nozzle];
             if (rec) {
                 track[nozzle] = null;
@@ -573,7 +584,9 @@ let gs_kiri_fdm = exports;
             // create list of mesh slice arrays with their platform offsets
             for (meshIndex = 0; meshIndex < widgets.length; meshIndex++) {
                 let mesh = widgets[meshIndex].mesh;
-                if (!mesh.widget) continue;
+                if (!mesh.widget) {
+                    continue;
+                }
                 let mslices = mesh.widget.slices;
                 if (mslices && mslices[layer]) {
                     slices.push({slice:mslices[layer], offset:mesh.position});
@@ -581,11 +594,14 @@ let gs_kiri_fdm = exports;
             }
 
             // exit if no slices
-            if (slices.length === 0) break;
+            if (slices.length === 0) {
+                break;
+            }
 
             // track purge blocks generated for each layer
             let track = extruders.slice();
             let lastOut;
+            let lastExt;
 
             // iterate over layer slices, find closest widget, print, eliminate
             for (;;) {
@@ -603,7 +619,10 @@ let gs_kiri_fdm = exports;
                     }
                     found++;
                 }
-                if (!closest) break;
+                if (!closest) {
+                    if (sliceEntry) lastOut = sliceEntry.slice;
+                    break;
+                }
                 // retract between widgets
                 if (layerout.length && minidx !== lastIndex) {
                     layerout.last().retract = true;
@@ -623,10 +642,19 @@ let gs_kiri_fdm = exports;
                     layerout,
                     { first: closest.slice.index === 0 }
                 );
-                lastOut = closest.slice,
+                lastOut = closest.slice;
+                lastExt = lastOut.ext
                 lastIndex = minidx;
             }
 
+            // if a declared extruder isn't used in a layer, use selected
+            // extruder to fill the relevant purge blocks for later support
+            track.forEach(ext => {
+                if (ext) {
+                    printPoint = purge(ext.extruder, track, layerout, printPoint, lastOut.z, lastExt);
+                }
+            });
+
             // if layer produced output, append to output array
             if (layerout.length) output.append(layerout);
 
@@ -634,15 +662,6 @@ let gs_kiri_fdm = exports;
             layerout.layer = layer++;
             update(layer / maxLayers);
 
-            // if a declared extruder isn't used in a layer, use selected
-            // extruder to fill the relevant purge blocks for later support
-            track.forEach(ext => {
-                if (ext) {
-                    console.log({purge_block_unused: ext.extruder, using: lastOut.extruder});
-                    printPoint = purge(ext.extruder, track, layerout, printPoint, lastOut.z, lastOut.extruder);
-                }
-            });
-
             // retract after last layer
             if (layer === maxLayers && layerout.length) {
                 layerout.last().retract = true;

js/kiri-slice.js

@@ -20,7 +20,21 @@ var gs_kiri_slice = exports;
         MIN = Math.min,
         MAX = Math.max,
         NOKEY = BASE.key.NONE,
-        outline_colors = [0xffff00, 0x00ffff, 0xff00ff, 0xff0000, 0x00ff00, 0x0000ff, 0xffffff, 0x000000],
+        outline_colors = [
+            0xffff00,
+            0xffcc00,
+            0xff9900
+        ],
+        debug_colors = [
+            0xffff00,
+            0x00ffff,
+            0xff00ff,
+            0xff0000,
+            0x00ff00,
+            0x0000ff,
+            0xffffff,
+            0x000000
+        ],
         trace_color = 0x000000,
         sparse_fill_color = 0x333366,
         fill_offset_color = 0xeeeeee,
@@ -312,14 +326,14 @@ var gs_kiri_slice = exports;
      *
      * @param {number} renderMode
      */
-    PRO.renderOutline = function(renderMode) {
+    PRO.renderOutline = function(renderMode,color) {
         if (!this.view) return;
 
         var process = KIRI.driver.CAM.process,
             slice = this,
             layers = slice.layers,
             layer = layers.outline,
-            colors = outline_colors,
+            colors = debug_colors,
             groups = slice.groups ? slice.groups.sort(function(a,b) { return b.area() - a.area() }) : null,
             tops = slice.tops,
             pbuf = [],
@@ -360,8 +374,9 @@ var gs_kiri_slice = exports;
                 break;
             // all polygons in yellow
             case 4:
+                colors = outline_colors;
                 tops.forEach(function(top) {
-                    layer.poly(top.poly, colors[0], true, open);
+                    layer.poly(top.poly, colors[color], true, open);
                     if (top.inner) layer.poly(top.inner, 0x999999, true, null);
                     // if (top.thinner) layer.poly(top.thinner, 0x559999, true, null);
                 });

js/kiri-slicer.js

@@ -471,7 +471,7 @@ var gs_kiri_slicer = exports;
             }
 
             // allow empty slices in CAM swap mode (for topos w/ gaps)
-            if (lines.length == 0 && !(options.swapX || options.swapY)) return;
+            // if (lines.length == 0 && !(options.swapX || options.swapY)) return;
 
             slice.height = height;
             slice.index = slices.length;

js/kiri-widget.js

@@ -409,7 +409,10 @@ let gs_kiri_widget = exports;
     /**
      * @param {number} color
      */
-    PRO.setColor = function(color) {
+    PRO.setColor = function(color,settings) {
+        if (Array.isArray(color)) {
+            color = color[this.getExtruder(settings) % color.length];
+        }
         let material = this.mesh.material;
         material.color.set(color);
     };
@@ -618,6 +621,14 @@ let gs_kiri_widget = exports;
         return this.modified;
     };
 
+    PRO.getExtruder = function(settings) {
+        if (settings && settings.widget) {
+            let rec = settings.widget[this.id];
+            return rec && rec.extruder >= 0 ? rec.extruder : 0;
+        }
+        return 0;
+    };
+
     /**
      * processes points into facets, then into slices
      *
@@ -728,8 +739,9 @@ let gs_kiri_widget = exports;
     PRO.render = function(renderMode, cam) {
         let slices = this.slices;
         if (!slices) return;
+        let extruder = this.getExtruder(this.settings);
         // render outline
-        slices.forEach(function(s) { s.renderOutline(renderMode) });
+        slices.forEach(function(s) { s.renderOutline(renderMode,extruder) });
         // render shells
         slices.forEach(function(s) { s.renderShells(renderMode) });
         // render diff

js/kiri.js

@@ -115,8 +115,8 @@ self.kiri.copyright = exports.COPYRIGHT;
     const color = {
         wireframe: 0x444444,
         wireframe_opacity: 0.25,
-        selected: 0xbbff00,
+        selected: [ 0xbbff00, 0xbbee00, 0xbbdd00 ],
-        deselected: 0xffff00,
+        deselected: [ 0xffff00, 0xffdd00, 0xffbb00 ],
         slicing: 0xffaaaa,
         preview_opacity: 0.0,
         model_opacity: 1.0,
@@ -1004,7 +1004,7 @@ self.kiri.copyright = exports.COPYRIGHT;
             if (!shift) platform.deselect();
             selectedMeshes.push(mesh);
             API.event.emit('widget.select', widget);
-            widget.setColor(color.selected);
+            widget.setColor(color.selected, settings);
             updateSelectedInfo();
         }
         platformUpdateSelected();
@@ -1050,7 +1050,7 @@ self.kiri.copyright = exports.COPYRIGHT;
             selectedMeshes.splice(si,1);
             API.event.emit('widget.deselect', widget);
         }
-        widget.setColor(color.deselected);
+        widget.setColor(color.deselected, settings);
         platformUpdateSelected();
         SPACE.update();
         updateSelectedInfo();