1089 lines
43 KiB
JavaScript
1089 lines
43 KiB
JavaScript
/** Copyright Stewart Allen <sa@grid.space> -- All Rights Reserved */
|
|
|
|
"use strict";
|
|
|
|
(function() {
|
|
|
|
let KIRI = self.kiri,
|
|
BASE = self.base,
|
|
UTIL = BASE.util,
|
|
POLY = BASE.polygons,
|
|
FDM = KIRI.driver.FDM,
|
|
newPoint = BASE.newPoint,
|
|
newPolygon = BASE.newPolygon,
|
|
getRangeParameters = FDM.getRangeParameters,
|
|
debug = false;
|
|
|
|
/**
|
|
* DRIVER PRINT CONTRACT
|
|
*
|
|
* @param {Function} update progress callback
|
|
* @returns {Object[]} returns array of render objects
|
|
*/
|
|
FDM.prepare = function(widgets, settings, update) {
|
|
// filter ignored widgets
|
|
widgets = widgets.filter(w => !w.track.ignore && !w.meta.disabled);
|
|
|
|
let render = settings.render !== false,
|
|
{ device, process, controller, bounds, mode } = settings,
|
|
{ bedWidth, bedDepth } = device,
|
|
output = [],
|
|
printPoint = newPoint(0,0,0),
|
|
nozzle = device.extruders[0].extNozzle,
|
|
isBelt = device.bedBelt,
|
|
isThin = controller.lineType === "line",
|
|
isFlat = controller.lineType === "flat",
|
|
isDanger = controller.danger || false,
|
|
isPalette = device.filamentSource === 'palette3',
|
|
firstLayerHeight = isBelt ? process.sliceHeight : process.firstSliceHeight || process.sliceHeight,
|
|
firstLayerSeek = process.outputSeekrate,
|
|
firstLayerRate = process.firstLayerRate,
|
|
firstLayerMult = process.firstLayerPrintMult,
|
|
purgeTower = process.outputPurgeTower || 0,
|
|
layerRetract = process.outputLayerRetract,
|
|
layerno = 0,
|
|
zoff = 0,
|
|
zmin = 0,
|
|
layerout = [],
|
|
print = self.worker.print = KIRI.newPrint(settings, widgets),
|
|
beltfact = Math.cos(Math.PI/4);
|
|
|
|
// compute bounds if missing
|
|
if (!bounds) {
|
|
bounds = new THREE.Box3();
|
|
for (let widget of widgets) {
|
|
let wp = widget.track.pos;
|
|
let wb = widget.bounds.clone();
|
|
wb.min.x += wp.x;
|
|
wb.max.x += wp.x;
|
|
wb.min.y += wp.y;
|
|
wb.max.y += wp.y;
|
|
bounds.union(wb);
|
|
}
|
|
settings.bounds = bounds;
|
|
}
|
|
|
|
// TODO pick a widget with a slice on the first layer and use that nozzle
|
|
// create brim, skirt, raft if specificed in FDM mode (code shared by laser)
|
|
if (!isBelt && (process.outputBrimCount || process.outputRaft)) {
|
|
let brims = [],
|
|
offset = process.outputBrimOffset || (process.outputRaft ? 4 : 0);
|
|
|
|
// compute first brim
|
|
widgets.filter(w => w.slices.length).forEach(function(widget) {
|
|
let tops = [];
|
|
// collect top outer polygons
|
|
widget.slices[0].tops.forEach(function(top) {
|
|
tops.push(top.poly.clone());
|
|
});
|
|
// collect support polygons
|
|
if (widget.slices[0].supports)
|
|
widget.slices[0].supports.forEach(function(support) {
|
|
tops.push(support.clone());
|
|
});
|
|
// nest and offset tops
|
|
POLY.nest(tops).forEach(function(poly) {
|
|
let off = poly.offset(-offset + nozzle / 2);
|
|
if (off) off.forEach(function(brim) {
|
|
brim.move(widget.track.pos);
|
|
brims.push(brim);
|
|
});
|
|
});
|
|
});
|
|
|
|
// merge brims
|
|
brims = POLY.union(brims, undefined, true);
|
|
|
|
// if brim is offset, over-expand then shrink to induce brims to merge
|
|
if (brims.length) {
|
|
let extra = process.sliceSupportExtra + 2;
|
|
let zheight = brims[0].getZ();
|
|
brims = POLY.expand(brims, extra, zheight, null, 1);
|
|
brims = POLY.expand(brims, -extra, zheight, null, 1);
|
|
}
|
|
|
|
// if raft is specified
|
|
if (process.outputRaft) {
|
|
let offset = newPoint(0,0,0),
|
|
height = nozzle;
|
|
|
|
// cause first point of raft to be used
|
|
printPoint = null;
|
|
|
|
let raft = function(height, angle, spacing, speed, extrude) {
|
|
let slice = KIRI.newSlice(zoff + height / 2);
|
|
brims.forEach(function(brim) {
|
|
// use first point of first brim as start point
|
|
if (printPoint === null) printPoint = brim.first();
|
|
let t = slice.addTop(brim);
|
|
t.traces = [ brim ];
|
|
t.inner = POLY.expand(t.traces, -nozzle * 0.5, 0, null, 1);
|
|
// tweak bounds for fill to induce an offset
|
|
t.inner[0].bounds.minx -= nozzle/2;
|
|
t.inner[0].bounds.maxx += nozzle/2;
|
|
t.fill_lines = POLY.fillArea(t.inner, angle, spacing, []);
|
|
})
|
|
offset.z = slice.z;
|
|
printPoint = print.slicePrintPath(slice, printPoint, offset, layerout, {
|
|
speed: speed,
|
|
mult: extrude,
|
|
});
|
|
layerout.z = zoff + height;
|
|
layerout.height = height;
|
|
output.append(layerout);
|
|
|
|
layerout = [];
|
|
zoff += height;
|
|
};
|
|
|
|
raft(nozzle/1, process.sliceFillAngle + 0 , nozzle * 5.0, firstLayerRate / 3, 4);
|
|
raft(nozzle/1, process.sliceFillAngle + 0 , nozzle * 5.0, firstLayerRate / 2, 4);
|
|
raft(nozzle/2, process.sliceFillAngle + 90, nozzle * 3.0, process.outputFeedrate, 2.5);
|
|
raft(nozzle/2, process.sliceFillAngle + 0 , nozzle * 1.0, process.outputFeedrate, 1.5);
|
|
raft(nozzle/2, process.sliceFillAngle + 90 , nozzle * 0.7, process.outputFeedrate, 0.75);
|
|
|
|
// raise first layer off raft slightly to lessen adhesion
|
|
firstLayerHeight += process.outputRaftSpacing || 0;
|
|
zoff += process.outputRaftSpacing || 0;
|
|
|
|
// retract after last raft layer
|
|
output.last().last().retract = true;
|
|
}
|
|
// raft excludes brims
|
|
else
|
|
// if using brim vs raft
|
|
if (process.outputBrimCount) {
|
|
let polys = [],
|
|
preout = [];
|
|
|
|
// offset specified # of brims
|
|
POLY.offset(brims, nozzle, {
|
|
outs: polys,
|
|
flat: true,
|
|
count: process.outputBrimCount,
|
|
z: firstLayerHeight / 2
|
|
});
|
|
|
|
print.setType('brim');
|
|
|
|
// output brim points
|
|
let brimStart = offset < nozzle * 2 ? newPoint(-bedWidth, -bedDepth, 0) : printPoint;
|
|
printPoint = print.poly2polyEmit(polys, brimStart, (poly, index, count, startPoint) => {
|
|
return print.polyPrintPath(poly, startPoint, preout, {
|
|
rate: firstLayerRate,
|
|
onfirst: function(point) {
|
|
if (preout.length && point.distTo2D(startPoint) > 2) {
|
|
// retract between brims
|
|
preout.last().retract = true;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
print.addPrintPoints(preout, layerout, null);
|
|
|
|
if (preout.length) {
|
|
// retract between brims and print
|
|
preout.last().retract = true;
|
|
}
|
|
}
|
|
// 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);
|
|
}
|
|
|
|
// synthesize support widgets when needed
|
|
// so that they can use a separate extruder
|
|
// compute zmin for belt purge towers
|
|
for (let widget of widgets.slice()) {
|
|
let sslices = [];
|
|
if (!widget.slices) {
|
|
console.log('invalid widget', widget);
|
|
continue;
|
|
}
|
|
for (let slice of widget.slices) {
|
|
zmin = Math.min(zmin, slice.z);
|
|
if (!slice.supports) {
|
|
continue;
|
|
}
|
|
let sslice = KIRI.newSlice(slice.z);
|
|
sslice.extruder = process.sliceSupportNozzle;
|
|
sslice.supports = slice.supports.slice();
|
|
sslice.height = slice.height;
|
|
sslices.push(sslice);
|
|
}
|
|
if (sslices.length) {
|
|
let swidget = KIRI.newWidget(null,widget.group);
|
|
swidget.slices = sslices;
|
|
swidget.support = true;
|
|
swidget.rotinfo = widget.rotinfo;
|
|
swidget.belt = widget.belt;
|
|
swidget.track = Object.clone(widget.track);
|
|
swidget.mesh = { widget: swidget, position: swidget.track.pos };
|
|
widget.anno.extruder = process.sliceSupportNozzle;
|
|
widgets.push(swidget);
|
|
}
|
|
}
|
|
|
|
let lastPoly;
|
|
let lastLayer;
|
|
let lastOffset;
|
|
let extruders = print.extruders = [];
|
|
let extcount = 0;
|
|
|
|
// find max layers (for updates)
|
|
// generate list of used extruders for purge blocks
|
|
for (let widget of widgets) {
|
|
let extruder = widget.anno.extruder || 0;
|
|
if (!extruders[extruder]) {
|
|
extruders[extruder] = {};
|
|
extcount++;
|
|
}
|
|
}
|
|
|
|
// determine size/location of purge blocks
|
|
let blokw = Math.sqrt(purgeTower);
|
|
let blokh = blokw;
|
|
let blokpos, walkpos, blok;
|
|
|
|
function mkblok(w,h) {
|
|
let count = extcount - 1;
|
|
let gap = nozzle;
|
|
if (isBelt) {
|
|
let step = w + gap;
|
|
let mp = (bounds.max.y + bounds.min.y) / 2; // part y midpoint
|
|
let sp = (bounds.max.y - bounds.min.y); // part y span
|
|
let ts = (w * count) + (gap * (count - 1)); // tower y span
|
|
let ty = -ts + w/2 - gap/2; // tower start y
|
|
blokpos = { y:ty, x: bounds.max.x + 2 + h / 2}; // first block pos
|
|
walkpos = { y:step, x:0 };
|
|
blok = { x:h, y:w };
|
|
} else if (bounds.min.x < bounds.min.y) {
|
|
let step = h + gap;
|
|
let mp = (bounds.max.x + bounds.min.x) / 2; // part y midpoint
|
|
let sp = (bounds.max.x - bounds.min.x); // part y span
|
|
let ts = (h * count) + (gap * (count - 1)); // tower y span
|
|
let tx = mp - ts / 2 + step / 2; // tower start y
|
|
blokpos = { x:tx, y: bounds.max.y + 2 + w / 2}; // first block pos
|
|
walkpos = { x:step, y:0 };
|
|
blok = { x:w, y:h };
|
|
} else {
|
|
let step = w + gap;
|
|
let mp = (bounds.max.y + bounds.min.y) / 2; // part y midpoint
|
|
let sp = (bounds.max.y - bounds.min.y); // part y span
|
|
let ts = (w * count) + (gap * (count - 1)); // tower y span
|
|
let ty = mp - ts / 2 + step / 2; // tower start y
|
|
blokpos = { y:ty, x: bounds.max.x + 2 + h / 2}; // first block pos
|
|
walkpos = { y:step, x:0 };
|
|
blok = { x:w, y:h };
|
|
}
|
|
}
|
|
|
|
function mkrec(i, angle = 45, thin = 6) {
|
|
let exi = device.extruders[i],
|
|
noz = exi.extNozzle,
|
|
pos = {x:blokpos.x + walkpos.x * i, y:blokpos.y + walkpos.y * i, z:0},
|
|
rect = newPolygon().centerRectangle(pos, blok.x, blok.y),
|
|
full = linesToPoly(POLY.fillArea([
|
|
newPolygon().centerRectangle(pos, blok.x - noz, blok.y - noz)
|
|
], angle, noz)),
|
|
sparse = rect.area() > 10 ? linesToPoly(POLY.fillArea([
|
|
newPolygon().centerRectangle(pos, blok.x - noz, blok.y - noz)
|
|
], angle + 90, noz * thin)) : newPolygon(),
|
|
rec = {
|
|
extruder: i,
|
|
diameter: exi.extNozzle,
|
|
rect,
|
|
full,
|
|
sparse,
|
|
pause: newPoint(pos.x + walkpos.y, pos.y + walkpos.x, pos.z)
|
|
};
|
|
return rec;
|
|
}
|
|
|
|
mkblok(blokw, blokh);
|
|
|
|
// allocate tower space for extruders-1 locations
|
|
let towers = extruders.slice(1).map((ext,i) => {
|
|
return ext ? mkrec(i) : ext;
|
|
});
|
|
|
|
function linesToPoly(points) {
|
|
let poly = newPolygon().setOpen();
|
|
let ping = 0;
|
|
for (let i=0; i<points.length; i += 2) {
|
|
let p1 = points[i];
|
|
let p2 = points[i+1];
|
|
if (ping++ % 2 === 0) {
|
|
poly.push(p1);
|
|
poly.push(p2);
|
|
} else {
|
|
poly.push(p2);
|
|
poly.push(p1);
|
|
}
|
|
}
|
|
return poly;
|
|
}
|
|
|
|
let purgedFirst = false;
|
|
let lastPurgeTool;
|
|
|
|
// generate purge block for given nozzle
|
|
function purge(nozzle, track, layer, start, z, using, offset) {
|
|
if (!purgeTower || extcount < 2) {
|
|
return start;
|
|
}
|
|
let rec = track.shift();
|
|
let thin = using >= 0 || lastPurgeTool === nozzle;
|
|
let tool = using >= 0 ? using : nozzle;
|
|
let first = isBelt ? !purgedFirst && layer.slice.index >= 0 : layer.slice.index === 0;
|
|
let rate = first ? process.firstLayerRate : process.outputFeedrate;
|
|
let wipe = true;
|
|
lastPurgeTool = tool;
|
|
if (rec) {
|
|
print.setType('purge tower');
|
|
if (layer.last()) {
|
|
layer.last().retract = true;
|
|
}
|
|
purgedFirst = purgedFirst || first;
|
|
let purgeOn = first || !thin;
|
|
if (isBelt && z < 0) {
|
|
let scale = 1 - ((z / zmin));
|
|
mkblok(blokw * scale, blokh);
|
|
rec = mkrec(rec.extruder, 0, 10);
|
|
rate = (process.outputFeedrate - process.firstLayerRate) * scale + process.firstLayerRate;
|
|
wipe = false;
|
|
}
|
|
let box = rec.rect.clone().setZ(z);
|
|
let pause = rec.pause.clone().setZ(z);
|
|
let fill = (z >= 0 && purgeOn ? rec.full : rec.sparse).clone().setZ(z);
|
|
if (isBelt) {
|
|
let bmove = {x:0, y:z, z:0};
|
|
box.move(bmove);
|
|
pause.move(bmove);
|
|
if (fill) {
|
|
fill.move(bmove);
|
|
}
|
|
if (offset) {
|
|
let bo = { x:0, y:offset.y, z:offset.z };
|
|
box.move(bo);
|
|
pause.move(bo);
|
|
if (fill) fill.move(bo);
|
|
}
|
|
}
|
|
start = print.polyPrintPath(box, start, layer, {
|
|
tool,
|
|
rate,
|
|
simple: true,
|
|
open: false,
|
|
onfirstout: (out => out.overate = (isBelt ? rate : 0))
|
|
});
|
|
if (fill && fill.length) {
|
|
// for pings, split path at 20mm
|
|
start = print.polyPrintPath(fill, start, layer, {
|
|
tool,
|
|
rate,
|
|
simple: true,
|
|
open: true,
|
|
onfirst: (point) => { point.purgeOn = purgeOn ? pause : undefined }
|
|
});
|
|
}
|
|
layer.last().retract = true;
|
|
// experimental post-retract wipe
|
|
if (wipe) start = print.polyPrintPath(box, start, layer, {
|
|
tool,
|
|
rate,
|
|
simple: true,
|
|
open: false,
|
|
extrude: 0
|
|
});
|
|
layer.last().overate = 0;
|
|
return start;
|
|
} else {
|
|
console.log({no_purge_tower_for: nozzle, using, track, layer});
|
|
return start;
|
|
}
|
|
}
|
|
|
|
// establish offsets
|
|
for (let widget of widgets) {
|
|
let { rotinfo, belt } = widget;
|
|
let offset = Object.clone(widget.track.pos);
|
|
if (isBelt) {
|
|
let o = rotinfo.ypos * beltfact;
|
|
offset = {
|
|
x: rotinfo.xpos,
|
|
y: o,
|
|
z: o
|
|
};
|
|
} else {
|
|
// when rafts used this is non-zero
|
|
offset.z = zoff;
|
|
}
|
|
widget.offset = offset;
|
|
}
|
|
|
|
// create shuffled slice cake by z offset (slice.z + offset.z)
|
|
let cake = [];
|
|
let zrec = {};
|
|
for (let widget of widgets) {
|
|
// skip synthesized support widget(s)
|
|
if (!widget.mesh) {
|
|
continue;
|
|
}
|
|
for (let slice of widget.slices) {
|
|
slice.widget = widget;
|
|
let z = (slice.z + widget.offset.z).round(2);
|
|
let rec = zrec[z] = zrec[z] || {z, slices:[]};
|
|
if (rec.slices.length === 0) {
|
|
cake.push(rec);
|
|
}
|
|
rec.slices.push(slice);
|
|
}
|
|
}
|
|
cake.sort((a, b) => {
|
|
return a.z - b.z;
|
|
});
|
|
|
|
let firstExt;
|
|
let lastWidget;
|
|
let lastExt;
|
|
let lastOut;
|
|
|
|
// walk cake layers bottom up
|
|
for (let layer of cake) {
|
|
// track purge blocks generated for each layer
|
|
let track = towers.slice();
|
|
|
|
// iterate over layer slices, find closest widget, print, eliminate
|
|
for (;;) {
|
|
let order = [];
|
|
// select slices of the same extruder type first then distance
|
|
for (let slice of layer.slices) {
|
|
if (slice.prep) {
|
|
continue;
|
|
}
|
|
let offset = lastOffset = slice.widget.offset;
|
|
let find = slice.findClosestPointTo(printPoint.sub(offset));
|
|
if (find) {
|
|
let ext = slice.extruder;
|
|
let lex = lastExt;
|
|
let dst = Math.abs(find.distance);
|
|
// penalize extruder swaps
|
|
if (ext !== lex) {
|
|
dst *= 10000;
|
|
}
|
|
// for first object, penalize extruders other than first
|
|
if (lastExt === undefined && ext > 0) {
|
|
dst *= 10000;
|
|
}
|
|
order.push({dst, slice, offset, z: layer.z});
|
|
}
|
|
}
|
|
if (order.length === 0) {
|
|
break;
|
|
}
|
|
order.sort((a,b) => {
|
|
return a.dst - b.dst;
|
|
});
|
|
let { z, slice, offset } = order[0];
|
|
if (firstExt === undefined) {
|
|
firstExt = slice.extruder;
|
|
}
|
|
let params = getRangeParameters(process, slice.index);
|
|
slice.prep = true;
|
|
// retract between widgets or layers (when set)
|
|
if (layerout.length && slice.widget !== lastWidget) {
|
|
layerout.last().retract = true;
|
|
}
|
|
lastWidget = slice.widget;
|
|
layerout.z = z + slice.height / 2;
|
|
layerout.height = layerout.height || slice.height;
|
|
layerout.slice = slice;
|
|
// mark layer as anchor if slice is belt and flag set
|
|
layerout.anchor = slice.belt && slice.belt.anchor;
|
|
// detect extruder change and print purge block
|
|
if (!lastOut || lastOut.extruder !== slice.extruder) {
|
|
if (slice.extruder >= 0)
|
|
printPoint = purge(slice.extruder, track, layerout, printPoint, slice.z, undefined, offset);
|
|
}
|
|
let wtb = slice.widget.track.box;
|
|
let beltStart = slice.belt && slice.belt.touch;// && (widgets.length === 1);
|
|
// output seek to start point between mesh slices if previous data
|
|
print.setType('layer');
|
|
printPoint = print.slicePrintPath(
|
|
slice,
|
|
beltStart ? newPoint(-5000, 5000, 0) : printPoint.sub(offset),
|
|
offset,
|
|
layerout,
|
|
{
|
|
routeAround: process.outputAvoidGaps,
|
|
seedPoint: printPoint.sub(offset),
|
|
danger: isDanger,
|
|
params, // range parameters
|
|
first: slice.index === 0,
|
|
support: slice.widget.support,
|
|
onBelt: beltStart,
|
|
pretract: (wipeDist) => {
|
|
if (lastLayer && lastLayer.length) {
|
|
let lastOut = lastLayer.last();
|
|
lastOut.retract = true;
|
|
if (wipeDist && lastPoly && lastOut.point) {
|
|
let endpoint = lastOut.point.followTo(lastPoly.center(true).add(offset), wipeDist);
|
|
if (endpoint.inPolygon(lastPoly)) {
|
|
print.addOutput(lastLayer, endpoint);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
);
|
|
lastOut = slice;
|
|
lastExt = lastOut.extruder;
|
|
lastPoly = slice.lastPoly;
|
|
lastLayer = layerout;
|
|
if (layerRetract && layerout.length) {
|
|
layerout.last().retract = true;
|
|
}
|
|
}
|
|
|
|
// clear slice.prep so it can be re-previewed in a different mode
|
|
for (let widget of widgets) {
|
|
// skip synthesized support widget(s)
|
|
if (!widget.mesh) {
|
|
continue;
|
|
}
|
|
for (let slice of widget.slices) {
|
|
slice.prep = false;
|
|
}
|
|
}
|
|
|
|
// if a declared extruder isn't used in a layer, use selected
|
|
// extruder to fill the relevant purge blocks for later support
|
|
track.slice().forEach(ext => {
|
|
printPoint = purge(ext.extruder, track, layerout, printPoint, lastOut.z, lastExt, lastOffset);
|
|
});
|
|
|
|
// if layer produced output, append to output array
|
|
if (layerout.length) {
|
|
output.append(layerout);
|
|
}
|
|
|
|
// retract after last layer
|
|
if (layerno === cake.length - 1 && layerout.length) {
|
|
layerout.last().retract = true;
|
|
}
|
|
|
|
// notify progress
|
|
layerout.layer = layerno++;
|
|
update((layerno / cake.length) * 0.5, "prepare");
|
|
|
|
layerout = [];
|
|
}
|
|
|
|
print.output = output;
|
|
|
|
// post-process for base extrusions (touching the bed)
|
|
if (isBelt) {
|
|
// tune base threshold
|
|
let thresh = Infinity;
|
|
for (let layer of output) {
|
|
for (let rec of layer) {
|
|
let point = rec.point;
|
|
thresh = Math.min(thresh, point.z - point.y);
|
|
}
|
|
}
|
|
// store this offset to be removed from Y values in export
|
|
print.belty = thresh;
|
|
thresh = thresh + firstLayerHeight * 0.25;
|
|
// iterate over layers, find extrusion on belt and
|
|
// apply corrections and add brim when specified
|
|
for (let layer of output) {
|
|
let params = getRangeParameters(process, layer.layer || 0);
|
|
let brimHalf = params.firstLayerBrim < 0;
|
|
let firstLayerBrim = Math.abs(params.firstLayerBrim);
|
|
let firstLayerBrimIn = params.firstLayerBrimIn || 0;
|
|
let firstLayerBrimTrig = params.firstLayerBrimTrig || 0;
|
|
let firstLayerBrimGap = params.firstLayerBrimGap || 0;
|
|
let lastout, first = false;
|
|
let minz = Infinity, maxy = -Infinity, minx = Infinity, maxx = -Infinity;
|
|
let mins = Infinity;
|
|
let miny = Infinity;
|
|
let pads = [];
|
|
let overate = 0;
|
|
|
|
for (let rec of layer) {
|
|
overate = rec.overate >= 0 ? rec.overate : overate;
|
|
let brate = params.firstLayerRate || firstLayerRate;
|
|
let bmult = params.firstLayerPrintMult || firstLayerMult;
|
|
let point = rec.point;
|
|
let belty = rec.belty = -point.y + point.z;
|
|
let lowrate = belty <= thresh ? brate : overate || brate;
|
|
miny = Math.min(miny, belty);
|
|
if (layer.anchor) {
|
|
// apply base rate to entire anchor (including bump)
|
|
rec.speed = Math.min(rec.speed, lowrate);
|
|
}
|
|
if (rec.emit && belty <= thresh && lastout && Math.abs(lastout.belty - belty) < 0.005) {
|
|
// apply base speed to segments touching belt
|
|
rec.speed = Math.min(rec.speed, lowrate);
|
|
rec.emit *= bmult;
|
|
minx = Math.min(minx, point.x, lastout.point.x);
|
|
maxx = Math.max(maxx, point.x, lastout.point.x);
|
|
maxy = Math.max(maxy, point.y);
|
|
minz = Math.min(minz, point.z);
|
|
first = rec;
|
|
// find length of shortest bed-facing segment
|
|
mins = Math.min(mins, lastout.point.distTo2D(rec.point));
|
|
// add to pads list if > 1mm long
|
|
if (point.x - lastout.point.x > 1) {
|
|
pads.push([lastout.point.x, point.x]);
|
|
}
|
|
}
|
|
lastout = rec;
|
|
}
|
|
// do not add brims to anchor layers
|
|
if (!first || layer.anchor) {
|
|
continue;
|
|
}
|
|
let tmpout = [];
|
|
let trigmet = firstLayerBrimTrig === 0 || (firstLayerBrimTrig && mins <= firstLayerBrimTrig);
|
|
let brimax = Math.max(firstLayerBrim, firstLayerBrimIn);
|
|
// add brim when all conditions met
|
|
if (brimax && trigmet) {
|
|
let { emit, tool } = first;
|
|
let y = maxy;
|
|
let z = minz;
|
|
let g = firstLayerBrimGap || 0;
|
|
let b = Math.max(firstLayerBrim, 1) + g;
|
|
let bi = Math.max(firstLayerBrimIn, 1) + g;
|
|
layer.last().retract = true;
|
|
// outside brim
|
|
if (firstLayerBrim && !brimHalf) {
|
|
print.addOutput(tmpout, newPoint(maxx + b, y, z), 0, firstLayerSeek, tool);
|
|
print.addOutput(tmpout, newPoint(maxx + g, y, z), emit, firstLayerRate, tool).retract = true;
|
|
}
|
|
// inside brim
|
|
if (firstLayerBrimIn && pads.length > 1) {
|
|
let gaps = [];
|
|
let lpad = pads[0];
|
|
for (let pad of pads.slice(1)) {
|
|
let x0 = lpad[1];
|
|
let x1 = pad[0];
|
|
lpad = pad;
|
|
if (x1 - x0 > bi * 2) {
|
|
// over 2x brim so emit two segments
|
|
print.addOutput(tmpout, newPoint(x1 - g, y, z), 0, firstLayerSeek, tool);
|
|
print.addOutput(tmpout, newPoint(x1 - bi, y, z), emit, firstLayerRate, tool).retract = true;
|
|
print.addOutput(tmpout, newPoint(x0 + bi, y, z), 0, firstLayerSeek, tool);
|
|
print.addOutput(tmpout, newPoint(x0 + g, y, z), emit, firstLayerRate, tool).retract = true;
|
|
} else if (x1 - x0 > bi / 3) {
|
|
// over 1/3rd brim length emit single segment
|
|
print.addOutput(tmpout, newPoint(x1 - g, y, z), 0, firstLayerSeek, tool);
|
|
print.addOutput(tmpout, newPoint(x0 + g, y, z), emit, firstLayerRate, tool).retract = true;
|
|
}
|
|
}
|
|
}
|
|
// outside brim
|
|
if (firstLayerBrim) {
|
|
print.addOutput(tmpout, newPoint(minx - b, y, z), 0, firstLayerSeek, tool);
|
|
print.addOutput(tmpout, newPoint(minx - g, y, z), emit, firstLayerRate, tool).retract = false;
|
|
}
|
|
} else {
|
|
// for any layer touching belt, ensure start point is nearest origin
|
|
// print.addOutput(tmpout, newPoint(minx, maxy, minz), 0, firstLayerSeek, first.tool);
|
|
// print.lastPoint = newPoint(minx, maxy, minz);
|
|
}
|
|
layer.splice(0,0,...tmpout);
|
|
}
|
|
}
|
|
|
|
// render if not explicitly disabled
|
|
if (render) {
|
|
print.render = FDM.prepareRender(output, (progress, layer) => {
|
|
update(0.5 + progress * 0.5, "render", layer);
|
|
}, {
|
|
toolMode: settings.pmode === 2,
|
|
tools: device.extruders,
|
|
thin: isThin,
|
|
flat: isFlat,
|
|
fdm: true
|
|
});
|
|
}
|
|
|
|
return print.render;
|
|
};
|
|
|
|
class Counter {
|
|
constructor() {
|
|
this.map = {};
|
|
this.total = 0;
|
|
}
|
|
put(key) {
|
|
const map = this.map;
|
|
const kp = key || 'bad';
|
|
map[kp] = (map[kp] || 0) + 1;
|
|
this.total++;
|
|
}
|
|
get() {
|
|
return { map: this.map, total: this.total };
|
|
}
|
|
}
|
|
|
|
FDM.isDark = function() {
|
|
return current.print.settings.controller.dark ? true : false;
|
|
};
|
|
|
|
FDM.rateToColor = function(rate, max) {
|
|
return FDM.isDark() ?
|
|
darkColorFunction(rate/max, 1, 0.85) :
|
|
currentColorFunction(rate/max, 1, 0.85);
|
|
};
|
|
|
|
FDM.prepareRender = function(levels, update, opts = {}) {
|
|
levels = levels.filter(level => level.length);
|
|
if (levels.length === 0) {
|
|
self.worker.print.maxSpeed = 0;
|
|
return [];
|
|
}
|
|
|
|
const dark = FDM.isDark();
|
|
const tools = opts.tools || {};
|
|
const flat = opts.flat;
|
|
const thin = opts.thin && !flat;
|
|
const ckspeed = opts.speed !== false;
|
|
const headColor = 0x888888;
|
|
const moveColor = opts.move >= 0 ? opts.move : 0xaaaaaa;
|
|
const printColor = opts.print >= 0 ? opts.print : 0x777700;
|
|
const arrowAll = true;
|
|
const arrowSize = arrowAll ? 0.2 : 0.4;
|
|
const layers = [];
|
|
const toolMode = opts.toolMode;
|
|
|
|
const moveOpt = {
|
|
face: moveColor,
|
|
line: flat ? 1 : moveColor,
|
|
opacity: flat ? 0.5 : 1
|
|
};
|
|
const printOpt = {
|
|
face: printColor,
|
|
line: flat ? 1 : printColor,
|
|
opacity: flat ? 0.5 : 1
|
|
};
|
|
|
|
let minspd = Infinity;
|
|
let maxspd = opts.maxspeed || 0;
|
|
let maxtool = [];
|
|
|
|
for (let level of levels) {
|
|
for (let o of level) {
|
|
if (o.speed) {
|
|
minspd = Math.min(minspd, o.speed);
|
|
maxspd = Math.max(maxspd, o.speed);
|
|
}
|
|
if (toolMode && o.tool !== undefined) {
|
|
if (maxtool.indexOf(o.tool) < 0) {
|
|
maxtool.push(o.tool);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// const maxspd = levels.map(level => {
|
|
// return level.map(o => o.speed || 0).reduce((a, v) => Math.max(a,v));
|
|
// }).reduce((a, v) => Math.max(a, v)) + 1;
|
|
|
|
// for reporting
|
|
self.worker.print.minSpeed = minspd;
|
|
self.worker.print.maxSpeed = maxspd;
|
|
self.worker.print.thinColor = thin;
|
|
self.worker.print.flatColor = flat;
|
|
|
|
let lastTool = null;
|
|
let lastEnd = null;
|
|
let lastOut = null;
|
|
let current = null;
|
|
let retracted = false;
|
|
let retractz = 0;
|
|
|
|
function color(point) {
|
|
if (toolMode) {
|
|
return FDM.rateToColor(maxtool.indexOf(point.tool), maxtool.length);
|
|
} else {
|
|
return FDM.rateToColor(point.speed, maxspd);
|
|
}
|
|
}
|
|
|
|
levels.forEach((level, index) => {
|
|
const prints = {};
|
|
const moves = [];
|
|
const heads = [];
|
|
const changes = [];
|
|
const retracts = [];
|
|
const engages = [];
|
|
const output = new KIRI.Layers();
|
|
layers.push(output);
|
|
|
|
const pushPrint = (toolid, poly) => {
|
|
toolid = toolid || 0;
|
|
const array = prints[toolid] = prints[toolid] || [];
|
|
const tool = tools[toolid] || {};
|
|
array.width = (tool.extNozzle || 1) / 2;
|
|
array.push(poly);
|
|
emits++;
|
|
};
|
|
|
|
let height = level.height / 2;
|
|
let width = 1;
|
|
let emits = 0;
|
|
|
|
level.forEach((out,oi) => {
|
|
if (retracted && out.emit) {
|
|
retracted = false;
|
|
engages.push(lastOut.point);
|
|
}
|
|
if (out.tool !== lastTool) {
|
|
lastTool = out.tool;
|
|
changes.push(out.point);
|
|
}
|
|
if (out.retract) {
|
|
retracts.push(out.point);
|
|
retracted = true;
|
|
retractz++;
|
|
}
|
|
if (!out.point) {
|
|
// in cam mode, these are drilling or dwell ops
|
|
return;
|
|
}
|
|
|
|
if (lastOut) {
|
|
if (arrowAll || lastOut.emit !== out.emit) {
|
|
heads.push({p1: lastOut.point, p2: out.point});
|
|
}
|
|
const op = out.point, lp = lastOut.point;
|
|
// const moved = Math.max(
|
|
// Math.abs(op.x - lp.x),
|
|
// Math.abs(op.y - lp.y),
|
|
// Math.abs(op.z - lp.z));
|
|
// if (moved < 0.0001) return;
|
|
if (out.emit) {
|
|
if (!lastOut.emit || (ckspeed && out.speed !== lastOut.speed) || lastEnd) {
|
|
current = newPolygon().setOpen();
|
|
current.push(lastOut.point);
|
|
current.color = color(out);
|
|
pushPrint(out.tool, current);
|
|
}
|
|
current.push(out.point);
|
|
} else {
|
|
if (lastOut.emit || lastEnd) {
|
|
current = newPolygon().setOpen();
|
|
current.push(lastOut.point);
|
|
moves.push(current);
|
|
}
|
|
current.push(out.point);
|
|
}
|
|
lastEnd = null;
|
|
} else {
|
|
current = newPolygon().setOpen();
|
|
current.push(out.point);
|
|
if (out.emit) {
|
|
current.color = color(out);
|
|
pushPrint(out.tool, current);
|
|
} else {
|
|
moves.push(current);
|
|
}
|
|
}
|
|
lastOut = out;
|
|
});
|
|
// all moves with an emit at the very end (common in contouring)
|
|
if (lastOut.emit && !emits) {
|
|
pushPrint(lastOut.tool, current)
|
|
}
|
|
lastEnd = lastOut;
|
|
if (changes.length) {
|
|
output
|
|
.setLayer('tool', { line: 0x000055, face: 0x0000ff, opacity: 0.5 }, true)
|
|
.addAreas(changes.map(point => {
|
|
return newPolygon().centerCircle(point, 0.2, 4).setZ(point.z + 0.03);
|
|
}), { outline: true });
|
|
}
|
|
if (retracts.length) {
|
|
output
|
|
.setLayer('retract', { line: 0x550000, face: 0xff0000, opacity: 0.5 }, true)
|
|
.addAreas(retracts.map(point => {
|
|
return newPolygon().centerCircle(point, 0.2, 5).setZ(point.z + 0.01);
|
|
}), { outline: true });
|
|
}
|
|
if (engages.length) {
|
|
output
|
|
.setLayer('engage', { line: 0x005500, face: 0x00ff00, opacity: 0.5 }, true)
|
|
.addAreas(engages.map(point => {
|
|
return newPolygon().centerCircle(point, 0.2, 7).setZ(point.z + 0.02);
|
|
}), { outline: true });
|
|
}
|
|
if (heads.length) {
|
|
let line = dark ? 0xffffff : 0x112233;
|
|
output
|
|
.setLayer('arrows', { face: headColor, line, opacity: 0.75 }, true)
|
|
.addAreas(heads.map(points => {
|
|
const {p1, p2} = points;
|
|
const slope = p2.slopeTo(p1);
|
|
const s1 = BASE.newSlopeFromAngle(slope.angle + 20);
|
|
const s2 = BASE.newSlopeFromAngle(slope.angle - 20);
|
|
const p3 = points.p2.projectOnSlope(s1, arrowSize);
|
|
const p4 = points.p2.projectOnSlope(s2, arrowSize);
|
|
return newPolygon().addPoints([p2,p3,p4]).setZ(p2.z + 0.01);
|
|
}), { thin: true, outline: true });
|
|
}
|
|
output
|
|
.setLayer(opts.other || 'move', moveOpt, opts.moves !== true)
|
|
.addPolys(moves, { thin: true, z: opts.z });
|
|
// force level when present
|
|
let pz = level.z ? level.z - height : opts.z;
|
|
Object.values(prints).forEach(array => {
|
|
array.forEach(poly => {
|
|
if (flat && poly.appearsClosed()) {
|
|
poly.setClosed();
|
|
poly.points.pop();
|
|
}
|
|
output
|
|
.setLayer(opts.action || 'print', printOpt)
|
|
.addPolys([ poly ],
|
|
thin ? { thin, z: opts.z, color: poly.color } :
|
|
flat ? {
|
|
flat, z: pz, color: poly.color,
|
|
outline: true, offset: array.width, open: poly.open } :
|
|
{
|
|
offset: array.width, height, z: pz,
|
|
color: { face: poly.color, line: poly.color }
|
|
})
|
|
});
|
|
});
|
|
|
|
update(index / levels.length, output);
|
|
});
|
|
// console.log({retractz});
|
|
return layers;
|
|
}
|
|
|
|
const colorFunctions = FDM.colorFunctions = {
|
|
default: hsv2rgb.bind({ seg: 4, fn: color4d }),
|
|
simple: hsv2rgb.bind({ seg: 3, fn: color4 }),
|
|
dark: hsv2rgb.bind({ seg: 4, fn: color4d })
|
|
};
|
|
|
|
let currentColorFunction = colorFunctions.default;
|
|
let darkColorFunction = colorFunctions.dark;
|
|
|
|
// hsv values all = 0 to 1
|
|
function hsv2rgb(h, s, v) {
|
|
const div = this.seg;
|
|
const ss = 1 / div;
|
|
const seg = Math.floor(h / ss);
|
|
const rem = h - (seg * ss);
|
|
const inc = (rem / ss);
|
|
const dec = (1 - inc);
|
|
const rgb = {r: 0, g: 0, b: 0};
|
|
this.fn(rgb, inc, seg);
|
|
rgb.r = ((rgb.r * 255 * v) & 0xff) << 16;
|
|
rgb.g = ((rgb.g * 255 * v) & 0xff) << 8;
|
|
rgb.b = ((rgb.b * 255 * v) & 0xff);
|
|
return rgb.r | rgb.g | rgb.b;
|
|
}
|
|
|
|
function color5(rgb, inc, seg) {
|
|
const dec = 1 - inc;
|
|
switch (seg) {
|
|
case 0:
|
|
rgb.r = 1;
|
|
rgb.g = inc;
|
|
rgb.b = 0;
|
|
break;
|
|
case 1:
|
|
rgb.r = dec;
|
|
rgb.g = 1;
|
|
rgb.b = 0;
|
|
break;
|
|
case 2:
|
|
rgb.r = 0;
|
|
rgb.g = dec;
|
|
rgb.b = inc;
|
|
break;
|
|
case 3:
|
|
rgb.r = inc;
|
|
rgb.g = 0;
|
|
rgb.b = 1;
|
|
break;
|
|
case 4:
|
|
rgb.r = dec;
|
|
rgb.g = 0;
|
|
rgb.b = dec;
|
|
break;
|
|
}
|
|
}
|
|
|
|
function color4d(rgb, inc, seg) {
|
|
const dec = 1 - inc;
|
|
switch (seg) {
|
|
case 0:
|
|
rgb.r = 1;
|
|
rgb.g = inc;
|
|
rgb.b = 0;
|
|
break;
|
|
case 1:
|
|
rgb.r = dec;
|
|
rgb.g = 1;
|
|
rgb.b = 0;
|
|
break;
|
|
case 2:
|
|
rgb.r = 0;
|
|
rgb.g = dec;
|
|
rgb.b = inc;
|
|
break;
|
|
case 3:
|
|
rgb.r = inc * 0.85;
|
|
rgb.g = 0;
|
|
rgb.b = 1;
|
|
break;
|
|
case 4:
|
|
rgb.r = 0.85;
|
|
rgb.g = 0;
|
|
rgb.b = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
function color4(rgb, inc, seg) {
|
|
const dec = 1 - inc;
|
|
switch (seg) {
|
|
case 0:
|
|
rgb.r = 0;
|
|
rgb.g = inc;
|
|
rgb.b = 1;
|
|
break;
|
|
case 1:
|
|
rgb.r = inc;
|
|
rgb.g = 1;
|
|
rgb.b = 0;
|
|
break;
|
|
case 2:
|
|
rgb.r = 1;
|
|
rgb.g = dec;
|
|
rgb.b = 0;
|
|
break;
|
|
case 3:
|
|
rgb.r = dec;
|
|
rgb.g = 0;
|
|
rgb.b = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
})();
|