AI_Assistant/grid-apps-cmms
Watch
1
0
Fork
You've already forked grid-apps-cmms
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix brim z, fix zhop for purges. disable polish code

Browse source
This commit is contained in:
Stewart Allen 2020-04-11 20:02:39 -04:00
commit 0358527254
3 changed files with 215 additions and 205 deletions
Download patch file Download diff file Expand all files Collapse all files

8
js/kiri-conf.js
View file

@ -279,8 +279,8 @@ let gs_kiri_conf = exports;
// detectThinWalls: 1, // detectThinWalls: 1,
antiBacklash: 1, antiBacklash: 1,
zHopDistance: 1, zHopDistance: 1,
polishLayers: 1, // polishLayers: 1,
polishSpeed: 1, // polishSpeed: 1,
outputLayerRetract: 1, outputLayerRetract: 1,
gcodePauseLayers: 1, gcodePauseLayers: 1,
outputClockwise: 1, outputClockwise: 1,
@ -538,8 +538,8 @@ let gs_kiri_conf = exports;
detectThinWalls: false, detectThinWalls: false,
antiBacklash: 1, antiBacklash: 1,
zHopDistance: 0.2, zHopDistance: 0.2,
polishLayers: 0, // polishLayers: 0,
polishSpeed: 40, // polishSpeed: 40,
outputLayerRetract: false, outputLayerRetract: false,
gcodePauseLayers: "", gcodePauseLayers: "",

408
js/kiri-driver-fdm.js
View file

