2105 lines
80 KiB
JavaScript
2105 lines
80 KiB
JavaScript
/** Copyright Stewart Allen <sa@grid.space> -- All Rights Reserved */
|
|
|
|
"use strict";
|
|
|
|
(function() {
|
|
|
|
if (!self.kiri.driver) self.kiri.driver = { };
|
|
if (self.kiri.driver.CAM) return;
|
|
|
|
const KIRI = self.kiri,
|
|
BASE = self.base,
|
|
UTIL = BASE.util,
|
|
POLY = BASE.polygons,
|
|
CAM = KIRI.driver.CAM = {
|
|
init,
|
|
slice,
|
|
sliceRender,
|
|
printSetup,
|
|
printExport,
|
|
printRender,
|
|
getToolById,
|
|
getToolDiameter,
|
|
},
|
|
CPRO = CAM.process = {
|
|
LEVEL: 1,
|
|
ROUGH: 2,
|
|
OUTLINE: 3,
|
|
CONTOUR_X: 4,
|
|
CONTOUR_Y: 5,
|
|
TRACE: 6,
|
|
DRILL: 7
|
|
},
|
|
MODES = [
|
|
"unset",
|
|
"level",
|
|
"rough",
|
|
"outline",
|
|
"contour-x",
|
|
"contour-y",
|
|
"trace",
|
|
"drill"
|
|
],
|
|
HPI = Math.PI/2,
|
|
SLICER = KIRI.slicer,
|
|
newLine = BASE.newLine,
|
|
newSlice = KIRI.newSlice,
|
|
newPoint = BASE.newPoint,
|
|
newPolygon = BASE.newPolygon,
|
|
time = UTIL.time;
|
|
|
|
function init(kiri, api) {
|
|
api.event.on("mode.set", (mode) => {
|
|
let isCAM = mode === 'CAM';
|
|
$('set-tools').style.display = isCAM ? '' : 'none';
|
|
kiri.space.platform.setColor(isCAM ? 0xeeeeee : 0xcccccc);
|
|
});
|
|
api.event.on("settings.saved", (settings) => {
|
|
let proc = settings.process;
|
|
api.ui.camTabs.marker.style.display = proc.camTabsOn ? 'flex' : 'none';
|
|
api.ui.camRough.marker.style.display = proc.camRoughOn ? 'flex' : 'none';
|
|
api.ui.camDrill.marker.style.display =
|
|
proc.camDrillingOn || proc.camDrillReg !== 'none' ? 'flex' : 'none';
|
|
api.ui.camOutline.marker.style.display = proc.camOutlineOn ? 'flex' : 'none';
|
|
api.ui.camContour.marker.style.display =
|
|
proc.camContourXOn || proc.camContourYOn ? 'flex' : 'none';
|
|
});
|
|
}
|
|
|
|
function getToolById(settings, id) {
|
|
for (let i=0, t=settings.tools; i<t.length; i++) {
|
|
if (t[i].id === id) return t[i];
|
|
}
|
|
return null;
|
|
};
|
|
|
|
function getToolDiameter(settings, id) {
|
|
let tool = getToolById(settings, id);
|
|
if (!tool) return 0;
|
|
return (tool.metric ? 1 : 25.4) * tool.flute_diam;
|
|
};
|
|
|
|
function getToolTipDiameter(settings, id) {
|
|
let tool = getToolById(settings, id);
|
|
if (!tool) return 0;
|
|
return (tool.metric ? 1 : 25.4) * tool.taper_tip;
|
|
};
|
|
|
|
function getToolShaftDiameter(settings, id) {
|
|
let tool = getToolById(settings, id);
|
|
if (!tool) return 0;
|
|
return (tool.metric ? 1 : 25.4) * tool.shaft_diam;
|
|
};
|
|
|
|
function getToolShaftOffset(settings, id) {
|
|
let tool = getToolById(settings, id);
|
|
if (!tool) return 0;
|
|
return (tool.metric ? 1 : 25.4) * tool.flute_len;
|
|
};
|
|
|
|
function createToolProfile(settings, id, topo) {
|
|
// generate tool profile
|
|
let tool = getToolById(settings, id),
|
|
ball = tool.type === "ballmill",
|
|
taper = tool.type === "tapermill",
|
|
shaft_diameter = getToolShaftDiameter(settings, id),
|
|
shaft_radius = shaft_diameter / 2,
|
|
shaft_pix_float = shaft_diameter / topo.resolution,
|
|
shaft_pix_int = Math.round(shaft_pix_float),
|
|
shaft_radius_pix_float = shaft_pix_float / 2,
|
|
shaft_offset = getToolShaftOffset(settings, id),
|
|
flute_diameter = getToolDiameter(settings, id),
|
|
flute_radius = flute_diameter / 2,
|
|
flute_pix_float = flute_diameter / topo.resolution,
|
|
// flute_pix_int = Math.round(flute_pix_float),
|
|
flute_radius_pix_float = flute_pix_float / 2,
|
|
tip_diameter = getToolTipDiameter(settings, id),
|
|
tip_pix_float = tip_diameter / topo.resolution,
|
|
tip_radius_pix_float = tip_pix_float / 2,
|
|
tip_max_radius_offset = flute_radius_pix_float - tip_radius_pix_float,
|
|
profile_pix_iter = shaft_pix_int + (1 - shaft_pix_int % 2),
|
|
toolCenter = (shaft_pix_int - (shaft_pix_int % 2)) / 2,
|
|
toolOffset = [],
|
|
larger_shaft = shaft_diameter - flute_diameter > 0.001;
|
|
|
|
// console.log({
|
|
// tool: tool.name,
|
|
// rez: topo.resolution,
|
|
// diam: flute_diameter,
|
|
// pix: flute_pix_float.toFixed(2),
|
|
// rad: flute_radius_pix_float.toFixed(2),
|
|
// tocks: profile_pix_iter,
|
|
// shaft_offset,
|
|
// larger_shaft
|
|
// });
|
|
|
|
// for each point in tool profile, check inside radius
|
|
for (let x = 0; x < profile_pix_iter; x++) {
|
|
for (let y = 0; y < profile_pix_iter; y++) {
|
|
let dx = x - toolCenter,
|
|
dy = y - toolCenter,
|
|
dist_from_center = Math.sqrt(dx * dx + dy * dy);
|
|
if (dist_from_center <= flute_radius_pix_float) {
|
|
// console.log({x,y,dx,dy,dist:dist_from_center,ln:dbl.length})
|
|
// flute offset points
|
|
let z_offset = 0;
|
|
if (ball) {
|
|
z_offset = (1 - Math.cos((dist_from_center / flute_radius_pix_float) * HPI)) * -flute_radius;
|
|
} else if (taper && dist_from_center >= tip_radius_pix_float) {
|
|
z_offset = ((dist_from_center - tip_radius_pix_float) / tip_max_radius_offset) * -shaft_offset;
|
|
}
|
|
toolOffset.push(dx, dy, z_offset);
|
|
} else if (shaft_offset && larger_shaft && dist_from_center <= shaft_radius_pix_float) {
|
|
// shaft offset points
|
|
toolOffset.push(dx, dy, -shaft_offset);
|
|
}
|
|
}
|
|
}
|
|
return toolOffset;
|
|
};
|
|
|
|
/**
|
|
* find highest z on a line segment
|
|
* x,y are in platform coodinates
|
|
*/
|
|
function getTopoZPathMax(widget, profile, x1, y1, x2, y2) {
|
|
|
|
let topo = widget.topo,
|
|
rez = topo.resolution,
|
|
bounds = widget.getBoundingBox(),
|
|
dx = x2-x1,
|
|
dy = y2-y1,
|
|
md = Math.max(Math.abs(dx),Math.abs(dy)),
|
|
mi = md / rez,
|
|
ix = dx / mi,
|
|
iy = dy / mi,
|
|
zmax = 0;
|
|
|
|
// implement fast grid fingerprinting. if no z variance within
|
|
// the scan area (or min scan delta set from last point), then
|
|
// use the last computed zmax and carry on
|
|
while (mi-- > 0) {
|
|
let tx1 = Math.round((x1 - bounds.min.x) / rez),
|
|
ty1 = Math.round((y1 - bounds.min.y) / rez);
|
|
zmax = Math.max(zmax, getMaxTopoToolZ(topo, profile, tx1, ty1, true));
|
|
x1 += ix;
|
|
y1 += iy;
|
|
}
|
|
|
|
return zmax;
|
|
};
|
|
|
|
/**
|
|
* x,y are in topo grid int coordinates
|
|
*/
|
|
function getMaxTopoToolZ(topo, profile, x, y, floormax) {
|
|
let tv, tx, ty, tz, gv, i = 0, mz = -1;
|
|
|
|
const sx = topo.stepsx, sy = topo.stepsy, xl = sx - 1, yl = sy - 1;
|
|
|
|
while (i < profile.length) {
|
|
// tool profile point x, y, and z offsets
|
|
let tx = profile[i++] + x;
|
|
let ty = profile[i++] + y;
|
|
let tz = profile[i++];
|
|
if (tx < 0 || tx > xl || ty < 0 || ty > yl) {
|
|
// if outside max topo steps, use 0
|
|
gv = 0;
|
|
} else {
|
|
// lookup grid value @ tx, ty
|
|
gv = topo.data[tx * sy + ty] || 0;
|
|
}
|
|
// inside the topo but off the part
|
|
if (floormax && gv === 0) {
|
|
// return topo.bounds.max.z;
|
|
gv = topo.bounds.max.z;
|
|
}
|
|
// update the rest
|
|
mz = Math.max(tz + gv, mz);
|
|
}
|
|
|
|
return Math.max(mz,0);
|
|
};
|
|
|
|
/**
|
|
* call out to slicer
|
|
*/
|
|
function doSlicing(widget, options, ondone, onupdate) {
|
|
SLICER.sliceWidget(widget, options, ondone, onupdate);
|
|
}
|
|
|
|
/**
|
|
* top down progressive union
|
|
*/
|
|
function pancake(slices, onupdate) {
|
|
let union, tops, last;
|
|
|
|
slices.forEach(function(slice,index) {
|
|
tops = slice.gatherTopPolys([]).clone(true);
|
|
if (!union) {
|
|
union = tops;
|
|
} else {
|
|
// replace slice's tops with unioned tops
|
|
tops.appendAll(union);
|
|
union = POLY.union(tops);
|
|
slice.tops = [];
|
|
union.forEach(function(poly) {
|
|
slice.addTop(poly);
|
|
poly.setZ(slice.z);
|
|
});
|
|
}
|
|
last = slice;
|
|
if (onupdate) onupdate(index/slices.length);
|
|
});
|
|
|
|
return last.clone(false);
|
|
}
|
|
|
|
/**
|
|
* bottom up progressive intersection of holes
|
|
*/
|
|
function holes(slices, offset, onupdate) {
|
|
let last;
|
|
|
|
slices.slice().reverse().forEach(function(slice,index) {
|
|
let holes = slice.gatherTopPolyInners([]).clone();
|
|
if (last) {
|
|
let inter = [];
|
|
// find intersection of hole below and hole in this layer
|
|
holes.forEach(hole => {
|
|
last.forEach(hole_under => {
|
|
inter.appendAll(hole.intersect(hole_under));
|
|
});
|
|
});
|
|
// filter dup polygons (which intersect can produce)
|
|
last = inter.filter((poly, index, arr) => {
|
|
for (let i=index+1, il=arr.length; i<il; i++) {
|
|
if (arr[i].isEquivalent(poly)) return false;
|
|
}
|
|
return true;
|
|
});
|
|
} else {
|
|
last = holes;
|
|
}
|
|
// console.log('holes', slice.z, index, holes, last);
|
|
if (onupdate) onupdate(index/slices.length);
|
|
});
|
|
|
|
let out = [];
|
|
POLY.expand(last, -offset*1.1, 0, out, 1);
|
|
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* @param {Slice[]} slices
|
|
* @param {number} z position
|
|
*
|
|
* return slice closest to specified z
|
|
*/
|
|
function closestSliceToZ(slices, z) {
|
|
let selected = null,
|
|
distance = Infinity,
|
|
nextdist;
|
|
slices.forEach(function(slice) {
|
|
nextdist = Math.abs(slice.z - z);
|
|
if (nextdist < distance) {
|
|
selected = slice;
|
|
distance = nextdist;
|
|
}
|
|
});
|
|
return selected;
|
|
}
|
|
|
|
/**
|
|
* select from pancaked layers
|
|
*/
|
|
function selectSlices(slices, step, mode, output) {
|
|
let last, zlastout, emitted = [];
|
|
|
|
function emit(slice) {
|
|
// prevent double emit at end
|
|
if (last === slice) return;
|
|
last = slice;
|
|
if (slice.camMode) {
|
|
// clone to prevent double emit
|
|
let nuslice = newSlice(slice.z);
|
|
slice.tops.forEach(function(top) {
|
|
nuslice.addTop(top.poly.clone(true));
|
|
});
|
|
slice = nuslice;
|
|
}
|
|
slice.camMode = mode;
|
|
zlastout = slice.z;
|
|
emitted.push(slice);
|
|
}
|
|
|
|
// - find mandatory slices (with flats)
|
|
// - divide space between by step (interpolate)
|
|
// - select smallest divisible gap
|
|
let forced = [ slices[0] ];
|
|
slices.forEach(function(slice) {
|
|
if (slice.hasFlats) forced.push(slice);
|
|
})
|
|
|
|
let mid = [];
|
|
forced.forEachPair(function(s1, s2) {
|
|
// skip last to first pair
|
|
if (s2.z > s1.z) return;
|
|
let delta = Math.abs(s2.z - s1.z),
|
|
inc = delta / step,
|
|
nstep = step,
|
|
dec = inc - Math.floor(inc),
|
|
slop = step * 0.02; // allow 2% over/under on step alignment
|
|
// skip if delta close to step
|
|
if (Math.abs(delta - step) < slop) {
|
|
return;
|
|
}
|
|
// add another step if decimal too high
|
|
if (dec > slop) nstep = delta / Math.ceil(inc);
|
|
// find closest slices in-between
|
|
for (let zv = s1.z - nstep; zv >= s2.z + nstep/2; zv -= nstep) {
|
|
mid.push(closestSliceToZ(slices, zv));
|
|
}
|
|
}, 1);
|
|
|
|
forced.appendAll(mid);
|
|
forced.sort(function(s1, s2) { return s2.z - s1.z; });
|
|
|
|
// drop first/top slice. it's not an actual cut. it was
|
|
// added in the beginning to force layer interpolation.
|
|
forced = forced.slice(1);
|
|
forced.forEach(function(slice) {
|
|
emit(slice);
|
|
});
|
|
|
|
// add to output array
|
|
emitted.forEach(function(slice) {
|
|
output.push(slice);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @param {Widget} widget
|
|
* @param {Object} settings
|
|
* @param {Function} ondone
|
|
* @param {Function} onupdate
|
|
*/
|
|
function generateTopoMap(widget, settings, ondone, onupdate) {
|
|
let mesh = widget.mesh,
|
|
proc = settings.process,
|
|
outp = settings.process,
|
|
units = settings.controller.units === 'in' ? 25.4 : 1,
|
|
resolution = outp.camTolerance * units,
|
|
diameter = getToolDiameter(settings, proc.camContourTool),
|
|
tool = getToolById(settings, proc.camContourTool),
|
|
toolStep = diameter * proc.camContourOver,
|
|
traceJoin = diameter / 2,
|
|
pocketOnly = proc.camOutlinePocket,
|
|
bounds = widget.getBoundingBox().clone(),
|
|
minX = bounds.min.x,// - diameter,
|
|
maxX = bounds.max.x,// + diameter,
|
|
minY = bounds.min.y,// - diameter,
|
|
maxY = bounds.max.y,// + diameter,
|
|
zBottom = outp.camZBottom * units,
|
|
boundsX = maxX - minX,
|
|
boundsY = maxY - minY,
|
|
maxangle = proc.camContourAngle,
|
|
curvesOnly = proc.camContourCurves,
|
|
R2A = 180 / Math.PI,
|
|
stepsx = Math.ceil(boundsX / resolution),
|
|
stepsy = Math.ceil(boundsY / resolution),
|
|
data = new Float32Array(stepsx * stepsy),
|
|
topo = widget.topo = {
|
|
data: data,
|
|
stepsx: stepsx,
|
|
stepsy: stepsy,
|
|
bounds: bounds,
|
|
diameter: diameter,
|
|
resolution: resolution
|
|
},
|
|
toolOffset = createToolProfile(settings, proc.camContourTool, topo),
|
|
newslices = [],
|
|
newlines,
|
|
newtop,
|
|
newtrace,
|
|
sliceout,
|
|
latent,
|
|
lastP,
|
|
slice, lx, ly,
|
|
startTime = time();
|
|
|
|
// return highest z within tools radius
|
|
function maxzat(x,y) {
|
|
return getMaxTopoToolZ(topo, toolOffset, x, y);
|
|
}
|
|
|
|
function push_point(x,y,z) {
|
|
let newP = newPoint(x,y,z);
|
|
if (lastP && lastP.z === z) {
|
|
if (curvesOnly) {
|
|
end_poly();
|
|
} else {
|
|
latent = newP;
|
|
}
|
|
} else {
|
|
if (latent) {
|
|
newtrace.push(latent);
|
|
latent = null;
|
|
}
|
|
newtrace.push(newP);
|
|
}
|
|
lastP = newP;
|
|
}
|
|
|
|
function end_poly() {
|
|
if (latent) {
|
|
newtrace.push(latent);
|
|
}
|
|
if (newtrace.length > 0) {
|
|
// add additional constraint on min perimeter()
|
|
if (newtrace.length > 1) {
|
|
sliceout.push(newtrace);
|
|
}
|
|
newtrace = newPolygon().setOpen();
|
|
}
|
|
latent = undefined;
|
|
lastP = undefined;
|
|
}
|
|
|
|
function topoSlicesDone(slices) {
|
|
let gridx = 0,
|
|
gridy,
|
|
gridi, // index
|
|
gridv, // value
|
|
zMin = Math.max(bounds.min.z, zBottom) + 0.0001,
|
|
x, y, tv, ltv;
|
|
|
|
// for each Y slice, find z grid value (x/z swapped)
|
|
for (let j=0, jl=slices.length; j<jl; j++) {
|
|
let slice = slices[j],
|
|
lines = slice.lines;
|
|
gridy = 0;
|
|
// slices have x/z swapped
|
|
for (y = minY; y < maxY && gridy < stepsy; y += resolution) {
|
|
gridi = gridx * stepsy + gridy;
|
|
gridv = data[gridi] || 0;
|
|
// strategy using raw lines (faster slice, but more lines)
|
|
for (let i=0, il=lines.length; i<il; i++) {
|
|
let line = lines[i], p1 = line.p1, p2 = line.p2;
|
|
if (
|
|
(p1.z > zMin || p2.z > zMin) && // one endpoint above 0
|
|
(p1.z > gridv || p2.z > gridv) && // one endpoint above gridv
|
|
((p1.y <= y && p2.y >= y) || // one endpoint left
|
|
(p2.y <= y && p1.y >= y)) // one endpoint right
|
|
) {
|
|
let dy = p1.y - p2.y,
|
|
dz = p1.z - p2.z,
|
|
pct = (p1.y - y) / dy,
|
|
nz = p1.z - (dz * pct);
|
|
if (nz > gridv) {
|
|
gridv = data[gridi] = Math.max(nz, zMin);
|
|
}
|
|
}
|
|
}
|
|
gridy++;
|
|
}
|
|
gridx++;
|
|
onupdate(0.20 + (gridx/stepsx) * 0.50, "trace surface");
|
|
}
|
|
|
|
// x contouring
|
|
if (proc.camContourXOn) {
|
|
startTime = time();
|
|
// emit slice per X
|
|
for (x = minX; x <= maxX; x += toolStep) {
|
|
gridx = Math.round(((x - minX) / boundsX) * stepsx);
|
|
ly = gridy = 0;
|
|
slice = newSlice(gridx, mesh.newGroup ? mesh.newGroup() : null);
|
|
slice.camMode = CPRO.CONTOUR_X;
|
|
slice.lines = newlines = [];
|
|
newtop = slice.addTop(newPolygon().setOpen()).poly;
|
|
newtrace = newPolygon().setOpen();
|
|
sliceout = slice.tops[0].traces = [ ];
|
|
for (y = minY; y < maxY; y += resolution) {
|
|
if (pocketOnly && (data[gridx * stepsy + gridy] || 0) === 0) {
|
|
end_poly();
|
|
gridy++;
|
|
ly = 0;
|
|
continue;
|
|
}
|
|
tv = maxzat(gridx, gridy);
|
|
if (tv === 0) {
|
|
end_poly();
|
|
gridy++;
|
|
ly = 0;
|
|
continue;
|
|
}
|
|
if (ly) {
|
|
if (mesh) newlines.push(newLine(
|
|
newPoint(x,ly,ltv),
|
|
newPoint(x,y,tv)
|
|
));
|
|
let ang = Math.abs((Math.atan2(ltv - tv, resolution) * R2A) % 90);
|
|
// over max angle, turn into square edge (up or down)
|
|
if (ang > maxangle) {
|
|
if (ltv > tv) {
|
|
// down = forward,down
|
|
push_point(x,y,ltv);
|
|
} else {
|
|
// up = up,forward
|
|
push_point(x,ly,tv);
|
|
}
|
|
}
|
|
}
|
|
push_point(x,y,tv);
|
|
ly = y;
|
|
ltv = tv;
|
|
gridy++;
|
|
}
|
|
end_poly();
|
|
if (sliceout.length > 0) {
|
|
newslices.push(slice);
|
|
}
|
|
onupdate(0.70 + (gridx/stepsx) * 0.15, "contour x");
|
|
}
|
|
}
|
|
|
|
// y contouring
|
|
if (proc.camContourYOn) {
|
|
startTime = time();
|
|
// emit slice per Y
|
|
for (y = minY; y <= maxY; y += toolStep) {
|
|
gridy = Math.round(((y - minY) / boundsY) * stepsy);
|
|
lx = gridx = 0;
|
|
slice = newSlice(gridy, mesh.newGroup ? mesh.newGroup() : null);
|
|
slice.camMode = CPRO.CONTOUR_Y;
|
|
slice.lines = newlines = [];
|
|
newtop = slice.addTop(newPolygon().setOpen()).poly;
|
|
newtrace = newPolygon().setOpen();
|
|
sliceout = slice.tops[0].traces = [ ];
|
|
for (x = minX; x <= maxX; x += resolution) {
|
|
if (pocketOnly && (data[gridx * stepsy + gridy] || 0) === 0) {
|
|
end_poly();
|
|
gridx++;
|
|
ly = 0;
|
|
continue;
|
|
}
|
|
tv = maxzat(gridx, gridy);
|
|
if (tv === 0) {
|
|
end_poly();
|
|
gridx++;
|
|
lx = 0;
|
|
continue;
|
|
}
|
|
if (lx) {
|
|
if (mesh) newlines.push(newLine(
|
|
newPoint(lx,y,ltv),
|
|
newPoint(x,y,tv)
|
|
));
|
|
let ang = Math.abs((Math.atan2(ltv - tv, resolution) * R2A) % 90);
|
|
// over max angle, turn into square edge (up or down)
|
|
if (ang > maxangle) {
|
|
if (ltv > tv) {
|
|
// down = forward,down
|
|
push_point(x,y,ltv);
|
|
} else {
|
|
// up = up,forward
|
|
push_point(lx,y,tv);
|
|
}
|
|
}
|
|
}
|
|
push_point(x,y,tv);
|
|
lx = x;
|
|
ltv = tv;
|
|
gridx++;
|
|
}
|
|
end_poly();
|
|
if (sliceout.length > 0) {
|
|
newslices.push(slice);
|
|
}
|
|
onupdate(0.85 + (gridy/stepsy) * 0.15, "contour y");
|
|
}
|
|
}
|
|
|
|
ondone(newslices);
|
|
}
|
|
|
|
// slices progress left-to-right along the X axis
|
|
doSlicing(widget, {height:resolution, swapX:true, topo:true}, topoSlicesDone, function(update) {
|
|
onupdate(0.0 + update * 0.20, "topo slice");
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Create facing passes in CAM mode
|
|
*
|
|
* @param {Slice} slice target
|
|
* @param {Polygon[]} shell enclosing slice tops
|
|
* @param {number} diameter of tool
|
|
* @param {number} overlap % on each pass
|
|
* @param {boolean} true for pocket only mode
|
|
* @param {number} bounds shell offset
|
|
* @returns {Object} shell
|
|
*/
|
|
function createLevelPaths(slice, shell, diameter, overlap, pocket) {
|
|
let outer = [],
|
|
offset = [];
|
|
|
|
// clone and flatten the shell with tops to offset array
|
|
shell.clone(true).forEach(function(poly) { poly.setZ(slice.z).flattenTo(offset) });
|
|
|
|
// re-nest offset array
|
|
offset = POLY.nest(offset);
|
|
|
|
// inset offset array by 1/2 diameter then by tool overlap %
|
|
POLY.expand(offset, - (diameter / 2), slice.z, outer, 0, -diameter * overlap);
|
|
|
|
if (!pocket) {
|
|
// re-flatten offset polys
|
|
offset = POLY.flatten(outer.slice(), []);
|
|
// re-clone shell to offset polys (because it was lost in the offset)
|
|
shell.clone(true).forEach(function(poly) { poly.setZ(slice.z).flattenTo(offset) });
|
|
// re-nest offset polys
|
|
outer = POLY.nest(offset);
|
|
}
|
|
|
|
if (!slice.tops.length) { console.log({no_top: slice.z}); slice.addTop() }
|
|
|
|
slice.tops[0].traces = outer;
|
|
};
|
|
|
|
/**
|
|
* Create roughing offsets in CAM mode
|
|
*
|
|
* @param {Slice} slice target
|
|
* @param {Polygon[]} shell enclosing slice tops
|
|
* @param {number} diameter of tool (mm)
|
|
* @param {number} stock to leave (mm)
|
|
* @param {number} percent overlap on each pass
|
|
* @param {boolean} true for pocket only mode
|
|
* @param {boolean} widecut expand outer cutout
|
|
* @returns {Object} shell or newly generated shell
|
|
*/
|
|
function createRoughPaths(slice, shell, diameter, stock, overlap, pocket, holes, widecut) {
|
|
let tops = slice.gatherTopPolys([]).clone(true),
|
|
outer = [],
|
|
offset = [];
|
|
|
|
// when holes present, use them as fake top offsets
|
|
// to prevent clearing out the entire thru pocket
|
|
if (holes) {
|
|
tops.appendAll(holes);
|
|
}
|
|
|
|
// clone and flatten the shell with tops to offset array
|
|
shell.clone(true).forEach(function(poly) { poly.setZ(slice.z).flattenTo(offset) });
|
|
POLY.flatten(tops, offset, true);
|
|
|
|
// only tab cut polys should be open
|
|
offset.forEach(function(trace) {
|
|
trace.setClosed();
|
|
});
|
|
|
|
// re-nest offset array
|
|
offset = POLY.nest(offset);
|
|
|
|
// inset offset array by 1/2 diameter then by tool overlap %
|
|
POLY.expand(offset, - (diameter / 2 + stock), slice.z, outer, 0, -diameter * overlap);
|
|
|
|
if (!pocket) {
|
|
// re-flatten offset polys
|
|
offset = POLY.flatten(outer.slice(), [], true);
|
|
// re-clone shell to offset polys (because it was lost in the offset)
|
|
shell.clone(true).forEach(function(poly) {
|
|
poly.setZ(slice.z).flattenTo(offset);
|
|
poly.setClosed();
|
|
});
|
|
// re-nest offset polys
|
|
// outer = POLY.nest(offset);
|
|
outer = offset;
|
|
// more outer
|
|
if (widecut) {
|
|
POLY.expand(offset, diameter * overlap, slice.z, outer, 1);
|
|
}
|
|
}
|
|
|
|
slice.tops[0].traces = outer;
|
|
};
|
|
|
|
/**
|
|
* Find top paths to trace when using ball and taper mills
|
|
* in waterline outlining and tracing modes.
|
|
*/
|
|
function findTracingPaths(widget, slice, tool, profile, partial) {
|
|
// for now, only emit completed polys and not segments
|
|
// TODO consider limiting to nup path lengths that are >= tool radius
|
|
let only_whole = !partial;
|
|
// check for ball and taper mills paths and add to top[0].inner
|
|
let polys = [];
|
|
let nups = [];
|
|
let cull = [];
|
|
slice.gatherTopPolys([]).forEach(poly => poly.flattenTo(polys));
|
|
polys.forEach(poly => {
|
|
let pz = poly.first().z;
|
|
let mz = -Infinity;
|
|
let np = newPolygon().setOpen();
|
|
let mp = 0;
|
|
// find top poly segments that are not significantly offset
|
|
// from tool profile and add to new polygons which accumulate
|
|
// to the top inner array
|
|
poly.forEachSegment((p1,p2) => {
|
|
let nz = getTopoZPathMax(widget, profile, p1.x, p1.y, p2.x, p2.y);
|
|
if (nz > mz) {
|
|
mz = nz;
|
|
}
|
|
// this # should be computed from topo resolution
|
|
if (nz - pz < 0.01) {
|
|
mp++
|
|
if (np.length) {
|
|
if (!np.first().isEqual(p2)) {
|
|
np.append(p2);
|
|
} else {
|
|
np.setClosed();
|
|
}
|
|
} else {
|
|
np.append(p1).append(p2);
|
|
}
|
|
} else if (np.length) {
|
|
if (!only_whole) {
|
|
nups.append(np);
|
|
}
|
|
np = newPolygon().setOpen();
|
|
}
|
|
});
|
|
if (np.length) {
|
|
if (np.length === poly.length) {
|
|
np.setClosed();
|
|
}
|
|
// if a trace poly has no interruptions for an endmill
|
|
// and it's an inner poly, eliminate it from the parent
|
|
// so it won't be offset.
|
|
let parent = poly.parent;
|
|
if (np.isClosed() && parent) {
|
|
// console.log(slice.z,'cull',poly);
|
|
if (parent.inner) {
|
|
parent.inner = parent.inner.filter(p => p !== poly);
|
|
}
|
|
if (only_whole) {
|
|
nups.append(np);
|
|
}
|
|
}
|
|
if (!only_whole) {
|
|
nups.append(np);
|
|
}
|
|
}
|
|
});
|
|
if (nups.length) {
|
|
// console.log(slice.z,'nups',nups.length);
|
|
slice.tops[0].inner = nups;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create CAM outlining offsets
|
|
*
|
|
* @param {Slice} slice target
|
|
* @param {Polygon[]} outermost pancacked shells for fill
|
|
* @param {number} tool diameter
|
|
* @param {boolean} pocket only
|
|
* @param {boolean} widecut expand outer cutout
|
|
*/
|
|
function createOutlinePaths(slice, shell, diameter, pocket, widecut) {
|
|
if (slice.tops.length === 0) return shell;
|
|
|
|
let tops = slice.gatherTopPolys([]).clone(true),
|
|
offset = POLY.expand(tops, diameter / 2, slice.z);
|
|
|
|
// when pocket only, drop first outer poly
|
|
// if it matches the shell and promote inner polys
|
|
if (pocket) {
|
|
offset = POLY.filter(POLY.diff(shell, offset, slice.z), [], function(poly) {
|
|
if (poly.area() < 1) return null;
|
|
for (let sp=0; sp<shell.length; sp++) {
|
|
// eliminate shell only polys
|
|
if (poly.isEquivalent(shell[sp])) {
|
|
if (poly.inner) return poly.inner;
|
|
return null;
|
|
}
|
|
}
|
|
return poly;
|
|
});
|
|
} else if (widecut) {
|
|
offset.slice().forEach(op => {
|
|
POLY.expand([op], diameter * 0.5, slice.z, offset, 1);
|
|
});
|
|
}
|
|
|
|
const output = POLY.flatten(offset, [], true);
|
|
|
|
slice.tops[0].traces = output;
|
|
|
|
// append inner traces from findTracingPaths
|
|
let inner = slice.tops[0].inner;
|
|
if (inner) {
|
|
// console.log(slice.z,'inner',inner.length)
|
|
// output.append(...inner);
|
|
// slice.tops[0].inner = null;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* DRIVER SLICE CONTRACT
|
|
*
|
|
* @param {Object} settings
|
|
* @param {Widget} widget
|
|
* @param {Function} output
|
|
*/
|
|
function slice(settings, widget, onupdate, ondone) {
|
|
let conf = settings,
|
|
proc = conf.process,
|
|
sliceAll = widget.slices = [],
|
|
unitsName = settings.controller.units,
|
|
units = unitsName === 'in' ? 25.4 : 1,
|
|
roughToolDiam = getToolDiameter(conf, proc.camRoughTool),
|
|
outlineToolDiam = getToolDiameter(conf, proc.camOutlineTool),
|
|
contourToolDiam = getToolDiameter(conf, proc.camContourTool),
|
|
procFacing = proc.camRoughOn && proc.camZTopOffset,
|
|
procRough = proc.camRoughOn && proc.camRoughDown && roughToolDiam,
|
|
procOutline = proc.camOutlineOn && proc.camOutlineDown && outlineToolDiam,
|
|
procContourX = proc.camContourXOn && proc.camOutlinePlunge && contourToolDiam,
|
|
procContourY = proc.camContourYOn && proc.camOutlinePlunge && contourToolDiam,
|
|
procContour = procContourX || procContourY,
|
|
procDrill = proc.camDrillingOn && proc.camDrillDown && proc.camDrillDownSpeed,
|
|
procDrillReg = proc.camDrillReg,
|
|
procTrace = proc.camTraceOn,
|
|
sliceDepth = Math.max(0.1, Math.min(proc.camRoughDown, proc.camOutlineDown) / 3 * units),
|
|
pocketOnlyRough = proc.camRoughPocket,
|
|
pocketOnlyOutline = proc.camOutlinePocket,
|
|
addTabsRough = procRough && proc.camTabsOn && !pocketOnlyRough,
|
|
addTabsOutline = procOutline && proc.camTabsOn && !pocketOnlyOutline,
|
|
tabWidth = proc.camTabsWidth * units,
|
|
tabHeight = proc.camTabsHeight * units,
|
|
bounds = widget.getBoundingBox(),
|
|
mesh = widget.mesh,
|
|
zBottom = proc.camZBottom * units,
|
|
zMin = Math.max(bounds.min.z, zBottom),
|
|
zThru = (proc.camZThru || 0) * units,
|
|
ztoff = proc.camZTopOffset * units,
|
|
camRoughStock = proc.camRoughStock * units,
|
|
camRoughDown = proc.camRoughDown * units,
|
|
shellRough,
|
|
shellOutline,
|
|
facePolys,
|
|
thruHoles,
|
|
wideCut = proc.camWideCutout;
|
|
|
|
if (settings.stock.x + 0.00001 < bounds.max.x - bounds.min.x) {
|
|
return ondone('stock X too small for part. disable stock or use offset stock');
|
|
}
|
|
|
|
if (settings.stock.y + 0.00001 < bounds.max.y - bounds.min.y) {
|
|
return ondone('stock Y too small for part. disable stock or use offset stock');
|
|
}
|
|
|
|
if (settings.stock.z + 0.00001 < bounds.max.z - bounds.min.z) {
|
|
return ondone('stock Z too small for part. disable stock or use offset stock');
|
|
}
|
|
|
|
if (sliceDepth <= 0.05) {
|
|
return ondone(`invalid slice depth (${sliceDepth.toFixed(2)} ${unitsName})`);
|
|
}
|
|
|
|
if (!(procFacing || procRough || procOutline || procContour || procDrill || procDrillReg)) {
|
|
return ondone("no processes selected");
|
|
}
|
|
|
|
if (zMin >= bounds.max.z) {
|
|
return ondone(`invalid z bottom >= bounds z max ${bounds.max.z}`);
|
|
}
|
|
|
|
// cut outside traces at the right points
|
|
const addCutoutTabs = function(slice, toolDiam) {
|
|
// too high
|
|
if (slice.z > zMin + tabHeight) return;
|
|
// skip if no tops | traces
|
|
if (slice.tops.length === 0) return;
|
|
|
|
let notabs = 0;
|
|
let nutrace = [];
|
|
|
|
// find trace with greatest area
|
|
slice.tops[0].traces.forEach(function(trace, index) {
|
|
|
|
// required to match computed order of cutouts
|
|
trace.setClockwise();
|
|
|
|
let count = proc.camTabsCount,
|
|
angle = proc.camTabsAngle,
|
|
angle_inc = 360 / count,
|
|
center = trace.bounds.center(slice.z),
|
|
offset = (tabWidth + toolDiam) / 2,
|
|
ints = [],
|
|
segs = [];
|
|
|
|
while (count-- > 0) {
|
|
let slope = BASE.newSlopeFromAngle(angle),
|
|
normal = BASE.newSlopeFromAngle(angle + 90),
|
|
c1 = center.projectOnSlope(normal, offset),
|
|
c2 = center.projectOnSlope(normal, -offset),
|
|
o1 = c1.projectOnSlope(slope, 10000),
|
|
o2 = c2.projectOnSlope(slope, 10000),
|
|
int1 = trace.intersections(c1, o1).pop(),
|
|
int2 = trace.intersections(c2, o2).pop();
|
|
if (int1 && int2) {
|
|
ints.push(int1);
|
|
ints.push(int2);
|
|
}
|
|
angle -= angle_inc;
|
|
}
|
|
|
|
if (ints.length) {
|
|
ints.push(ints.shift());
|
|
for (let i=0; i<ints.length; i+=2) {
|
|
segs.push(trace.emitSegment(ints[i], ints[i+1]));
|
|
}
|
|
// check for and eliminate overlaps
|
|
for (let i=0, il=segs.length; i < il; i++) {
|
|
let si = segs[i];
|
|
for (let j=i+1; j<il; j++) {
|
|
let sj = segs[j];
|
|
if (sj.overlaps(si)) {
|
|
if (sj.perimeter() > si.perimeter()) {
|
|
sj._overlap = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// replace intersected trace with non-overlapping segments
|
|
nutrace.appendAll(segs.filter(seg => !seg._overlap));
|
|
} else {
|
|
nutrace.push(trace);
|
|
notabs++;
|
|
}
|
|
|
|
});
|
|
|
|
if (notabs) {
|
|
console.log(`unable to compute tabs for ${notabs} traces @ z=${slice.z}`);
|
|
}
|
|
|
|
slice.tops[0].traces = nutrace;
|
|
}
|
|
|
|
// extend bottom cutout
|
|
const addZThru = function(selected) {
|
|
let last = selected[selected.length-1];
|
|
let add = last.clone(true);
|
|
add.camMode = last.camMode;
|
|
add.z -= zThru;
|
|
add.tops.forEach(top => {
|
|
top.poly.setZ(add.z);
|
|
});
|
|
selected.push(add);
|
|
};
|
|
|
|
// called when z-index slicing complete
|
|
const camSlicesDone = function(slices) {
|
|
|
|
// return outermost (bottom layer) "top" polys
|
|
const camShell = pancake(slices, function(update) {
|
|
onupdate(0.25 + update * 0.15, "shelling");
|
|
});
|
|
|
|
// set all default shells
|
|
const camShellPolys = shellRough = shellOutline = facePolys = camShell.gatherTopPolys([]);
|
|
|
|
if (procDrillReg) {
|
|
sliceDrillReg(settings, widget, sliceAll, zThru);
|
|
}
|
|
|
|
if (procDrill) {
|
|
sliceDrill(settings, widget, slices, sliceAll);
|
|
}
|
|
|
|
if (procRough) {
|
|
if (pocketOnlyRough) {
|
|
// expand shell minimally triggering a clean
|
|
shellRough = POLY.expand(shellRough, 0.01, 0);
|
|
} else {
|
|
// expand shell by half tool diameter + stock to leave
|
|
shellRough = facePolys = POLY.expand(shellRough, (roughToolDiam / 2) + camRoughStock, 0);
|
|
}
|
|
}
|
|
|
|
if (procOutline) {
|
|
if (pocketOnlyOutline) {
|
|
// expand shell minimally triggering a clean
|
|
shellOutline = POLY.expand(shellOutline, -outlineToolDiam / 2, 0);
|
|
} else {
|
|
// expand shell by half tool diameter (not needed because only one offset)
|
|
// shellOutline = POLY.expand(shellOutline, outlineToolDiam / 2, 0);
|
|
}
|
|
}
|
|
|
|
// clear area from top of stock to top of part
|
|
if (procFacing) {
|
|
let ztop = bounds.max.z,
|
|
zpos = ztop + ztoff,
|
|
zstep = camRoughDown;
|
|
|
|
while (zpos >= ztop) {
|
|
zpos = zpos - Math.min(zstep, zpos - ztop);
|
|
|
|
const slice = newSlice(zpos, mesh.newGroup ? mesh.newGroup() : null);
|
|
slice.camMode = CPRO.LEVEL;
|
|
sliceAll.append(slice);
|
|
|
|
shellRough.clone().forEach(function(poly) {
|
|
slice.addTop(poly);
|
|
})
|
|
|
|
if (Math.abs(zpos - ztop) < 0.001) break;
|
|
}
|
|
}
|
|
|
|
if (procRough) {
|
|
let selected = [];
|
|
selectSlices(slices, camRoughDown * units, CPRO.ROUGH, selected);
|
|
if (zThru) {
|
|
addZThru(selected);
|
|
}
|
|
sliceAll.appendAll(selected);
|
|
if (!proc.camRoughVoid) {
|
|
thruHoles = holes(slices, roughToolDiam + camRoughStock);
|
|
}
|
|
}
|
|
|
|
if (procOutline) {
|
|
let selected = [];
|
|
selectSlices(slices, proc.camOutlineDown * units, CPRO.OUTLINE, selected);
|
|
if (zThru) {
|
|
addZThru(selected);
|
|
}
|
|
sliceAll.appendAll(selected);
|
|
}
|
|
}
|
|
|
|
// horizontal slices for rough/outline
|
|
doSlicing(widget, {height:sliceDepth, cam:true, zmin:zBottom, noEmpty:true}, camSlicesDone, function(update) {
|
|
onupdate(0.0 + update * 0.25, "slicing");
|
|
});
|
|
|
|
// we need topo for safe travel moves when roughing and outlining
|
|
// not generated when drilling-only. then all z moves use bounds max.
|
|
// also generates x and y contouring when selected
|
|
if (procRough || procOutline || procContour)
|
|
generateTopoMap(widget, settings, function(slices) {
|
|
sliceAll.appendAll(slices);
|
|
// todo union rough / outline shells
|
|
// todo union rough / outline tabs
|
|
// todo append to generated topo map
|
|
}, function(update, msg) {
|
|
onupdate(0.40 + update * 0.50, msg || "create topo");
|
|
});
|
|
|
|
// prepare for tracing paths
|
|
let traceTool;
|
|
let traceToolProfile;
|
|
if (procTrace) {
|
|
traceTool = getToolById(conf, proc.camTraceTool);
|
|
if (traceTool.type !== 'endmill') {
|
|
traceToolProfile = createToolProfile(conf, proc.camTraceTool, widget.topo);
|
|
}
|
|
}
|
|
|
|
// for each final slice, do post-processing
|
|
sliceAll.forEach(function(slice, index) {
|
|
// re-index
|
|
slice.index = index;
|
|
let modekey = MODES[slice.camMode] || "?mode?";
|
|
switch (slice.camMode) {
|
|
case CPRO.LEVEL:
|
|
createLevelPaths(slice, facePolys, roughToolDiam, proc.camRoughOver, pocketOnlyRough);
|
|
break;
|
|
case CPRO.ROUGH:
|
|
createRoughPaths(slice, shellRough, roughToolDiam, camRoughStock, proc.camRoughOver, pocketOnlyRough, thruHoles, wideCut);
|
|
if (addTabsRough) addCutoutTabs(slice, roughToolDiam);
|
|
break;
|
|
case CPRO.OUTLINE:
|
|
createOutlinePaths(slice, shellOutline, outlineToolDiam, pocketOnlyOutline, wideCut);
|
|
if (addTabsOutline) addCutoutTabs(slice, outlineToolDiam);
|
|
if (traceToolProfile) findTracingPaths(widget, slice, traceTool, traceToolProfile);
|
|
break;
|
|
}
|
|
onupdate(0.90 + (index / sliceAll.length) * 0.10, modekey);
|
|
}, "cam post");
|
|
|
|
ondone();
|
|
};
|
|
|
|
// drilling op
|
|
function sliceDrill(settings, widget, slices, output) {
|
|
let drills = [],
|
|
drillToolDiam = getToolDiameter(settings, settings.process.camDrillTool),
|
|
centerDiff = drillToolDiam * 0.1,
|
|
area = (drillToolDiam/2) * (drillToolDiam/2) * Math.PI,
|
|
areaDelta = area * 0.05;
|
|
|
|
// for each slice, look for polygons with 98.5% circularity whose
|
|
// area is within the tolerance of a circle matching the tool diameter
|
|
slices.forEach(function(slice) {
|
|
let inner = slice.gatherTopPolyInners([]);
|
|
inner.forEach(function(poly) {
|
|
if (poly.circularity() >= 0.985 && Math.abs(poly.area() - area) <= areaDelta) {
|
|
let center = poly.circleCenter(),
|
|
merged = false,
|
|
closest = Infinity,
|
|
dist;
|
|
// TODO reject if inside camShellPolys (means there is material above)
|
|
// if (center.isInPolygon(camShellPolys)) return;
|
|
drills.forEach(function(drill) {
|
|
if (merged) return;
|
|
if ((dist = drill.last().distTo2D(center)) <= centerDiff) {
|
|
merged = true;
|
|
drill.push(center);
|
|
}
|
|
closest = Math.min(closest,dist);
|
|
});
|
|
if (!merged) {
|
|
drills.push(newPolygon().append(center));
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
// drill points to use center (average of all points) of the polygon
|
|
drills.forEach(function(drill) {
|
|
let center = drill.center(true),
|
|
slice = newSlice(0,null);
|
|
drill.points.forEach(function(point) {
|
|
point.x = center.x;
|
|
point.y = center.y;
|
|
});
|
|
slice.camMode = CPRO.DRILL;
|
|
slice.addTop(null).traces = [ drill ];
|
|
output.append(slice);
|
|
});
|
|
}
|
|
|
|
// drill registration holes
|
|
function sliceDrillReg(settings, widget, output, zThru) {
|
|
let proc = settings.process,
|
|
stock = settings.stock,
|
|
bounds = settings.bounds,
|
|
mx = (bounds.max.x + bounds.min.x) / 2,
|
|
my = (bounds.max.y + bounds.min.y) / 2,
|
|
mz = zThru || 0,
|
|
dx = (stock.x - (bounds.max.x - bounds.min.x)) / 4,
|
|
dy = (stock.y - (bounds.max.y - bounds.min.y)) / 4,
|
|
dz = stock.z,
|
|
points = [];
|
|
|
|
switch(proc.camDrillReg) {
|
|
case "x axis":
|
|
points.push(newPoint(bounds.min.x - dx, my, 0));
|
|
points.push(newPoint(bounds.max.x + dx, my, 0));
|
|
break;
|
|
case "y axis":
|
|
points.push(newPoint(mx, bounds.min.y - dy, 0));
|
|
points.push(newPoint(mx, bounds.max.y + dy, 0));
|
|
break;
|
|
}
|
|
|
|
if (points.length) {
|
|
let slice = newSlice(0,null), polys = [];
|
|
points.forEach(point => {
|
|
polys.push(newPolygon()
|
|
.append(point.clone().setZ(bounds.max.z))
|
|
.append(point.clone().setZ(bounds.max.z - stock.z - mz)));
|
|
});
|
|
slice.camMode = CPRO.DRILL;
|
|
slice.addTop(null).traces = polys;
|
|
output.append(slice);
|
|
}
|
|
}
|
|
|
|
// runs in browser main
|
|
function sliceRender(widget) {
|
|
let slices = widget.slices;
|
|
if (!slices) return;
|
|
|
|
slices.forEach(function(slice) {
|
|
let tops = slice.tops,
|
|
layers = slice.layers,
|
|
outline = layers.outline,
|
|
open = (slice.camMode === CPRO.CONTOUR_X || slice.camMode === CPRO.CONTOUR_Y);
|
|
|
|
layers.outline.clear(); // slice raw edges
|
|
layers.trace.clear(); // roughing
|
|
layers.solid.clear(); // outline
|
|
layers.bridge.clear(); // outline x
|
|
layers.flat.clear(); // outline y
|
|
layers.fill.clear(); // facing
|
|
|
|
tops.forEach(function(top) {
|
|
outline.poly(top.poly, 0x999900, true, open);
|
|
if (top.inner) outline.poly(top.inner, 0xdddddd, true);
|
|
});
|
|
|
|
// various outlining
|
|
let layer;
|
|
slice.tops.forEach(function(top) {
|
|
switch (slice.camMode) {
|
|
case CPRO.OUTLINE:
|
|
layer = layers.solid;
|
|
break;
|
|
case CPRO.CONTOUR_X:
|
|
layer = layers.bridge;
|
|
break;
|
|
case CPRO.CONTOUR_Y:
|
|
layer = layers.flat;
|
|
break;
|
|
default: // roughing
|
|
layer = layers.trace;
|
|
break;
|
|
}
|
|
if (top.traces) {
|
|
layer.poly(top.traces, 0x010101, true, null);
|
|
}
|
|
});
|
|
|
|
// facing (previously separate. now part of roughing)
|
|
layer = slice.layers.fill;
|
|
slice.tops.forEach(function(top) {
|
|
if (top.fill_lines) {
|
|
layer.lines(top.fill_lines, fill_color);
|
|
}
|
|
});
|
|
|
|
outline.render();
|
|
layers.trace.render();
|
|
layers.solid.render();
|
|
layers.bridge.render();
|
|
layers.flat.render();
|
|
layers.fill.render();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* DRIVER PRINT CONTRACT
|
|
*
|
|
* @param {Object} print state object
|
|
* @param {Function} update incremental callback
|
|
* @param {Number} [index] into widget array
|
|
* @param {Object} [firstPoint] starting point
|
|
*/
|
|
function printSetup(print, update, index, firstPoint) {
|
|
let widgetIndex = index || 0,
|
|
widgetArray = print.widgets,
|
|
widgetCount = widgetArray.length,
|
|
widget = widgetArray[widgetIndex];
|
|
|
|
if (widgetIndex >= widgetCount || !widget) return;
|
|
|
|
let getTool = getToolById,
|
|
settings = print.settings,
|
|
device = settings.device,
|
|
process = settings.process,
|
|
stock = settings.stock,
|
|
outer = settings.bounds,
|
|
outerz = outer.max.z,
|
|
slices = widget.slices,
|
|
bounds = widget.getCamBounds(settings),
|
|
boundsz = bounds.max.z,
|
|
units = settings.controller.units === 'in' ? 25.4 : 1,
|
|
hasStock = process.camStockOffset || (process.camStockZ && process.camStockX && process.camStockY),
|
|
startCenter = process.outputOriginCenter,
|
|
alignTop = settings.controller.alignTop,
|
|
zclear = (process.camZClearance || 1) * units,
|
|
zmax_outer = hasStock ? stock.z + zclear : outerz + zclear,
|
|
ztoff = process.camZTopOffset * units,
|
|
zadd = hasStock ? stock.z - boundsz : alignTop ? outerz - boundsz : 0,
|
|
zmax = outerz + zclear,
|
|
wmpos = widget.mesh.position,
|
|
wmx = wmpos.x,
|
|
wmy = wmpos.y,
|
|
originx = startCenter ? 0 : hasStock ? -stock.x / 2 : bounds.min.x,
|
|
originy = startCenter ? 0 : hasStock ? -stock.y / 2 : bounds.min.y,
|
|
origin = newPoint(originx + wmx, originy + wmy, zmax),
|
|
output = print.output,
|
|
modes = CPRO,
|
|
easeDown = process.camEaseDown,
|
|
depthFirst = process.camDepthFirst,
|
|
tolerance = process.camTolerance * units,
|
|
drillDown = process.camDrillDown * units,
|
|
drillLift = process.camDrillLift * units,
|
|
drillDwell = process.camDrillDwell,
|
|
newOutput = widgetIndex === 0 ? [] : print.output,
|
|
layerOut = [],
|
|
printPoint,
|
|
isNewMode,
|
|
tool,
|
|
toolDiam,
|
|
toolDiamMove,
|
|
toolProfile,
|
|
feedRate,
|
|
plungeRate,
|
|
lastTool,
|
|
lastMode,
|
|
lastPoint,
|
|
nextIsMove = true,
|
|
spindle = 0,
|
|
spindleMax = device.spindleMax,
|
|
addOutput = print.addOutput,
|
|
tip2tipEmit = print.tip2tipEmit,
|
|
poly2polyEmit = print.poly2polyEmit,
|
|
poly2polyDepthFirstEmit = print.poly2polyDepthFirstEmit;
|
|
|
|
function newLayer() {
|
|
if (layerOut.length < 2) {
|
|
return;
|
|
}
|
|
newOutput.push(layerOut);
|
|
layerOut = [];
|
|
layerOut.spindle = spindle;
|
|
}
|
|
|
|
function setTool(toolID, feed, plunge) {
|
|
if (toolID !== lastTool) {
|
|
tool = getToolById(settings, toolID);
|
|
toolDiam = getToolDiameter(settings, toolID);
|
|
toolDiamMove = toolDiam; // TODO validate w/ multiple models
|
|
if (widget.topo) {
|
|
toolProfile = createToolProfile(settings, toolID, widget.topo);
|
|
}
|
|
lastTool = toolID;
|
|
}
|
|
feedRate = feed * units;
|
|
plungeRate = plunge * units;
|
|
}
|
|
|
|
function emitDrills(polys) {
|
|
polys = polys.slice();
|
|
for (;;) {
|
|
let closestDist = Infinity,
|
|
closestI,
|
|
closest = null,
|
|
dist;
|
|
|
|
for (let i=0; i<polys.length; i++) {
|
|
if (!polys[i]) continue;
|
|
if ((dist = polys[i].first().distTo2D(printPoint)) < closestDist) {
|
|
closestDist = dist;
|
|
closest = polys[i];
|
|
closestI = i;
|
|
}
|
|
}
|
|
|
|
if (!closest) return;
|
|
polys[closestI] = null;
|
|
printPoint = closest.first();
|
|
emitDrill(closest, drillDown, drillLift, drillDwell);
|
|
}
|
|
// TODO emit in next-closest-order
|
|
// polys.forEach(function(poly) {
|
|
// emitDrill(poly, drillDown, drillLift, drillDwell);
|
|
// });
|
|
}
|
|
|
|
function emitDrill(poly, down, lift, dwell) {
|
|
let remain = poly.first().z - poly.last().z,
|
|
points = [],
|
|
point = poly.first();
|
|
for (;;) {
|
|
if (remain > down * 2) {
|
|
points.push(point.clone());
|
|
point.z -= down;
|
|
remain -= down;
|
|
} else if (remain < down) {
|
|
points.push(point.clone());
|
|
point.z -= remain;
|
|
points.push(point.clone());
|
|
break;
|
|
} else {
|
|
points.push(point.clone());
|
|
point.z -= remain / 2;
|
|
points.push(point.clone());
|
|
point.z -= remain / 2;
|
|
points.push(point.clone());
|
|
break;
|
|
}
|
|
}
|
|
points.forEach(function(point, index) {
|
|
camOut(point, 1);
|
|
if (index > 0 && index < points.length - 1) {
|
|
if (dwell) camDwell(dwell);
|
|
if (lift) camOut(point.clone().setZ(point.z + lift), 0);
|
|
}
|
|
})
|
|
camOut(point.clone().setZ(zmax));
|
|
newLayer();
|
|
}
|
|
|
|
/**
|
|
* @param {Point} point
|
|
* @param {number} emit (0=move, !0=filament emit/laser on/cut mode)
|
|
* @param {number} [speed] speed
|
|
* @param {number} [tool] tool
|
|
*/
|
|
function layerPush(point, emit, speed, tool) {
|
|
layerOut.mode = lastMode;
|
|
addOutput(layerOut, point, emit, speed, tool);
|
|
}
|
|
|
|
function camDwell(time) {
|
|
layerPush(
|
|
null,
|
|
0,
|
|
time,
|
|
tool.number
|
|
);
|
|
}
|
|
|
|
function camOut(point, cut) {
|
|
point = point.clone();
|
|
point.x += wmx;
|
|
point.y += wmy;
|
|
point.z += zadd;
|
|
|
|
if (nextIsMove) {
|
|
cut = 0;
|
|
nextIsMove = false;
|
|
}
|
|
let rate = feedRate;
|
|
|
|
if (!lastPoint) {
|
|
let above = point.clone().setZ(zmax + zadd);
|
|
// before first point, move cutting head to point above it
|
|
layerPush(above, 0, 0, tool.number);
|
|
// then set that as the lastPoint
|
|
lastPoint = above;
|
|
}
|
|
|
|
let deltaXY = lastPoint.distTo2D(point),
|
|
deltaZ = point.z - lastPoint.z,
|
|
absDeltaZ = Math.abs(deltaZ),
|
|
isMove = !cut;
|
|
// drop points too close together
|
|
if (deltaXY < 0.001 && point.z === lastPoint.z) {
|
|
console.trace(["drop dup",lastPoint,point]);
|
|
return;
|
|
}
|
|
if (isMove && deltaXY <= toolDiamMove) {
|
|
// convert short planar moves to cuts
|
|
if (absDeltaZ <= tolerance) {
|
|
cut = 1;
|
|
isMove = false;
|
|
} else if (deltaZ <= -tolerance) {
|
|
// move over before descending
|
|
layerPush(point.clone().setZ(lastPoint.z), 0, 0, tool.number);
|
|
// new pos for plunge calc
|
|
deltaXY = 0;
|
|
}
|
|
} //else (TODO verify no else here b/c above could change isMove)
|
|
// move over things
|
|
if ((deltaXY > toolDiam || (deltaZ > toolDiam && deltaXY > tolerance)) && (isMove || absDeltaZ >= tolerance)) {
|
|
let maxz = (toolProfile ? Math.max(
|
|
getTopoZPathMax(
|
|
widget,
|
|
toolProfile,
|
|
lastPoint.x - wmx,
|
|
lastPoint.y - wmy,
|
|
point.x - wmx,
|
|
point.y - wmy),
|
|
point.z,
|
|
lastPoint.z) : zmax) + ztoff + zadd,
|
|
mustGoUp = Math.max(maxz - point.z, maxz - lastPoint.z) >= tolerance,
|
|
clearz = maxz;
|
|
// up if any point between higher than start/outline
|
|
if (mustGoUp) {
|
|
clearz = maxz + zclear;
|
|
layerPush(lastPoint.clone().setZ(clearz), 0, 0, tool.number);
|
|
}
|
|
// over to point above where we descend to
|
|
if (mustGoUp || point.z < maxz) {
|
|
layerPush(point.clone().setZ(clearz), 0, 0, tool.number);
|
|
// new pos for plunge calc
|
|
deltaXY = 0;
|
|
}
|
|
}
|
|
// synth new plunge rate
|
|
if (deltaZ <= -tolerance) {
|
|
let threshold = Math.min(deltaXY / 2, absDeltaZ),
|
|
modifier = threshold / absDeltaZ;
|
|
if (threshold && modifier && deltaXY > tolerance) {
|
|
// use modifier to speed up long XY move plunge rates
|
|
rate = Math.round(plungeRate + ((feedRate - plungeRate) * modifier));
|
|
} else {
|
|
rate = plungeRate;
|
|
}
|
|
// console.log({deltaZ: deltaZ, deltaXY: deltaXY, threshold:threshold, modifier:modifier, rate:rate, plungeRate:plungeRate});
|
|
}
|
|
|
|
// todo synthesize move speed from feed / plunge accordingly
|
|
layerPush(
|
|
point,
|
|
cut ? 1 : 0,
|
|
rate,
|
|
tool.number
|
|
);
|
|
lastPoint = point;
|
|
layerOut.spindle = spindle;
|
|
}
|
|
|
|
// coming from a previous widget, use previous last point
|
|
lastPoint = firstPoint;
|
|
|
|
// make top start offset configurable
|
|
printPoint = firstPoint || origin;
|
|
|
|
// accumulated data for depth-first optimiztions
|
|
let depthData = {
|
|
rough: [],
|
|
outline: [],
|
|
roughDiam: 0,
|
|
outlineDiam: 0,
|
|
contourx: [],
|
|
contoury: [],
|
|
layer: 0,
|
|
drill: []
|
|
};
|
|
|
|
// todo first move into positon
|
|
slices.forEach(function(slice, sliceIndex) {
|
|
depthData.layer++;
|
|
isNewMode = slice.camMode != lastMode;
|
|
lastMode = slice.camMode;
|
|
nextIsMove = true;
|
|
if (isNewMode) depthData.layer = 0;
|
|
|
|
switch (slice.camMode) {
|
|
case modes.LEVEL:
|
|
setTool(process.camRoughTool, process.camRoughSpeed, 0);
|
|
spindle = Math.min(spindleMax, process.camRoughSpindle);
|
|
slice.tops.forEach(function(top) {
|
|
if (!top.traces) return;
|
|
let polys = [];
|
|
top.traces.forEach(function (poly) {
|
|
polys.push(poly);
|
|
if (poly.inner) {
|
|
poly.inner.forEach(function(inner) {
|
|
polys.push(inner);
|
|
})
|
|
}
|
|
});
|
|
// set winding specified in output
|
|
POLY.setWinding(polys, process.camConventional, false);
|
|
printPoint = poly2polyEmit(polys, printPoint, function(poly, index, count) {
|
|
poly.forEachPoint(function(point, pidx, points, offset) {
|
|
camOut(point.clone(), offset !== 0);
|
|
}, true, index);
|
|
});
|
|
newLayer();
|
|
});
|
|
break;
|
|
case modes.ROUGH:
|
|
case modes.OUTLINE:
|
|
let dir = process.camConventional;
|
|
if (slice.camMode === modes.ROUGH) {
|
|
setTool(process.camRoughTool, process.camRoughSpeed, process.camRoughPlunge);
|
|
spindle = Math.min(spindleMax, process.camRoughSpindle);
|
|
depthData.roughDiam = toolDiam;
|
|
} else {
|
|
setTool(process.camOutlineTool, process.camOutlineSpeed, process.camOutlinePlunge);
|
|
spindle = Math.min(spindleMax, process.camOutlineSpindle);
|
|
depthData.outlineDiam = toolDiam;
|
|
if (!process.camOutlinePocket) {
|
|
dir = !dir;
|
|
}
|
|
}
|
|
// todo find closest next trace/trace-point
|
|
slice.tops.forEach(function(top) {
|
|
if (!top.poly) return;
|
|
if (!top.traces) return;
|
|
let polys = [], t = [], c = [];
|
|
POLY.flatten(top.traces, top.inner || []).forEach(function (poly) {
|
|
let child = poly.parent;
|
|
if (depthFirst) poly = poly.clone(true);
|
|
if (child) c.push(poly); else t.push(poly);
|
|
poly.layer = depthData.layer;
|
|
polys.push(poly);
|
|
});
|
|
// set cut direction on outer polys
|
|
POLY.setWinding(t, dir);
|
|
// set cut direction on inner polys
|
|
POLY.setWinding(c, !dir);
|
|
if (depthFirst) {
|
|
(slice.camMode === modes.ROUGH ? depthData.rough : depthData.outline).append(polys);
|
|
} else {
|
|
printPoint = poly2polyEmit(polys, printPoint, function(poly, index, count) {
|
|
poly.forEachPoint(function(point, pidx, points, offset) {
|
|
camOut(point.clone(), offset !== 0);
|
|
}, poly.isClosed(), index);
|
|
});
|
|
newLayer();
|
|
}
|
|
});
|
|
break;
|
|
case modes.CONTOUR_X:
|
|
case modes.CONTOUR_Y:
|
|
if (isNewMode || !printPoint) {
|
|
// force start at lower left corner
|
|
printPoint = newPoint(bounds.min.x,bounds.min.y,zmax);
|
|
}
|
|
setTool(process.camContourTool, process.camContourSpeed, process.camFastFeedZ);
|
|
spindle = Math.min(spindleMax, process.camContourSpindle);
|
|
depthData.outlineDiam = toolDiam;
|
|
// todo find closest next trace/trace-point
|
|
slice.tops.forEach(function(top) {
|
|
if (!top.traces) return;
|
|
let polys = [], poly, emit;
|
|
top.traces.forEach(function (poly) {
|
|
if (depthFirst) poly = poly.clone(true);
|
|
polys.push({first:poly.first(), last:poly.last(), poly:poly});
|
|
});
|
|
if (depthFirst) {
|
|
(slice.camMode === modes.CONTOUR_X ? depthData.contourx : depthData.contoury).appendAll(polys);
|
|
} else {
|
|
printPoint = tip2tipEmit(polys, printPoint, function(el, point, count) {
|
|
poly = el.poly;
|
|
if (poly.last() === point) poly.reverse();
|
|
poly.forEachPoint(function(point, pidx) {
|
|
camOut(point.clone(), pidx > 0);
|
|
}, false);
|
|
return lastPoint;
|
|
});
|
|
newLayer();
|
|
}
|
|
});
|
|
break;
|
|
case modes.DRILL:
|
|
setTool(process.camDrillTool, process.camDrillDownSpeed, process.camDrillDownSpeed);
|
|
// drilling is always depth-first
|
|
slice.tops.forEach(function(top) {
|
|
if (!top.traces) return;
|
|
depthData.drill.appendAll(top.traces);
|
|
});
|
|
break;
|
|
}
|
|
update(sliceIndex / slices.length);
|
|
});
|
|
|
|
// act on accumulated layer data
|
|
if (depthFirst) {
|
|
// roughing depth first
|
|
if (depthData.rough.length > 0) {
|
|
lastMode = CPRO.ROUGH;
|
|
setTool(process.camRoughTool, process.camRoughSpeed, process.camRoughPlunge);
|
|
spindle = Math.min(spindleMax, process.camRoughSpindle);
|
|
printPoint = poly2polyDepthFirstEmit(depthData.rough, printPoint, function(poly, index, count, fromPoint) {
|
|
let last = null;
|
|
if (easeDown && poly.isClosed()) {
|
|
last = poly.forEachPointEaseDown(function(point, offset) {
|
|
camOut(point.clone(), offset > 0);
|
|
}, fromPoint);
|
|
} else {
|
|
poly.forEachPoint(function(point, pidx, points, offset) {
|
|
camOut(point.clone(), offset !== 0);
|
|
}, poly.isClosed(), index);
|
|
}
|
|
newLayer();
|
|
return last;
|
|
}, depthData.roughDiam * process.camRoughOver * 1.01);
|
|
}
|
|
// outline depth first
|
|
if (depthData.outline.length > 0) {
|
|
lastMode = CPRO.OUTLINE;
|
|
setTool(process.camOutlineTool, process.camOutlineSpeed, process.camOutlinePlunge);
|
|
spindle = Math.min(spindleMax, process.camOutlineSpindle);
|
|
printPoint = poly2polyDepthFirstEmit(depthData.outline, printPoint, function(poly, index, count, fromPoint) {
|
|
let last = null;
|
|
if (easeDown && poly.isClosed()) {
|
|
last = poly.forEachPointEaseDown(function(point, offset) {
|
|
camOut(point.clone(), offset > 0);
|
|
}, fromPoint);
|
|
} else {
|
|
poly.forEachPoint(function(point, pidx, points, offset) {
|
|
camOut(point.clone(), offset !== 0);
|
|
last = point;
|
|
}, poly.isClosed(), index);
|
|
}
|
|
newLayer();
|
|
return last;
|
|
}, depthData.outlineDiam * 0.01);
|
|
}
|
|
// two modes for deferred outlining: x then y or combined
|
|
if (process.camContourCurves) {
|
|
lastMode = CPRO.CONTOUR_X;
|
|
setTool(process.camContourTool, process.camContourSpeed, process.camContourPlunge);
|
|
spindle = Math.min(spindleMax, process.camContourSpindle);
|
|
// combined deferred contour x and y outlining
|
|
let contourxy = [].appendAll(depthData.contourx).appendAll(depthData.contoury);
|
|
printPoint = tip2tipEmit(contourxy, printPoint, function(el, point, count) {
|
|
let poly = el.poly;
|
|
if (poly.last() === point) {
|
|
poly.reverse();
|
|
}
|
|
poly.forEachPoint(function(point, pidx) {
|
|
camOut(point.clone(), pidx > 0);
|
|
}, false);
|
|
newLayer();
|
|
return lastPoint;
|
|
});
|
|
} else {
|
|
setTool(process.camContourTool, process.camContourSpeed, process.camContourPlunge);
|
|
spindle = Math.min(spindleMax, process.camContourSpindle);
|
|
// deferred contour x outlining
|
|
if (depthData.contourx.length > 0) {
|
|
lastMode = CPRO.CONTOUR_X;
|
|
// force start at lower left corner
|
|
// printPoint = newPoint(bounds.min.x,bounds.min.y,zmax);
|
|
printPoint = tip2tipEmit(depthData.contourx, printPoint, function(el, point, count) {
|
|
let poly = el.poly;
|
|
if (poly.last() === point) poly.reverse();
|
|
poly.forEachPoint(function(point, pidx) {
|
|
camOut(point.clone(), pidx > 0);
|
|
}, false);
|
|
newLayer();
|
|
return lastPoint;
|
|
});
|
|
}
|
|
// deferred contour y outlining
|
|
if (depthData.contoury.length > 0) {
|
|
lastMode = CPRO.CONTOUR_Y;
|
|
// force start at lower left corner
|
|
printPoint = tip2tipEmit(depthData.contoury, printPoint, function(el, point, count) {
|
|
let poly = el.poly;
|
|
if (poly.last() === point) poly.reverse();
|
|
poly.forEachPoint(function(point, pidx) {
|
|
camOut(point.clone(), pidx > 0);
|
|
}, false);
|
|
newLayer();
|
|
return lastPoint;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// drilling is always depth first, and always output last (change?)
|
|
if (depthData.drill.length > 0) {
|
|
lastMode = CPRO.DRILL;
|
|
setTool(process.camDrillTool, process.camDrillDownSpeed, process.camDrillDownSpeed);
|
|
emitDrills(depthData.drill);
|
|
}
|
|
|
|
// last layer/move is to zmax
|
|
// injected into the last layer generated
|
|
if (lastPoint)
|
|
addOutput(newOutput[newOutput.length-1], printPoint = lastPoint.clone().setZ(zmax_outer), 0, 0, tool.number);
|
|
|
|
// replace output single flattened layer with all points
|
|
print.output = newOutput;
|
|
|
|
if (widgetIndex + 1 < widgetCount) {
|
|
printSetup(print, update, widgetIndex + 1, printPoint);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @returns {Array} gcode lines
|
|
*/
|
|
function printExport(print, online) {
|
|
let widget = print.widgets[0];
|
|
|
|
if (!widget) return;
|
|
|
|
let i,
|
|
time = 0,
|
|
lines = 0,
|
|
bytes = 0,
|
|
output = [],
|
|
spindle = 0,
|
|
modes = CPRO,
|
|
settings = print.settings,
|
|
device = settings.device,
|
|
gcodes = settings.device || {},
|
|
tools = settings.tools,
|
|
space = gcodes.gcodeSpace ? ' ' : '',
|
|
stripComments = gcodes.gcodeStrip || false,
|
|
cmdToolChange = gcodes.gcodeChange || [ "M6 T{tool}" ],
|
|
cmdSpindle = gcodes.gcodeSpindle || [ "M3 S{speed}" ],
|
|
cmdDwell = gcodes.gcodeDwell || [ "G4 P{time}" ],
|
|
bounds = widget.getCamBounds(settings),
|
|
dev = settings.device,
|
|
spro = settings.process,
|
|
units = settings.controller.units === 'in' ? 25.4 : 1,
|
|
maxZd = spro.camFastFeedZ * units,
|
|
maxXYd = spro.camFastFeed * units,
|
|
decimals = BASE.config.gcode_decimals || 4,
|
|
pos = { x:null, y:null, z:null, f:null, t:null },
|
|
line,
|
|
cidx,
|
|
mode = 0,
|
|
point,
|
|
points = 0,
|
|
hasStock = spro.camStockOffset || (spro.camStockZ && spro.camStockX && spro.camStockY),
|
|
zmax = hasStock ? settings.stock.z : bounds.max.z,
|
|
runbox = {
|
|
max: { x:-Infinity, y:-Infinity, z:-Infinity},
|
|
min: { x:Infinity, y:Infinity, z:Infinity}
|
|
},
|
|
offset = {
|
|
x: -settings.origin.x,
|
|
y: settings.origin.y
|
|
},
|
|
consts = {
|
|
tool: 0,
|
|
tool_name: "unknown",
|
|
top: (offset ? dev.bedDepth : dev.bedDepth/2),
|
|
left: (offset ? 0 : -dev.bedWidth/2),
|
|
right: (offset ? dev.bedWidth : dev.bedWidth/2),
|
|
bottom: (offset ? 0 : -dev.bedDepth/2),
|
|
time_sec: 0,
|
|
time_ms: 0,
|
|
time: 0
|
|
},
|
|
append;
|
|
|
|
if (online) {
|
|
append = function(line) {
|
|
if (line) {
|
|
lines++;
|
|
bytes += line.length;
|
|
output.append(line);
|
|
}
|
|
if (!line || output.length > 1000) {
|
|
online(output.join("\n"));
|
|
output = [];
|
|
}
|
|
};
|
|
} else {
|
|
append = function(line) {
|
|
if (!line) return;
|
|
output.append(line);
|
|
lines++;
|
|
bytes += line.length;
|
|
}
|
|
}
|
|
|
|
function filterEmit(array, consts) {
|
|
if (!array) return;
|
|
for (i=0; i<array.length; i++) {
|
|
line = print.constReplace(array[i], consts);
|
|
if (stripComments && (cidx = line.indexOf(";")) >= 0) {
|
|
line = line.substring(0, cidx).trim();
|
|
if (line.length === 0) continue;
|
|
}
|
|
append(line);
|
|
}
|
|
}
|
|
|
|
function add0(val) {
|
|
let s = val.toString(),
|
|
d = s.indexOf(".");
|
|
if (d < 0) {
|
|
return s + '.0';
|
|
} else {
|
|
return s;
|
|
}
|
|
}
|
|
|
|
function toolByNumber(number) {
|
|
for (let i=0; i<tools.length; i++) {
|
|
if (tools[i].number === number) return tools[i];
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
function toolNameByNumber(number) {
|
|
for (let i=0; i<tools.length; i++) {
|
|
if (tools[i].number === number) return tools[i].name;
|
|
}
|
|
return "unknown";
|
|
}
|
|
|
|
function moveTo(out) {
|
|
let newpos = out.point;
|
|
|
|
// no point == dwell
|
|
// out.speed = time to dwell in ms
|
|
if (!newpos) {
|
|
time += out.speed / 60;
|
|
consts.time_sec = out.speed / 1000;
|
|
consts.time_ms = out.speed;
|
|
consts.time = consts.time_sec;
|
|
filterEmit(cmdDwell, consts);
|
|
return;
|
|
}
|
|
|
|
newpos.x = UTIL.round(newpos.x, decimals);
|
|
newpos.y = UTIL.round(newpos.y, decimals);
|
|
newpos.z = UTIL.round(newpos.z, decimals);
|
|
|
|
// on tool change
|
|
if (out.tool != pos.t) {
|
|
pos.t = out.tool;
|
|
consts.tool = pos.t;
|
|
consts.tool_name = toolNameByNumber(out.tool);
|
|
filterEmit(cmdToolChange, consts);
|
|
}
|
|
|
|
// first point out sets the current position (but not Z)
|
|
// hacky AF way to split initial x,y,z into z then x,y
|
|
if (points === 0) {
|
|
pos.x = pos.y = pos.z = 0;
|
|
points++;
|
|
moveTo({
|
|
tool: out.tool,
|
|
point: { x: 0, y: 0, z: newpos.z }
|
|
});
|
|
moveTo({
|
|
tool: out.tool,
|
|
point: { x: newpos.x, y: newpos.y, z: newpos.z }
|
|
});
|
|
points--;
|
|
return;
|
|
}
|
|
|
|
let speed = out.speed,
|
|
nl = [speed ? 'G1' : 'G0'],
|
|
dx = newpos.x - pos.x,
|
|
dy = newpos.y - pos.y,
|
|
dz = newpos.z - pos.z,
|
|
maxf = dz ? maxZd : maxXYd,
|
|
feed = Math.min(speed || maxf, maxf),
|
|
dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
|
|
|
// drop dup points (all deltas are 0)
|
|
if (!(dx || dy || dz)) {
|
|
return;
|
|
}
|
|
|
|
if (newpos.x !== pos.x) {
|
|
pos.x = newpos.x;
|
|
runbox.min.x = Math.min(runbox.min.x, pos.x);
|
|
runbox.max.x = Math.max(runbox.max.x, pos.x);
|
|
nl.append(space).append("X").append(add0(pos.x));
|
|
}
|
|
if (newpos.y !== pos.y) {
|
|
pos.y = newpos.y;
|
|
runbox.min.y = Math.min(runbox.min.y, pos.y);
|
|
runbox.max.y = Math.max(runbox.max.y, pos.y);
|
|
nl.append(space).append("Y").append(add0(pos.y));
|
|
}
|
|
if (newpos.z !== pos.z) {
|
|
pos.z = newpos.z;
|
|
runbox.min.z = Math.min(runbox.min.z, pos.z);
|
|
runbox.max.z = Math.max(runbox.max.z, pos.z);
|
|
nl.append(space).append("Z").append(add0(pos.z));
|
|
}
|
|
if (feed && feed !== pos.f) {
|
|
pos.f = feed;
|
|
nl.append(space).append("F").append(feed);
|
|
}
|
|
|
|
// update time calculation
|
|
time += (dist / (pos.f || 1000)) * 60;
|
|
|
|
// if (comment && !stripComments) {
|
|
// nl.append(" ; ").append(comment);
|
|
// nl.append(" ; ").append(points);
|
|
// }
|
|
|
|
append(nl.join(''));
|
|
points++;
|
|
}
|
|
|
|
if (!stripComments) {
|
|
append(`; Generated by Kiri:Moto ${KIRI.version}`);
|
|
append(`; ${new Date().toString()}`);
|
|
filterEmit(["; Bed left:{left} right:{right} top:{top} bottom:{bottom}"], consts);
|
|
append(`; Target: ${settings.filter[settings.mode]}`);
|
|
append("; --- process ---");
|
|
for (let pk in spro) {
|
|
append("; " + pk + " = " + spro[pk]);
|
|
}
|
|
}
|
|
|
|
// collect tool info to add to header
|
|
let toolz = {}, ctool;
|
|
|
|
// remap points as necessary for origins, offsets, inversions
|
|
print.output.forEach(function(layer) {
|
|
layer.forEach(function(out) {
|
|
if (out.tool && out.tool !== ctool) {
|
|
ctool = toolByNumber(out.tool);
|
|
toolz[out.tool] = ctool;
|
|
}
|
|
point = out.point;
|
|
if (!point || point.mod) return;
|
|
// ensure not point is modified twice
|
|
point.mod = 1;
|
|
if (offset) {
|
|
point.x += offset.x;
|
|
point.y += offset.y;
|
|
}
|
|
if (spro.outputInvertX) point.x = -point.x;
|
|
if (spro.outputInvertY) point.y = -point.y;
|
|
if (spro.camOriginTop) point.z = point.z - zmax;
|
|
});
|
|
});
|
|
|
|
if (!stripComments) {
|
|
// emit tools used in comments
|
|
append("; --- tools ---");
|
|
Object.keys(toolz).sort().forEach(tn => {
|
|
let tool = toolz[tn];
|
|
append(`; tool=${tn} flute=${tool.flute_diam} len=${tool.flute_len} metric=${tool.metric}`);
|
|
});
|
|
}
|
|
|
|
// emit gcode preamble
|
|
filterEmit(gcodes.gcodePre, consts);
|
|
|
|
// emit all points in layer/point order
|
|
print.output.forEach(function (layerout) {
|
|
if (mode !== layerout.mode) {
|
|
if (mode && !stripComments) append("; ending " + MODES[mode] + " pass after " + Math.round(time/60) + " seconds");
|
|
mode = layerout.mode;
|
|
if (!stripComments) append("; starting " + MODES[mode] + " pass");
|
|
}
|
|
if (layerout.spindle && layerout.spindle !== spindle) {
|
|
spindle = layerout.spindle;
|
|
if (spindle > 0) {
|
|
filterEmit(cmdSpindle, {speed: Math.abs(spindle)});
|
|
} else {
|
|
append("M4");
|
|
}
|
|
// append((spindle > 0 ? "M3" : "M4") + " S" + Math.abs(spindle));
|
|
}
|
|
layerout.forEach(function(out) {
|
|
moveTo(out);
|
|
});
|
|
});
|
|
if (mode && !stripComments) append("; ending " + MODES[mode] + " pass after " + Math.round(time/60) + " seconds");
|
|
|
|
// emit gcode post
|
|
filterEmit(gcodes.gcodePost, consts);
|
|
|
|
// flush buffered gcode
|
|
append();
|
|
|
|
print.time = time;
|
|
print.lines = lines;
|
|
print.bytes = bytes + lines - 1;
|
|
print.bounds = runbox;
|
|
|
|
return online ? null : output.join("\n");
|
|
};
|
|
|
|
function printRender(print) {
|
|
return KIRI.driver.FDM.printRender(print, {aslines: true, color: 0x010101});
|
|
}
|
|
|
|
})();
|