checkpoint belt work
This commit is contained in:
Stewart Allen
parent
d89674f1d5
commit
44d54491d7
6 changed files with 103 additions and 116 deletions
|
|
@ -978,9 +978,9 @@
|
|||
if (settings.device.bedBelt && WIDGETS[0].rotinfo) {
|
||||
let ri = WIDGETS[0].rotinfo;
|
||||
// console.log(ri)
|
||||
ri.dy = ri.dz = 0;
|
||||
ri.dy = settings.device.bedDepth / 2 - ri.ypos;
|
||||
stack.obj.rotate(WIDGETS[0].rotinfo);
|
||||
// ri.dy = ri.dz = 0;
|
||||
// ri.dy = settings.device.bedDepth / 2 - ri.ypos;
|
||||
// stack.obj.rotate(WIDGETS[0].rotinfo);
|
||||
}
|
||||
segtimes[`${segNumber}_draw`] = Date.now() - startTime;
|
||||
}
|
||||
|
|
@ -1688,7 +1688,7 @@
|
|||
if (isBelt) {
|
||||
let bounds = platformUpdateBounds(),
|
||||
movey = -(dev.bedDepth / 2 + bounds.min.y);
|
||||
forAllWidgets(widget => widget.move(0, movey + 10, 0));
|
||||
forAllWidgets(widget => widget.move(0, movey + 0, 0));
|
||||
}
|
||||
|
||||
platform.update_origin();
|
||||
|
|
|
|||
|
|
@ -100,6 +100,7 @@
|
|||
|
||||
const scope = this,
|
||||
morph = false,
|
||||
// morph = true,
|
||||
bounds = scope.bounds = {
|
||||
max: { x:-Infinity, y:-Infinity, z:-Infinity},
|
||||
min: { x:Infinity, y:Infinity, z:Infinity}
|
||||
|
|
@ -166,8 +167,8 @@
|
|||
);
|
||||
|
||||
if (morph && belt) {
|
||||
point.z *= beltfact;
|
||||
point.y -= point.z * beltfact;
|
||||
point.z *= beltfact;
|
||||
}
|
||||
|
||||
const retract = (fdm && pos.E < 0) || undefined;
|
||||
|
|
@ -226,16 +227,23 @@
|
|||
lastPos = Object.assign({}, pos);
|
||||
}
|
||||
|
||||
lines.forEach(function(line) {
|
||||
lines.forEach(function(line, idx) {
|
||||
if (idx < 10) console.log({line})
|
||||
if (line.indexOf(';LAYER:') === 0) {
|
||||
newlayer = true;
|
||||
if (idx < 100) console.log({newlayer});
|
||||
}
|
||||
if (line.indexOf('- LAYER ') > 0) {
|
||||
seq.height = defh;
|
||||
const hd = line.replace('(','').replace(')','').split(' ');
|
||||
defh = parseFloat(hd[4]);
|
||||
if (fdm) dz = -defh / 2;
|
||||
newlayer = true;
|
||||
if (idx < 100) console.log({layer: defh});
|
||||
}
|
||||
if (line.indexOf("BED TYPE: BELT") > 0) {
|
||||
belt = true;
|
||||
if (idx < 100) console.log({isbelt: belt});
|
||||
}
|
||||
line = line.split(";")[0].split(" ").filter(v => v);
|
||||
let cmd = line.shift();
|
||||
|
|
|
|||
|
|
@ -74,7 +74,9 @@ KIRI.worker = {
|
|||
|
||||
let rotation = (Math.PI/180) * (settings.device.bedBelt ? 45 : 0);
|
||||
if (rotation) {
|
||||
let bounds = widget.getBoundingBox(true);
|
||||
let track = widget.track;
|
||||
// console.log(widget.id, '\n', track.pos, '\n', track.box, '\n', '\n---\n')
|
||||
xpos = track.pos.x;
|
||||
ypos = track.pos.y + settings.device.bedDepth / 2 - track.box.h / 2;
|
||||
widget.mesh = null;
|
||||
|
|
@ -83,7 +85,7 @@ KIRI.worker = {
|
|||
widget._rotate(rotation,0,0,true);
|
||||
widget.center(false, true);
|
||||
widget.getBoundingBox(true);
|
||||
widget.belt = { ypos };
|
||||
widget.belt = { xpos, ypos };
|
||||
}
|
||||
|
||||
widget.slice(settings, function(error) {
|
||||
|
|
@ -106,9 +108,11 @@ KIRI.worker = {
|
|||
widget.setPoints(null);
|
||||
widget._rotate(-rotation,0,0,true);
|
||||
let wbb = widget.getBoundingBox(true);
|
||||
widget.center(false, true);
|
||||
let dy = (wbb.max.y + wbb.min.y)/2;
|
||||
let dz = wbb.min.z;
|
||||
widget.rotinfo = { angle: 45, dy, dz, xpos, ypos };
|
||||
// console.log(widget.id, '\n', widget.belt, '\n', widget.rotinfo, '\n===\n')
|
||||
send.data({ rotinfo: widget.rotinfo });
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@
|
|||
gcodeLayer = device.gcodeLayer,
|
||||
gcodeTrack = device.gcodeTrack,
|
||||
tool = 0,
|
||||
isBelt = false && device.bedBelt,
|
||||
isBelt = device.bedBelt,
|
||||
bedType = isBelt ? "belt" : "fixed",
|
||||
extruder = extruders[tool],
|
||||
offset_x = extruder.extOffsetX,
|
||||
|
|
@ -77,7 +77,7 @@
|
|||
bytes = 0,
|
||||
bcos = Math.cos(Math.PI/4),
|
||||
icos = 1 / bcos;
|
||||
|
||||
console.log({isBelt, offset});
|
||||
(process.gcodePauseLayers || "").split(",").forEach(function(lv) {
|
||||
let v = parseInt(lv);
|
||||
if (v >= 0) pause.push(v);
|
||||
|
|
@ -199,14 +199,11 @@
|
|||
}
|
||||
let epos = isBelt ? { x: pos.x, y: pos.y, z: pos.z } : pos;
|
||||
if (isBelt) {
|
||||
// let rpos = new THREE.Vector3(pos.x, pos.y, pos.z);
|
||||
// rpos.applyAxisAngle( taxis, angle );
|
||||
// epos.x = rpos.x;
|
||||
// epos.y = rpos.z * icos;
|
||||
// epos.z = rpos.y + (bcos * rpos.z);
|
||||
epos.x = pos.x;
|
||||
epos.z = pos.z * icos;
|
||||
epos.y = pos.y + epos.z * bcos;
|
||||
// epos.z = pos.y * icos;
|
||||
// epos.y = pos.z + (pos.y * icos) * bcos;
|
||||
}
|
||||
if (emit.x) o.append(" X").append(epos.x.toFixed(decimals));
|
||||
if (emit.y) o.append(" Y").append(epos.y.toFixed(decimals));
|
||||
|
|
@ -253,7 +250,8 @@
|
|||
path.layer === 0 ?
|
||||
(process.firstSliceHeight || process.sliceHeight) : path.height);
|
||||
|
||||
subst.z = (zpos + path.height).toFixed(3);
|
||||
subst.z = zpos = path.z;
|
||||
// subst.z = (zpos + path.height).toFixed(3);
|
||||
subst.Z = subst.z;
|
||||
subst.layer = layer;
|
||||
subst.height = path.height.toFixed(3);
|
||||
|
|
@ -293,7 +291,6 @@
|
|||
}
|
||||
|
||||
// move Z to layer height
|
||||
zpos += path.height;
|
||||
if (layer > 0 || !isBelt) {
|
||||
moveTo({z:zpos}, seekMMM);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -46,7 +46,9 @@
|
|||
isThin = settings.controller.lineType === "line",
|
||||
isFlat = settings.controller.lineType === "flat",
|
||||
isBelt = device.bedBelt,
|
||||
beltYoff = device.bedDepth / 2;
|
||||
beltYoff = device.bedDepth / 2,
|
||||
bcos = Math.cos(Math.PI/4),
|
||||
icos = 1 / bcos;
|
||||
|
||||
// compute bounds if missing
|
||||
if (!bounds) {
|
||||
|
|
@ -285,42 +287,45 @@
|
|||
}
|
||||
}
|
||||
|
||||
const center = {x:0, y:0, z:0};
|
||||
|
||||
// increment layer count until no widget has remaining slices
|
||||
for (;;) {
|
||||
// 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;
|
||||
}
|
||||
let widget = mesh.widget;
|
||||
let mslices = widget.slices;
|
||||
if (mslices && mslices[layer]) {
|
||||
let offset = Object.clone(mesh.position || center);
|
||||
// establish offsets
|
||||
for (let widget of widgets) {
|
||||
let offset = widget.mesh ? Object.clone(widget.mesh.position) : {x:0, y:0, z:0};
|
||||
if (isBelt) {
|
||||
offset = center;
|
||||
offset.x = widget.rotinfo.xpos;
|
||||
offset.y = widget.rotinfo.dz;
|
||||
offset.z = widget.rotinfo.ypos;
|
||||
offset.y = widget.belt.miny;
|
||||
offset.y += widget.rotinfo.ypos * bcos;
|
||||
offset.z = widget.rotinfo.ypos * bcos;
|
||||
} else {
|
||||
// when rafts used this is non-zero
|
||||
offset.z = zoff;
|
||||
}
|
||||
slices.push({
|
||||
slice: mslices[layer],
|
||||
offset: offset,
|
||||
widget: widget
|
||||
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;
|
||||
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;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// exit if no slices
|
||||
if (slices.length === 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
// walk cake layers bottom up
|
||||
for (let layer of cake) {
|
||||
// track purge blocks generated for each layer
|
||||
let track = extruders.slice();
|
||||
let lastOut;
|
||||
|
|
@ -328,58 +333,55 @@
|
|||
|
||||
// iterate over layer slices, find closest widget, print, eliminate
|
||||
for (;;) {
|
||||
closest = null;
|
||||
mindist = Infinity;
|
||||
let order = [];
|
||||
// select slices of the same extruder type first then distance
|
||||
for (meshIndex = 0; meshIndex < slices.length; meshIndex++) {
|
||||
sliceEntry = slices[meshIndex];
|
||||
if (sliceEntry) {
|
||||
find = sliceEntry.slice.findClosestPointTo(printPoint.sub(sliceEntry.offset));
|
||||
for (let slice of layer.slices) {
|
||||
if (slice.prep) {
|
||||
continue;
|
||||
}
|
||||
let offset = slice.widget.offset;
|
||||
let find = slice.findClosestPointTo(printPoint.sub(offset));
|
||||
if (find) {
|
||||
let ext = sliceEntry.slice.extruder;
|
||||
let ext = slice.extruder;
|
||||
let lex = lastOut ? lastOut.extruder : ext;
|
||||
let dst = Math.abs(find.distance);
|
||||
if (ext !== lex) dst *= 10000;
|
||||
order.push({dst,sliceEntry,meshIndex});
|
||||
// penalize extruder swaps
|
||||
if (ext !== lex) {
|
||||
dst *= 10000;
|
||||
}
|
||||
order.push({dst, slice, offset, z: layer.z});
|
||||
}
|
||||
}
|
||||
if (order.length === 0) {
|
||||
break;
|
||||
}
|
||||
order.sort((a,b) => {
|
||||
return a.dst - b.dst;
|
||||
});
|
||||
if (order.length) {
|
||||
let find = order.shift();
|
||||
closest = find.sliceEntry;
|
||||
minidx = find.meshIndex;
|
||||
}
|
||||
|
||||
if (!closest) {
|
||||
if (sliceEntry) lastOut = sliceEntry.slice;
|
||||
break;
|
||||
}
|
||||
let { z, slice, offset } = order[0];
|
||||
slice.prep = true;
|
||||
// retract between widgets
|
||||
if (layerout.length && minidx !== lastIndex) {
|
||||
layerout.last().retract = true;
|
||||
}
|
||||
layerout.height = layerout.height || closest.slice.height;
|
||||
slices[minidx] = null;
|
||||
layerout.z = z;
|
||||
layerout.height = layerout.height || slice.height;
|
||||
// detect extruder change and print purge block
|
||||
if (!lastOut || lastOut.extruder !== closest.slice.extruder) {
|
||||
printPoint = purge(closest.slice.extruder, track, layerout, printPoint, closest.slice.z);
|
||||
if (!lastOut || lastOut.extruder !== slice.extruder) {
|
||||
printPoint = purge(slice.extruder, track, layerout, printPoint, slice.z);
|
||||
}
|
||||
// output seek to start point between mesh slices if previous data
|
||||
printPoint = print.slicePrintPath(
|
||||
closest.slice,
|
||||
printPoint.sub(closest.offset),
|
||||
closest.offset,
|
||||
slice,
|
||||
printPoint.sub(offset),
|
||||
offset,
|
||||
layerout,
|
||||
{
|
||||
first: closest.slice.index === 0,
|
||||
support: closest.widget.support
|
||||
first: slice.index === 0,
|
||||
support: slice.widget.support
|
||||
}
|
||||
);
|
||||
lastOut = closest.slice;
|
||||
lastOut = slice;
|
||||
lastExt = lastOut.ext
|
||||
lastIndex = minidx;
|
||||
}
|
||||
|
|
@ -393,7 +395,9 @@
|
|||
});
|
||||
|
||||
// if layer produced output, append to output array
|
||||
if (layerout.length) output.append(layerout);
|
||||
if (layerout.length) {
|
||||
output.append(layerout);
|
||||
}
|
||||
|
||||
// retract after last layer
|
||||
if (layer === maxLayers && layerout.length) {
|
||||
|
|
@ -411,30 +415,6 @@
|
|||
|
||||
print.output = output;
|
||||
|
||||
// if belt, adjust z and y to baselines
|
||||
function beltSkew() {
|
||||
let bcos = Math.cos(Math.PI/4);
|
||||
let icos = 1/bcos;
|
||||
let miny = Infinity, minz = Infinity;
|
||||
for (let layer of output) {
|
||||
for (let rec of layer) {
|
||||
rec.point.z = rec.point.z * icos;
|
||||
rec.point.y = rec.point.y + rec.point.z * bcos;
|
||||
miny = Math.min(miny, rec.point.y);
|
||||
minz = Math.min(minz, rec.point.y);
|
||||
}
|
||||
}
|
||||
if (miny || minz) {
|
||||
console.log({miny, minz})
|
||||
for (let layer of output) {
|
||||
for (let rec of layer) {
|
||||
rec.point.y -= minz;
|
||||
rec.point.z -= miny;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// render if not explicitly disabled
|
||||
if (render) {
|
||||
print.render = FDM.prepareRender(output, (progress, layer) => {
|
||||
|
|
@ -442,10 +422,6 @@
|
|||
}, { tools: device.extruders, thin: isThin, flat: isFlat, fdm: true });
|
||||
}
|
||||
|
||||
if (isBelt) {
|
||||
beltSkew();
|
||||
}
|
||||
|
||||
return print.render;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -273,11 +273,13 @@
|
|||
for (let top of slices[0].tops) {
|
||||
bounds.merge(top.poly.bounds);
|
||||
}
|
||||
widget.belt = {
|
||||
offset_y: bounds.miny,
|
||||
pos_y: sdev.bedDepth / 2 + widget.track.pos.y,
|
||||
ypos: widget.belt.ypos
|
||||
};
|
||||
widget.belt.miny = -bounds.miny;
|
||||
// widget.belt.yy2 = sdev.bedDepth / 2 + widget.track.pos.y;
|
||||
// widget.belt = {
|
||||
// offset_y: bounds.miny,
|
||||
// pos_y: sdev.bedDepth / 2 + widget.track.pos.y,
|
||||
// ypos: widget.belt.ypos
|
||||
// };
|
||||
}
|
||||
|
||||
// report slicing complete
|
||||
|
|
|
|||
Loading…
Reference in a new issue