@ -177,190 +177,190 @@ let gs_kiri_fdm = exports;
}, "infill"); }, "infill");
} }
let polish = spro.polishLayers; // let polish = spro.polishLayers;
// experimental polishing // // experimental polishing
if (polish) { // if (polish) {
let polish_layer = Math.floor(polish); // let polish_layer = Math.floor(polish);
let polish_step = Math.max(polish - polish_layer || 1, 0.25); // let polish_step = Math.max(polish - polish_layer || 1, 0.25);
widget.polish = {}; // widget.polish = {};
let px = []; // let px = [];
let py = []; // let py = [];
// compute x polishing slices // // compute x polishing slices
SLICER.sliceWidget(widget, { // SLICER.sliceWidget(widget, {
height: nozzleSize * polish_step, // height: nozzleSize * polish_step,
swapX: true, // swapX: true,
swapY: false, // swapY: false,
simple: true // simple: true
}, (polish_done => { // }, (polish_done => {
widget.polish.x = polish_done // widget.polish.x = polish_done
.filter(s => s.groups.length) // .filter(s => s.groups.length)
.map(s => s.groups) // .map(s => s.groups)
.forEach(p => px.appendAll(p)); // .forEach(p => px.appendAll(p));
}), (polish_update) => { // }), (polish_update) => {
// console.log({polish_update}); // // console.log({polish_update});
}); // });
// compute y polishing slices // // compute y polishing slices
SLICER.sliceWidget(widget, { // SLICER.sliceWidget(widget, {
height: nozzleSize * polish_step, // height: nozzleSize * polish_step,
swapX: false, // swapX: false,
swapY: true, // swapY: true,
simple: true // simple: true
}, (polish_done => { // }, (polish_done => {
widget.polish.y = polish_done // widget.polish.y = polish_done
.filter(s => s.groups.length) // .filter(s => s.groups.length)
.map(s => s.groups) // .map(s => s.groups)
.forEach(p => py.appendAll(p)); // .forEach(p => py.appendAll(p));
}), (polish_update) => { // }), (polish_update) => {
// console.log({polish_update}); // // console.log({polish_update});
}); // });
// apply polishing finishes to layers // // apply polishing finishes to layers
forSlices(1.0, 1.0, (slice) => { // forSlices(1.0, 1.0, (slice) => {
if (polish_layer >= 2) { // if (polish_layer >= 2) {
let sai = (slice.index - polish_layer); // let sai = (slice.index - polish_layer);
if (sai % (polish_layer-1) !== 0) { // if (sai % (polish_layer-1) !== 0) {
return; // return;
} // }
} // }
if (slice.index >= polish_layer) { // if (slice.index >= polish_layer) {
let sd = slice; // let sd = slice;
for (let i=0; i<polish_layer; i++) { // for (let i=0; i<polish_layer; i++) {
sd = sd.down; // sd = sd.down;
} // }
let zb = sd.z; // let zb = sd.z;
let zt = slice.z; // let zt = slice.z;
let pout = []; // let pout = [];
let cont = 0; // let cont = 0;
[px, py].forEach(pa => { // [px, py].forEach(pa => {
//
let polys = []; // let polys = [];
pa.forEach(p => { // pa.forEach(p => {
// rotate and test for self-intersection (points under model) // // rotate and test for self-intersection (points under model)
p.ensureXY(); // p.ensureXY();
let ox = p._aligned == 'yz' ? 0.1 : 0; // let ox = p._aligned == 'yz' ? 0.1 : 0;
let oy = p._aligned == 'yz' ? 0 : 0.1; // let oy = p._aligned == 'yz' ? 0 : 0.1;
p.forEachPoint(pt => { // p.forEachPoint(pt => {
let int = p.intersections( // let int = p.intersections(
pt.offset(ox,oy,0), // pt.offset(ox,oy,0),
pt.offset(ox*10000,oy*10000,0)); // pt.offset(ox*10000,oy*10000,0));
if (int.length > 0) { // if (int.length > 0) {
pt._under = true; // pt._under = true;
} // }
}); // });
p.restoreXY(); // p.restoreXY();
//
let lastp = undefined; // let lastp = undefined;
let poly = []; // let poly = [];
// look for qualifying segments // // look for qualifying segments
p.forEachSegment((p1, p2) => { // p.forEachSegment((p1, p2) => {
// eliminate segments that projected up // // eliminate segments that projected up
// intersect with the polygon (bottom faces) // // intersect with the polygon (bottom faces)
if (p1._under || p2._under) { // if (p1._under || p2._under) {
return; // return;
} // }
// skip when both below layer range // // skip when both below layer range
if (p1.z < zb && p2.z < zb) { // if (p1.z < zb && p2.z < zb) {
return; // return;
} // }
// skip when both above layer range // // skip when both above layer range
if (p1.z > zt && p2.z > zt) { // if (p1.z > zt && p2.z > zt) {
return; // return;
} // }
// skip vertical // // skip vertical
if (p1.x === p2.x && p1.y === p2.y) { // if (p1.x === p2.x && p1.y === p2.y) {
return; // return;
} // }
// skip horizontal // // skip horizontal
// if (p1.z === p2.z) { // // if (p1.z === p2.z) {
// return; // // return;
// } // // }
// order points lowest to highest // // order points lowest to highest
let swap = false; // let swap = false;
if (p1.z > p2.z) { // if (p1.z > p2.z) {
let t = p2; // let t = p2;
p2 = p1; // p2 = p1;
p1 = t; // p1 = t;
swap = true; // swap = true;
} // }
let trimlo = false; // let trimlo = false;
let trimhi = false; // let trimhi = false;
if (p1.z < zb) { // if (p1.z < zb) {
trimlo = true; // trimlo = true;
} // }
if (p2.z > zt) { // if (p2.z > zt) {
trimhi = true; // trimhi = true;
} // }
let xaxis = p1.x === p2.x; // let xaxis = p1.x === p2.x;
if (xaxis) { // if (xaxis) {
p1 = BASE.newPoint(p1.y,p1.z,p1.x); // p1 = BASE.newPoint(p1.y,p1.z,p1.x);
p2 = BASE.newPoint(p2.y,p2.z,p2.x); // p2 = BASE.newPoint(p2.y,p2.z,p2.x);
} else { // } else {
p1 = BASE.newPoint(p1.x,p1.z,p1.y); // p1 = BASE.newPoint(p1.x,p1.z,p1.y);
p2 = BASE.newPoint(p2.x,p2.z,p2.y); // p2 = BASE.newPoint(p2.x,p2.z,p2.y);
} // }
let slope = BASE.newSlope(p1, p2); // let slope = BASE.newSlope(p1, p2);
let angle = slope.angle; // let angle = slope.angle;
if (angle > 80 && angle < 100) { // if (angle > 80 && angle < 100) {
return; // return;
} // }
let len = p1.distTo2D(p2); // let len = p1.distTo2D(p2);
let np1 = p1; // let np1 = p1;
if (trimlo) { // if (trimlo) {
let zunder = zb - p1.y; // let zunder = zb - p1.y;
let zover = p2.y - zb; // let zover = p2.y - zb;
let zdelt = p2.y - p1.y; // let zdelt = p2.y - p1.y;
let pct = zunder / zdelt; // let pct = zunder / zdelt;
np1 = p1.follow(slope, len * pct); // np1 = p1.follow(slope, len * pct);
} // }
if (trimhi) { // if (trimhi) {
let zunder = zt - p1.y; // let zunder = zt - p1.y;
let zover = p2.y - zt; // let zover = p2.y - zt;
let zdelt = p2.y - p1.y; // let zdelt = p2.y - p1.y;
let pct = zover / zdelt; // let pct = zover / zdelt;
p2 = p2.follow(slope.invert(), len * pct); // p2 = p2.follow(slope.invert(), len * pct);
} // }
p1 = np1; // p1 = np1;
if (xaxis) { // if (xaxis) {
p1 = BASE.newPoint(p1.z,p1.x,p1.y); // p1 = BASE.newPoint(p1.z,p1.x,p1.y);
p2 = BASE.newPoint(p2.z,p2.x,p2.y); // p2 = BASE.newPoint(p2.z,p2.x,p2.y);
} else { // } else {
p1 = BASE.newPoint(p1.x,p1.z,p1.y); // p1 = BASE.newPoint(p1.x,p1.z,p1.y);
p2 = BASE.newPoint(p2.x,p2.z,p2.y); // p2 = BASE.newPoint(p2.x,p2.z,p2.y);
} // }
if (!lastp) { // if (!lastp) {
poly.push(p1); // poly.push(p1);
poly.push(p2); // poly.push(p2);
} else if (p1.isMergable2D(lastp)) { // } else if (p1.isMergable2D(lastp)) {
// } else if (p1.isEqual(lastp)) { // // } else if (p1.isEqual(lastp)) {
poly.push(p2); // poly.push(p2);
cont++; // cont++;
} else if (poly.length) { // } else if (poly.length) {
polys.push(poly); // polys.push(poly);
poly = [p1, p2]; // poly = [p1, p2];
} // }
lastp = p2; // lastp = p2;
}); // });
if (poly.length) { // if (poly.length) {
polys.push(poly); // polys.push(poly);
} // }
}); // });
pout.push(polys); // pout.push(polys);
polys = []; // polys = [];
}); // });
//
if (pout.length && slice.tops.length) { // if (pout.length && slice.tops.length) {
slice.tops[0].polish = { // slice.tops[0].polish = {
x: pout[0] // x: pout[0]
.map(a => BASE.newPolygon(a).setOpen()) // .map(a => BASE.newPolygon(a).setOpen())
// .filter(p => p.perimeter() > nozzleSize) // // .filter(p => p.perimeter() > nozzleSize)
, // ,
y: pout[1] // y: pout[1]
.map(a => BASE.newPolygon(a).setOpen()) // .map(a => BASE.newPolygon(a).setOpen())
// .filter(p => p.perimeter() > nozzleSize) // // .filter(p => p.perimeter() > nozzleSize)
}; // };
} // }
} // }
}); // });
} // }
// report slicing complete // report slicing complete
ondone(); ondone();
@ -432,8 +432,9 @@ let gs_kiri_fdm = exports;
// if brim is offset, over-expand then shrink to induce brims to merge // if brim is offset, over-expand then shrink to induce brims to merge
if (offset && brims.length) { if (offset && brims.length) {
let extra = process.sliceSupportExtra + 2; let extra = process.sliceSupportExtra + 2;
brims = POLY.expand(brims, extra, 0, null, 1); let zheight = brims[0].getZ();
brims = POLY.expand(brims, -extra, 0, null, 1); brims = POLY.expand(brims, extra, zheight, null, 1);
brims = POLY.expand(brims, -extra, zheight, null, 1);
} }
// if raft is specified // if raft is specified
@ -488,7 +489,7 @@ let gs_kiri_fdm = exports;
let polys = [], let polys = [],
preout = []; preout = [];
// expand brims // expand specified # of brims
brims.forEach(function(brim) { brims.forEach(function(brim) {
POLY.trace2count(brim, polys, -nozzle, process.outputBrimCount, 0); POLY.trace2count(brim, polys, -nozzle, process.outputBrimCount, 0);
}); });
@ -509,6 +510,7 @@ let gs_kiri_fdm = exports;
print.addPrintPoints(preout, layerout, null); print.addPrintPoints(preout, layerout, null);
if (preout.length) { if (preout.length) {
// retract between brims and print
preout.last().retract = true; preout.last().retract = true;
} }
} }
@ -572,11 +574,14 @@ let gs_kiri_fdm = exports;
let rec = track[nozzle]; let rec = track[nozzle];
if (rec) { if (rec) {
track[nozzle] = null; track[nozzle] = null;
return print.polyPrintPath(rec.poly.clone().setZ(z), start, layer, { if (layer.last()) layer.last().retract = true;
start = print.polyPrintPath(rec.poly.clone().setZ(z), start, layer, {
tool: using || nozzle, tool: using || nozzle,
open: true, open: true,
simple: true simple: true
}); });
layer.last().retract = true;
return start;
} else { } else {
console.log({already_purged: nozzle, from: track, layer}); console.log({already_purged: nozzle, from: track, layer});
} }
@ -812,7 +817,7 @@ let gs_kiri_fdm = exports;
time += timeDwell; time += timeDwell;
} }
function retract() { function retract(zhop) {
retracted = retDist; retracted = retDist;
moveTo({e:-retracted}, retSpeed, `retract ${retDist}`); moveTo({e:-retracted}, retSpeed, `retract ${retDist}`);
if (zhop) moveTo({z:zpos + zhop}, seekMMM, "zhop up"); if (zhop) moveTo({z:zpos + zhop}, seekMMM, "zhop up");
@ -825,24 +830,26 @@ let gs_kiri_fdm = exports;
} }
let o = [!rate && !newpos.e ? 'G0' : 'G1']; let o = [!rate && !newpos.e ? 'G0' : 'G1'];
if (typeof newpos.x === 'number') { if (typeof newpos.x === 'number') {
pos.x = UTIL.round(newpos.x,decimals); pos.x = newpos.x;//UTIL.round(newpos.x,decimals);
o.append(" X").append(pos.x.toFixed(decimals)); o.append(" X").append(pos.x.toFixed(decimals));
} }
if (typeof newpos.y === 'number') { if (typeof newpos.y === 'number') {
pos.y = UTIL.round(newpos.y,decimals); pos.y = newpos.y;//UTIL.round(newpos.y,decimals);
o.append(" Y").append(pos.y.toFixed(decimals)); o.append(" Y").append(pos.y.toFixed(decimals));
} }
if (typeof newpos.z === 'number') { if (typeof newpos.z === 'number') {
pos.z = UTIL.round(newpos.z,decimals); pos.z = newpos.z;//UTIL.round(newpos.z,decimals);
o.append(" Z").append(pos.z.toFixed(decimals)); o.append(" Z").append(pos.z.toFixed(decimals));
} }
if (typeof newpos.e === 'number') { if (typeof newpos.e === 'number') {
outputLength += newpos.e; outputLength += newpos.e;
if (extrudeAbs) { if (extrudeAbs) {
// for cumulative (absolute) extruder positions // for cumulative (absolute) extruder positions
o.append(" E").append(UTIL.round(outputLength, decimals)); // o.append(" E").append(UTIL.round(outputLength, decimals));
o.append(" E").append(outputLength.toFixed(decimals));
} else { } else {
o.append(" E").append(UTIL.round(newpos.e, decimals)); // o.append(" E").append(UTIL.round(newpos.e, decimals));
o.append(" E").append(newpos.e.toFixed(decimals));
} }
} }
if (rate && rate != pos.f) { if (rate && rate != pos.f) {
@ -964,7 +971,7 @@ let gs_kiri_fdm = exports;
// re-engage post-retraction before new extrusion // re-engage post-retraction before new extrusion
if (out.emit && retracted) { if (out.emit && retracted) {
// when enabled, resume previous Z // when enabled, resume previous Z
if (zhop) moveTo({z:zpos}, seekMMM, "zhop down"); if (zhop && pos.z != zpos) moveTo({z:zpos}, seekMMM, "zhop down");
// re-engage retracted filament // re-engage retracted filament
moveTo({e:retracted}, retSpeed, `engage ${retracted}`); moveTo({e:retracted}, retSpeed, `engage ${retracted}`);
retracted = 0; retracted = 0;
@ -978,14 +985,17 @@ let gs_kiri_fdm = exports;
moveTo({x:x, y:y, e:emitMM}, speedMMM); moveTo({x:x, y:y, e:emitMM}, speedMMM);
emitted += emitMM; emitted += emitMM;
} else { } else {
moveTo({x:x, y:y}, seekMMM);
// TODO disabling out of plane z moves until a better mechanism
// can be built that doesn't rely on computed zpos from layer heights...
// when making z moves (like polishing) allow slowdown vs fast seek // when making z moves (like polishing) allow slowdown vs fast seek
let moveSpeed = (lastp && lastp.z !== z) ? speedMMM : seekMMM; // let moveSpeed = (lastp && lastp.z !== z) ? speedMMM : seekMMM;
moveTo({x:x, y:y, z:z}, moveSpeed); // moveTo({x:x, y:y, z:z}, moveSpeed);
} }
// retract filament // retract filament if point retract flag set
if (!retracted && out.retract) { if (!retracted && out.retract) {
retract(); retract(zhop);
} }
// update time and distance (should calc in moveTo() instead) // update time and distance (should calc in moveTo() instead)

4
js/kiri-init.js
View file

@ -1413,8 +1413,8 @@ var gs_kiri_init = exports;
zHopDistance: UC.newInput(LANG.ad_zhop_s, {title:LANG.ad_zhop_l, bound:UC.bound(0,3.0), convert:UC.toFloat, modes:FDM, expert:true}), zHopDistance: UC.newInput(LANG.ad_zhop_s, {title:LANG.ad_zhop_l, bound:UC.bound(0,3.0), convert:UC.toFloat, modes:FDM, expert:true}),
antiBacklash: UC.newInput(LANG.ad_abkl_s, {title:LANG.ad_abkl_l, bound:UC.bound(0,3), convert:UC.toInt, modes:FDM, expert:true}), antiBacklash: UC.newInput(LANG.ad_abkl_s, {title:LANG.ad_abkl_l, bound:UC.bound(0,3), convert:UC.toInt, modes:FDM, expert:true}),
// detectThinWalls: UC.newBoolean("thin wall fill", onBooleanClick, {title: "detect and fill thin openings\nbetween shells walls", modes:FDM, expert:true}) // detectThinWalls: UC.newBoolean("thin wall fill", onBooleanClick, {title: "detect and fill thin openings\nbetween shells walls", modes:FDM, expert:true})
polishLayers: LOCAL ? UC.newInput(LANG.ad_play_s, {title:LANG.ad_play_l, bound:UC.bound(0,10), convert:UC.toFloat, modes:FDM, expert:true}) : null, // polishLayers: LOCAL ? UC.newInput(LANG.ad_play_s, {title:LANG.ad_play_l, bound:UC.bound(0,10), convert:UC.toFloat, modes:FDM, expert:true}) : null,
polishSpeed: LOCAL ? UC.newInput(LANG.ad_pspd_s, {title:LANG.ad_pspd_l, bound:UC.bound(10,2000), convert:UC.toInt, modes:FDM, expert:true}) : null, // polishSpeed: LOCAL ? UC.newInput(LANG.ad_pspd_s, {title:LANG.ad_pspd_l, bound:UC.bound(10,2000), convert:UC.toInt, modes:FDM, expert:true}) : null,
gcodePauseLayers: UC.newInput(LANG.ag_paws_s, {title:LANG.ag_paws_l, modes:FDM, expert:true}), gcodePauseLayers: UC.newInput(LANG.ag_paws_s, {title:LANG.ag_paws_l, modes:FDM, expert:true}),
outputLayerRetract: UC.newBoolean(LANG.ad_lret_s, onBooleanClick, {title:LANG.ad_lret_l, modes:FDM, expert:true}) outputLayerRetract: UC.newBoolean(LANG.ad_lret_s, onBooleanClick, {title:LANG.ad_lret_l, modes:FDM, expert:true})
}); });