283 lines
10 KiB
JavaScript
283 lines
10 KiB
JavaScript
import { arcToPath } from "../../../geo/paths.js";
|
|
import { newPolygon } from "../../../geo/polygon.js";
|
|
import { CamOp } from "./op.js";
|
|
import { Tool } from "./tool.js";
|
|
import { cylinder_poly_find } from "./slice.js";
|
|
import { newPoint } from "../../../geo/point.js";
|
|
import { newSlice } from "../../core/slice.js";
|
|
|
|
export class OpHelical extends CamOp {
|
|
constructor(state, op) {
|
|
super(state, op);
|
|
}
|
|
|
|
async slice(progress) {
|
|
let { op, state } = this;
|
|
let { settings, addSlices, widget, updateToolDiams } = state;
|
|
let {
|
|
cylinders,
|
|
forceStartAng,
|
|
startAng,
|
|
fromTop,
|
|
offOver,
|
|
offset,
|
|
down,
|
|
thru,
|
|
finish,
|
|
clockwise,
|
|
reverse,
|
|
entry,
|
|
entryOffset,
|
|
} = op;
|
|
let { color } = state;
|
|
let { stock } = settings
|
|
|
|
let tool = new Tool(settings, op.tool),
|
|
toolDiam = tool.fluteDiameter(),
|
|
sliceOut = (this.sliceOut = []),
|
|
startAngle = forceStartAng ? startAng : 0;
|
|
|
|
updateToolDiams(toolDiam);
|
|
// console.log({cylinders});
|
|
let faces = cylinders[widget.id] ?? [];
|
|
if (faces.faces) faces = faces.faces;
|
|
let polys = [];
|
|
|
|
//iterate over selected faces
|
|
for (let [i, face] of faces.entries()) {
|
|
//get poly info for the cylinder
|
|
let res
|
|
try {
|
|
res = cylinder_poly_find(
|
|
widget,
|
|
face
|
|
);
|
|
} catch (error) {
|
|
// don't quit if a cylinder errors out, just skip
|
|
console.error(error)
|
|
continue
|
|
}
|
|
let { zmin, zmax, diam, center, interior, faces } = res;
|
|
// console.log({ zmin, zmax, diam, center, interior });
|
|
let radius = diam / 2;
|
|
zmax = fromTop ? stock.z : zmax;
|
|
|
|
let radAdd,
|
|
zBottom = zmin - thru,
|
|
numSegs = faces.length / 2,
|
|
poly = newPolygon().setOpen();
|
|
|
|
if (offOver) {
|
|
//apply offset override
|
|
if (offset == "auto") {
|
|
radAdd = interior ? -offOver : offOver;
|
|
} else if (offset == "inside") {
|
|
radAdd = -offOver;
|
|
} else if (offset == "outside") {
|
|
radAdd = offOver;
|
|
}
|
|
} else {
|
|
//otherwise, calculate based on offset type
|
|
if (offset == "auto") {
|
|
radAdd = (interior ? -toolDiam : toolDiam) / 2;
|
|
} else if (offset == "inside") {
|
|
radAdd = -toolDiam / 2;
|
|
} else if (offset == "outside") {
|
|
radAdd = toolDiam / 2;
|
|
}
|
|
}
|
|
radius += radAdd;
|
|
|
|
if (radius <= 0) {
|
|
//if negative radius, skip this cylinder
|
|
console.log('negative radius', radius);
|
|
continue
|
|
}
|
|
|
|
let startPoint = center
|
|
.clone()
|
|
.setZ(zmax)
|
|
.add(
|
|
newPoint(
|
|
Math.cos(startAngle) * radius,
|
|
Math.sin(startAngle) * radius,
|
|
0
|
|
)
|
|
);
|
|
|
|
let currentZ = zmax;
|
|
for (; ;) {
|
|
let bottom = currentZ - down;
|
|
if (bottom > zBottom) {
|
|
//if not at the bottom, do a whole helix
|
|
let start = startPoint.setZ(currentZ),
|
|
end = startPoint.clone().setZ(bottom);
|
|
// console.log(currentZ, bottom, [start.z, end.z]);
|
|
let path = arcToPath(start, end, numSegs, {
|
|
clockwise,
|
|
radius,
|
|
center,
|
|
});
|
|
// console.log({ path, start, end, radius, center });
|
|
poly.addPoints(path);
|
|
} else {
|
|
//if at the bottom, do a partial helix
|
|
let toBottom = currentZ - zBottom,
|
|
ofFull = toBottom / down,
|
|
ofCircle = ofFull * (2 * Math.PI),
|
|
cwMultiplier = clockwise ? -1 : 1,
|
|
finalAngle = startAngle + (ofCircle * cwMultiplier),
|
|
finalEnd = center
|
|
.clone()
|
|
.setZ(zBottom)
|
|
.add(
|
|
newPoint(
|
|
Math.cos(finalAngle) * radius,
|
|
Math.sin(finalAngle) * radius,
|
|
0
|
|
)
|
|
);
|
|
|
|
// console.log({down,toBottom,ofFull,ofCircle,startAngle,finalAngle,finalEnd});
|
|
//if not already very close to final point
|
|
if (ofCircle >= 0.001) {
|
|
//circle down to final point
|
|
poly.addPoints(
|
|
arcToPath(startPoint.setZ(currentZ), finalEnd, numSegs, {
|
|
clockwise,
|
|
radius,
|
|
center,
|
|
})
|
|
);
|
|
}
|
|
|
|
//if starting at the bottom, reverse poly
|
|
if (reverse) {
|
|
poly.reverse();
|
|
}
|
|
|
|
if (entry) {
|
|
//get first z of poly to use for entry
|
|
let firstZ = poly.first().z;
|
|
//create new pointArray
|
|
let entry = [newPoint(0, 0, 0)];
|
|
//add center point
|
|
let entryCenter = center.clone().setZ(firstZ)
|
|
|
|
//if doing a curved enter, add more
|
|
if (entryOffset > 0) {
|
|
if (entryOffset > radius) {
|
|
console.error("entryOffset must be less than radius of helix");
|
|
} else {
|
|
//calculate entry center
|
|
let lineOut = radius - entryOffset;
|
|
let centerOffset = (entryOffset ** 2 + 2 * entryOffset * lineOut) / (2 * (entryOffset + lineOut));
|
|
//add entry points
|
|
entry.push(
|
|
newPoint(0, -lineOut, 0),
|
|
...arcToPath(
|
|
newPoint(0, -lineOut, 0),
|
|
newPoint(radius, 0, 0),
|
|
128,
|
|
{
|
|
clockwise: false,
|
|
radius: lineOut,
|
|
center: newPoint(centerOffset, 0, 0)
|
|
}
|
|
),
|
|
newPoint(radius, 0, 0),
|
|
)
|
|
}
|
|
}
|
|
//for each point
|
|
//rotate by start angle
|
|
// add to hole center
|
|
let invert = ((clockwise && !reverse) || (!clockwise && reverse)) ? -1 : 1
|
|
let entryAngle = reverse ? finalAngle : startAngle
|
|
entry = entry.map(p => {
|
|
// TODO: there's totally a way to do this with a matrix
|
|
// logical XOR
|
|
p.y *= invert
|
|
p.rotate(entryAngle)
|
|
return p.add(entryCenter)
|
|
})
|
|
//append to start of poly
|
|
poly = newPolygon().setOpen().addPoints(entry).addPoints(poly.points);
|
|
}
|
|
//if doing a finish pass, do a full circle at the bottom
|
|
if (finish && !reverse) {
|
|
poly.addPoints(
|
|
arcToPath(finalEnd, finalEnd, numSegs, {
|
|
clockwise,
|
|
radius,
|
|
center,
|
|
}),
|
|
);
|
|
poly.append(
|
|
finalEnd.clone().setZ(zBottom),
|
|
)
|
|
}
|
|
break;
|
|
}
|
|
currentZ = bottom;
|
|
}
|
|
|
|
progress(i / faces.length, "Helical intrerpolation");
|
|
polys.push(poly);
|
|
}
|
|
|
|
let slice = newSlice(0);
|
|
slice.camTrace = { tool: op.tool, rate: op.feed, plunge: op.rate };
|
|
slice.camLines = polys;
|
|
|
|
slice
|
|
.output()
|
|
.setLayer("Helical", { face: color, line: color })
|
|
.addPolys(slice.camLines);
|
|
|
|
addSlices(slice);
|
|
sliceOut.push(slice);
|
|
}
|
|
|
|
async prepare(ops, progress) {
|
|
let {
|
|
setTool,
|
|
setSpindle,
|
|
polyEmit,
|
|
setPrintPoint,
|
|
getPrintPoint,
|
|
} = ops;
|
|
let { tool, spindle, rate, feed } = this.op;
|
|
|
|
setTool(tool, feed, rate);
|
|
setSpindle(spindle);
|
|
|
|
let [polys] = this.sliceOut.map((s) => s.camLines);
|
|
let pp = getPrintPoint();
|
|
polys = polys.slice();
|
|
|
|
for (;;) {
|
|
let closestDist = Infinity,
|
|
closestI,
|
|
closest = null,
|
|
dist,
|
|
poly;
|
|
|
|
for (let i = 0; i < polys.length; i++) {
|
|
if (!polys[i]) continue;
|
|
if ((dist = polys[i].first().distTo2D(pp)) < closestDist) {
|
|
closestDist = dist;
|
|
closest = polys[i];
|
|
closestI = i;
|
|
}
|
|
}
|
|
|
|
if (!closest) break;
|
|
poly = polys[closestI]
|
|
polys[closestI] = null;
|
|
pp = polyEmit(poly, 0, 1, poly.points[0])
|
|
}
|
|
|
|
setPrintPoint(pp);
|
|
}
|
|
}
|