kopia lustrzana https://github.com/OpenBuilds/OpenBuilds-CONTROL
993 wiersze
36 KiB
JavaScript
993 wiersze
36 KiB
JavaScript
self.addEventListener('message', function(e) {
|
|
// console.log("New message received by worker", e.data.data.length)
|
|
importScripts("/lib/threejs/three.min.js");
|
|
var data = e.data;
|
|
var result = createObjectFromGCode(e.data.data)
|
|
result = result;
|
|
// console.log(result)
|
|
self.postMessage(JSON.stringify(result));
|
|
}, false);
|
|
|
|
// This is a simplified and updated version of http://gcode.joewalnes.com/
|
|
// Updated with code from http://chilipeppr.com/tinyg's 3D viewer to support more CNC type Gcode
|
|
// Simplified by Andrew Hodel in 2015
|
|
// Updated by PvdW in 2016 for S-Value lasers
|
|
// Updates by PvdW in 2017 - new arc code from http://chilipeppr.com
|
|
// Updates by PvdW in 2017 - AUTODETECT MAX S VALUE
|
|
// Updated by PvdW in 2017 - Parse GCODE to find starting temperatures (preheat machine)
|
|
// Updated by PvdW in 2018 - Webworker Version
|
|
// Updated by PvdW in 2019 - Improve Performance
|
|
|
|
var lastLine = {
|
|
x: 0,
|
|
y: 0,
|
|
z: 0,
|
|
e: 0,
|
|
f: 0,
|
|
t: false,
|
|
feedrate: null,
|
|
extruding: false,
|
|
tool: false
|
|
};
|
|
|
|
GCodeParser = function(handlers, modecmdhandlers) {
|
|
this.handlers = handlers || {};
|
|
this.modecmdhandlers = modecmdhandlers || {};
|
|
|
|
this.lastArgs = {
|
|
cmd: null
|
|
};
|
|
this.lastFeedrate = null;
|
|
this.isUnitsMm = true;
|
|
|
|
this.parseLine = function(text, info) {
|
|
// console.log("LINE: " + text)
|
|
var origtext = text;
|
|
// remove line numbers if exist
|
|
if (text.match(/^N/i)) {
|
|
// yes, there's a line num
|
|
text = text.replace(/^N\d+\s*/ig, "");
|
|
}
|
|
|
|
// collapse leading zero g cmds to no leading zero
|
|
text = text.replace(/G00/i, 'G0');
|
|
text = text.replace(/G0(\d)/i, 'G$1');
|
|
// add spaces before g cmds and xyzabcijkf params
|
|
text = text.replace(/([gmtxyzabcijkfst])/ig, " $1");
|
|
// remove spaces after xyzabcijkf params because a number should be directly after them
|
|
text = text.replace(/([xyzabcijkfst])\s+/ig, "$1");
|
|
// remove front and trailing space
|
|
text = text.trim();
|
|
|
|
// see if comment
|
|
var isComment = false;
|
|
if (text.match(/^(;|\(|<)/)) {
|
|
text = origtext;
|
|
isComment = true;
|
|
} else {
|
|
// make sure to remove inline comments
|
|
text = text.replace(/\(.*?\)/g, "");
|
|
}
|
|
//console.log("gcode txt:", text);
|
|
|
|
if (text && !isComment) {
|
|
text = text.replace(/(;|\().*$/, ""); // ; or () trailing // strip off end of line comment
|
|
var tokens = [];
|
|
// Execute any non-motion commands on the line immediately
|
|
// Add other commands to the tokens list for later handling
|
|
// Segments are not created for non-motion commands;
|
|
// the segment for this line is created later
|
|
text.split(/\s+/).forEach(function(token) {
|
|
var modehandler = modecmdhandlers[token.toUpperCase()];
|
|
if (modehandler) {
|
|
modehandler();
|
|
} else {
|
|
tokens.push(token);
|
|
}
|
|
});
|
|
|
|
if (tokens.length) {
|
|
var cmd = tokens[0];
|
|
cmd = cmd.toUpperCase();
|
|
// check if a g or m cmd was included in gcode line
|
|
// you are allowed to just specify coords on a line
|
|
// and it should be assumed that the last specified gcode
|
|
// cmd is what's assumed
|
|
isComment = false;
|
|
if (!cmd.match(/^(G|M|T|S)/i)) {
|
|
cmd = this.lastArgs.cmd;
|
|
tokens.unshift(cmd); // put at spot 0 in array
|
|
} else {
|
|
// we have a normal cmd as opposed to just an xyz pos where
|
|
// it assumes you should use the last cmd
|
|
// however, need to remove inline comments (TODO. it seems parser works fine for now)
|
|
}
|
|
var args = {
|
|
'cmd': cmd,
|
|
'text': text,
|
|
'origtext': origtext,
|
|
'indx': info,
|
|
'isComment': isComment,
|
|
'feedrate': null
|
|
};
|
|
// console.log("args:", args);
|
|
if (tokens.length > 1 && !isComment) {
|
|
tokens.splice(1).forEach(function(token) {
|
|
//console.log("token:", token);
|
|
if (token && token.length > 0) {
|
|
var key = token[0].toLowerCase();
|
|
var value = parseFloat(token.substring(1));
|
|
args[key] = value;
|
|
} else {
|
|
//console.log("couldn't parse token in foreach. weird:", token);
|
|
}
|
|
});
|
|
}
|
|
var handler = this.handlers[cmd] || this.handlers['default'];
|
|
// don't save if saw a comment
|
|
if (!args.isComment) {
|
|
this.lastArgs = args;
|
|
//console.log("just saved lastArgs for next use:", this.lastArgs);
|
|
} else {
|
|
//console.log("this was a comment, so didn't save lastArgs");
|
|
}
|
|
//console.log("calling handler: cmd:", cmd, "args:", args, "info:", info);
|
|
if (handler) {
|
|
// scan for feedrate
|
|
if (args.text.match(/F([\d.]+)/i)) {
|
|
// we have a new feedrate
|
|
var feedrate = parseFloat(RegExp.$1);
|
|
args.feedrate = feedrate;
|
|
this.lastFeedrate = feedrate;
|
|
} else {
|
|
// use feedrate from prior lines
|
|
args.feedrate = this.lastFeedrate;
|
|
}
|
|
|
|
if (args.text.match(/S([\d.]+)/i)) {
|
|
// we have a new S-Value
|
|
var svalue = parseFloat(RegExp.$1);
|
|
args.svalue = svalue;
|
|
this.lastsvalue = svalue;
|
|
} else {
|
|
// use feedrate from prior lines
|
|
args.svalue = this.lastsvalue;
|
|
}
|
|
|
|
if (args.text.match(/T([\d.]+)/i)) {
|
|
console.log("New Tool: ", args.text)
|
|
// we have a new S-Value
|
|
var tool = parseFloat(RegExp.$1);
|
|
args.tool = tool;
|
|
this.lasttool = tool;
|
|
} else {
|
|
// use tool from prior lines
|
|
args.tool = this.lasttool;
|
|
}
|
|
//console.log("about to call handler. args:", args, "info:", info, "this:", this);
|
|
return handler(args, info, this);
|
|
} else {
|
|
console.error("No handler for gcode command!!!");
|
|
}
|
|
|
|
}
|
|
} else {
|
|
// it was a comment or the line was empty
|
|
// we still need to create a segment with xyz in p2
|
|
// so that when we're being asked to /gotoline we have a position
|
|
// for each gcode line, even comments. we just use the last real position
|
|
// to give each gcode line (even a blank line) a spot to go to
|
|
var args = {
|
|
'cmd': 'empty or comment',
|
|
'text': text,
|
|
'origtext': origtext,
|
|
'indx': info,
|
|
'isComment': isComment
|
|
};
|
|
var handler = this.handlers['default'];
|
|
return handler(args, info, this);
|
|
}
|
|
}
|
|
|
|
this.parse = function(gcode) {
|
|
// console.log(gcode)
|
|
|
|
|
|
|
|
var lines = gcode.split(/\r{0,1}\n/);
|
|
// var lines = gcode
|
|
|
|
for (var i = 0; i < lines.length; i++) {
|
|
if (this.parseLine(lines[i], i) === false) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
},
|
|
colorG0 = 0x00cc00, //bootstrap color
|
|
colorG1 = 0xcc0000,
|
|
colorG2 = 0x0000cc,
|
|
createObjectFromGCode = function(gcode) {
|
|
// console.log(gcode)
|
|
|
|
// Reset Starting Point
|
|
lastLine = {
|
|
x: 0,
|
|
y: 0,
|
|
z: 0,
|
|
e: 0,
|
|
f: 0,
|
|
s: 0,
|
|
t: false,
|
|
feedrate: null,
|
|
extruding: false
|
|
};
|
|
|
|
|
|
setUnits = function(units) {
|
|
if (units == "mm")
|
|
this.isUnitsMm = true;
|
|
else
|
|
this.isUnitsMm = false;
|
|
this.onUnitsChanged();
|
|
}
|
|
|
|
onUnitsChanged = function() {
|
|
//console.log("onUnitsChanged");
|
|
// we need to publish back the units
|
|
var units = "mm";
|
|
if (!this.isUnitsMm) units = "inch";
|
|
// $('.com-chilipeppr-widget-3dviewer-units-indicator').text(units);
|
|
// console.log("USING UNITS:" + units)
|
|
|
|
}
|
|
// these are extra Object3D elements added during
|
|
// the gcode rendering to attach to scene
|
|
this.extraObjects = [];
|
|
this.extraObjects["G17"] = [];
|
|
this.extraObjects["G18"] = [];
|
|
this.extraObjects["G19"] = [];
|
|
this.offsetG92 = {
|
|
x: 0,
|
|
y: 0,
|
|
z: 0,
|
|
e: 0
|
|
};
|
|
this.setUnits("mm");
|
|
|
|
|
|
// we have been using an approach where we just append
|
|
// each gcode move to one monolithic geometry. we
|
|
// are moving away from that idea and instead making each
|
|
// gcode move be it's own full-fledged line object with
|
|
// its own userData info
|
|
// G2/G3 moves are their own child of lots of lines so
|
|
// that even the simulator can follow along better
|
|
var layers = [];
|
|
var layer = undefined;
|
|
var lines = [];
|
|
var totalDist = 0;
|
|
|
|
|
|
this.newLayer = function(line) {
|
|
//console.log("layers:", layers, "layers.length", layers.length);
|
|
layer = {
|
|
type: {},
|
|
layer: layers.length,
|
|
z: line.z,
|
|
};
|
|
layers.push(layer);
|
|
};
|
|
|
|
this.drawArc = function(aX, aY, aZ, endaZ, aRadius, aStartAngle, aEndAngle, aClockwise, plane) {
|
|
//console.log("drawArc:", aX, aY, aZ, aRadius, aStartAngle, aEndAngle, aClockwise);
|
|
var ac = new THREE.ArcCurve(aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise);
|
|
//console.log("ac:", ac);
|
|
var acmat = new THREE.LineBasicMaterial({
|
|
color: colorG2,
|
|
opacity: 0.5,
|
|
transparent: true
|
|
});
|
|
var acgeo = new THREE.Geometry();
|
|
var ctr = 0;
|
|
var z = aZ;
|
|
var points = []
|
|
ac.getPoints(20).forEach(function(v) {
|
|
//console.log(v);
|
|
z = (((endaZ - aZ) / 20) * ctr) + aZ;
|
|
acgeo.vertices.push(new THREE.Vector3(v.x, v.y, z));
|
|
ctr++;
|
|
points.push({
|
|
'x': v.x,
|
|
'y': v.y,
|
|
'z': z,
|
|
})
|
|
});
|
|
var aco = new THREE.Line(acgeo, acmat);
|
|
aco.userData.points = points;
|
|
|
|
//aco.position.set(pArc.x, pArc.y, pArc.z);
|
|
//console.log("aco:", aco);
|
|
this.extraObjects[plane].push(aco);
|
|
return aco;
|
|
};
|
|
|
|
this.drawArcFrom2PtsAndCenter = function(vp1, vp2, vpArc, args) {
|
|
//console.log("drawArcFrom2PtsAndCenter. vp1:", vp1, "vp2:", vp2, "vpArc:", vpArc, "args:", args);
|
|
|
|
//var radius = vp1.distanceTo(vpArc);
|
|
//console.log("radius:", radius);
|
|
|
|
// Find angle
|
|
var p1deltaX = vpArc.x - vp1.x;
|
|
var p1deltaY = vpArc.y - vp1.y;
|
|
var p1deltaZ = vpArc.z - vp1.z;
|
|
|
|
var p2deltaX = vpArc.x - vp2.x;
|
|
var p2deltaY = vpArc.y - vp2.y;
|
|
var p2deltaZ = vpArc.z - vp2.z;
|
|
|
|
switch (args.plane) {
|
|
case "G18":
|
|
var anglepArcp1 = Math.atan(p1deltaZ / p1deltaX);
|
|
var anglepArcp2 = Math.atan(p2deltaZ / p2deltaX);
|
|
break;
|
|
case "G19":
|
|
var anglepArcp1 = Math.atan(p1deltaZ / p1deltaY);
|
|
var anglepArcp2 = Math.atan(p2deltaZ / p2deltaY);
|
|
break;
|
|
default:
|
|
var anglepArcp1 = Math.atan(p1deltaY / p1deltaX);
|
|
var anglepArcp2 = Math.atan(p2deltaY / p2deltaX);
|
|
}
|
|
|
|
// Draw arc from arc center
|
|
var radius = vpArc.distanceTo(vp1);
|
|
var radius2 = vpArc.distanceTo(vp2);
|
|
//console.log("radius:", radius);
|
|
|
|
if (Number((radius).toFixed(2)) != Number((radius2).toFixed(2))) console.log("Radiuses not equal. r1:", radius, ", r2:", radius2, " with args:", args, " rounded vals r1:", Number((radius).toFixed(2)), ", r2:", Number((radius2).toFixed(2)));
|
|
|
|
// arccurve
|
|
var clwise = true;
|
|
if (args.clockwise === false) clwise = false;
|
|
//if (anglepArcp1 < 0) clockwise = false;
|
|
|
|
switch (args.plane) {
|
|
case "G19":
|
|
if (p1deltaY >= 0) anglepArcp1 += Math.PI;
|
|
if (p2deltaY >= 0) anglepArcp2 += Math.PI;
|
|
break;
|
|
default:
|
|
if (p1deltaX >= 0) anglepArcp1 += Math.PI;
|
|
if (p2deltaX >= 0) anglepArcp2 += Math.PI;
|
|
}
|
|
|
|
if (anglepArcp1 === anglepArcp2 && clwise === false)
|
|
// Draw full circle if angles are both zero,
|
|
// start & end points are same point... I think
|
|
switch (args.plane) {
|
|
case "G18":
|
|
var threeObj = this.drawArc(vpArc.x, vpArc.z, (-1 * vp1.y), (-1 * vp2.y), radius, anglepArcp1, (anglepArcp2 + (2 * Math.PI)), clwise, "G18");
|
|
break;
|
|
case "G19":
|
|
var threeObj = this.drawArc(vpArc.y, vpArc.z, vp1.x, vp2.x, radius, anglepArcp1, (anglepArcp2 + (2 * Math.PI)), clwise, "G19");
|
|
break;
|
|
default:
|
|
var threeObj = this.drawArc(vpArc.x, vpArc.y, vp1.z, vp2.z, radius, anglepArcp1, (anglepArcp2 + (2 * Math.PI)), clwise, "G17");
|
|
}
|
|
else
|
|
switch (args.plane) {
|
|
case "G18":
|
|
var threeObj = this.drawArc(vpArc.x, vpArc.z, (-1 * vp1.y), (-1 * vp2.y), radius, anglepArcp1, anglepArcp2, clwise, "G18");
|
|
break;
|
|
case "G19":
|
|
var threeObj = this.drawArc(vpArc.y, vpArc.z, vp1.x, vp2.x, radius, anglepArcp1, anglepArcp2, clwise, "G19");
|
|
break;
|
|
default:
|
|
var threeObj = this.drawArc(vpArc.x, vpArc.y, vp1.z, vp2.z, radius, anglepArcp1, anglepArcp2, clwise, "G17");
|
|
}
|
|
return threeObj;
|
|
};
|
|
|
|
this.addSegment = function(p1, p2, args) {
|
|
|
|
if (p2.arc) {
|
|
//console.log("");
|
|
//console.log("drawing arc. p1:", p1, ", p2:", p2);
|
|
|
|
//var segmentCount = 12;
|
|
// figure out the 3 pts we are dealing with
|
|
// the start, the end, and the center of the arc circle
|
|
// radius is dist from p1 x/y/z to pArc x/y/z
|
|
//if(args.clockwise === false || args.cmd === "G3"){
|
|
// var vp2 = new THREE.Vector3(p1.x, p1.y, p1.z);
|
|
// var vp1 = new THREE.Vector3(p2.x, p2.y, p2.z);
|
|
//}
|
|
//else {
|
|
var vp1 = new THREE.Vector3(p1.x, p1.y, p1.z);
|
|
var vp2 = new THREE.Vector3(p2.x, p2.y, p2.z);
|
|
//}
|
|
var vpArc;
|
|
|
|
// if this is an R arc gcode command, we're given the radius, so we
|
|
// don't have to calculate it. however we need to determine center
|
|
// of arc
|
|
if (args.r != null) {
|
|
//console.log("looks like we have an arc with R specified. args:", args);
|
|
//console.log("anglepArcp1:", anglepArcp1, "anglepArcp2:", anglepArcp2);
|
|
|
|
radius = parseFloat(args.r);
|
|
|
|
// First, find the distance between points 1 and 2. We'll call that q,
|
|
// and it's given by sqrt((x2-x1)^2 + (y2-y1)^2).
|
|
var q = Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2) + Math.pow(p2.z - p1.z, 2));
|
|
|
|
// Second, find the point halfway between your two points. We'll call it
|
|
// (x3, y3). x3 = (x1+x2)/2 and y3 = (y1+y2)/2.
|
|
var x3 = (p1.x + p2.x) / 2;
|
|
var y3 = (p1.y + p2.y) / 2;
|
|
var z3 = (p1.z + p2.z) / 2;
|
|
|
|
// There will be two circle centers as a result of this, so
|
|
// we will have to pick the correct one. In gcode we can get
|
|
// a + or - val on the R to indicate which circle to pick
|
|
// One answer will be:
|
|
// x = x3 + sqrt(r^2-(q/2)^2)*(y1-y2)/q
|
|
// y = y3 + sqrt(r^2-(q/2)^2)*(x2-x1)/q
|
|
// The other will be:
|
|
// x = x3 - sqrt(r^2-(q/2)^2)*(y1-y2)/q
|
|
// y = y3 - sqrt(r^2-(q/2)^2)*(x2-x1)/q
|
|
var pArc_1 = undefined;
|
|
var pArc_2 = undefined;
|
|
var calc = Math.sqrt((radius * radius) - Math.pow(q / 2, 2));
|
|
|
|
// calc can be NaN if q/2 is epsilon larger than radius due to finite precision
|
|
// When that happens, the calculated center is incorrect
|
|
if (isNaN(calc)) {
|
|
calc = 0.0;
|
|
}
|
|
var angle_point = undefined;
|
|
|
|
switch (args.plane) {
|
|
case "G18":
|
|
pArc_1 = {
|
|
x: x3 + calc * (p1.z - p2.z) / q,
|
|
y: y3 + calc * (p2.y - p1.y) / q,
|
|
z: z3 + calc * (p2.x - p1.x) / q
|
|
};
|
|
pArc_2 = {
|
|
x: x3 - calc * (p1.z - p2.z) / q,
|
|
y: y3 - calc * (p2.y - p1.y) / q,
|
|
z: z3 - calc * (p2.x - p1.x) / q
|
|
};
|
|
angle_point = Math.atan2(p1.z, p1.x) - Math.atan2(p2.z, p2.x);
|
|
if (((p1.x - pArc_1.x) * (p1.z + pArc_1.z)) + ((pArc_1.x - p2.x) * (pArc_1.z + p2.z)) >=
|
|
((p1.x - pArc_2.x) * (p1.z + pArc_2.z)) + ((pArc_2.x - p2.x) * (pArc_2.z + p2.z))) {
|
|
var cw = pArc_1;
|
|
var ccw = pArc_2;
|
|
} else {
|
|
var cw = pArc_2;
|
|
var ccw = pArc_1;
|
|
}
|
|
break;
|
|
case "G19":
|
|
pArc_1 = {
|
|
x: x3 + calc * (p1.x - p2.x) / q,
|
|
y: y3 + calc * (p1.z - p2.z) / q,
|
|
z: z3 + calc * (p2.y - p1.y) / q
|
|
};
|
|
pArc_2 = {
|
|
x: x3 - calc * (p1.x - p2.x) / q,
|
|
y: y3 - calc * (p1.z - p2.z) / q,
|
|
z: z3 - calc * (p2.y - p1.y) / q
|
|
};
|
|
|
|
if (((p1.y - pArc_1.y) * (p1.z + pArc_1.z)) + ((pArc_1.y - p2.y) * (pArc_1.z + p2.z)) >=
|
|
((p1.y - pArc_2.y) * (p1.z + pArc_2.z)) + ((pArc_2.y - p2.y) * (pArc_2.z + p2.z))) {
|
|
var cw = pArc_1;
|
|
var ccw = pArc_2;
|
|
} else {
|
|
var cw = pArc_2;
|
|
var ccw = pArc_1;
|
|
}
|
|
break;
|
|
default:
|
|
pArc_1 = {
|
|
x: x3 + calc * (p1.y - p2.y) / q,
|
|
y: y3 + calc * (p2.x - p1.x) / q,
|
|
z: z3 + calc * (p2.z - p1.z) / q
|
|
};
|
|
pArc_2 = {
|
|
x: x3 - calc * (p1.y - p2.y) / q,
|
|
y: y3 - calc * (p2.x - p1.x) / q,
|
|
z: z3 - calc * (p2.z - p1.z) / q
|
|
};
|
|
if (((p1.x - pArc_1.x) * (p1.y + pArc_1.y)) + ((pArc_1.x - p2.x) * (pArc_1.y + p2.y)) >=
|
|
((p1.x - pArc_2.x) * (p1.y + pArc_2.y)) + ((pArc_2.x - p2.x) * (pArc_2.y + p2.y))) {
|
|
var cw = pArc_1;
|
|
var ccw = pArc_2;
|
|
} else {
|
|
var cw = pArc_2;
|
|
var ccw = pArc_1;
|
|
}
|
|
}
|
|
|
|
if ((p2.clockwise === true && radius >= 0) || (p2.clockwise === false && radius < 0)) vpArc = new THREE.Vector3(cw.x, cw.y, cw.z);
|
|
else vpArc = new THREE.Vector3(ccw.x, ccw.y, ccw.z);
|
|
|
|
} else {
|
|
// this code deals with IJK gcode commands
|
|
/*if(args.clockwise === false || args.cmd === "G3")
|
|
var pArc = {
|
|
x: p2.arci ? p1.x + p2.arci : p1.x,
|
|
y: p2.arcj ? p1.y + p2.arcj : p1.y,
|
|
z: p2.arck ? p1.z + p2.arck : p1.z,
|
|
};
|
|
else*/
|
|
var pArc = {
|
|
x: p2.arci,
|
|
y: p2.arcj,
|
|
z: p2.arck,
|
|
};
|
|
//console.log("new pArc:", pArc);
|
|
vpArc = new THREE.Vector3(pArc.x, pArc.y, pArc.z);
|
|
//console.log("vpArc:", vpArc);
|
|
}
|
|
|
|
var threeObjArc = this.drawArcFrom2PtsAndCenter(vp1, vp2, vpArc, args);
|
|
|
|
// still push the normal p1/p2 point for debug
|
|
p2.g2 = true;
|
|
p2.threeObjArc = threeObjArc;
|
|
// these golden lines showing start/end of a g2 or g3 arc were confusing people
|
|
// so hiding them for now. jlauer 8/15/15
|
|
/*
|
|
geometry = group.geometry;
|
|
geometry.vertices.push(
|
|
new THREE.Vector3(p1.x, p1.y, p1.z));
|
|
geometry.vertices.push(
|
|
new THREE.Vector3(p2.x, p2.y, p2.z));
|
|
geometry.colors.push(group.color);
|
|
geometry.colors.push(group.color);
|
|
*/
|
|
// end of if p2.arc
|
|
// console.log( p2.threeObjArc.userData.points)
|
|
|
|
// console.log(JSON.stringify(threeObjArc.userData))
|
|
|
|
var a = new THREE.Vector3(p1.x, p1.y, p1.z);
|
|
var b = new THREE.Vector3(p2.x, p2.y, p2.z);
|
|
|
|
if (dist > 0) {
|
|
this.totalDist += dist;
|
|
}
|
|
|
|
// calc distance of one segment of the arc
|
|
dist = a.distanceTo(b) / threeObjArc.userData.points.length;
|
|
|
|
// time to execute this move
|
|
// if this move is 10mm and we are moving at 100mm/min then
|
|
// this move will take 10/100 = 0.1 minutes or 6 seconds
|
|
|
|
|
|
|
|
for (i = 0; i < threeObjArc.userData.points.length; i++) {
|
|
var timeMinutes = 0;
|
|
if (dist > 0) {
|
|
var fr;
|
|
if (args.feedrate > 0) {
|
|
fr = args.feedrate
|
|
} else {
|
|
fr = 1000;
|
|
}
|
|
timeMinutes = dist / fr;
|
|
|
|
// adjust for acceleration, meaning estimate
|
|
// this will run longer than estimated from the math
|
|
// above because we don't start moving at full feedrate
|
|
// obviously, we have to slowly accelerate in and out
|
|
timeMinutes = timeMinutes * 1.32;
|
|
}
|
|
this.totalTime += timeMinutes;
|
|
var p2sub = {
|
|
x: threeObjArc.userData.points[i].x,
|
|
y: threeObjArc.userData.points[i].y,
|
|
z: threeObjArc.userData.points[i].z,
|
|
e: p2.e,
|
|
f: p2.f,
|
|
g2: true,
|
|
g2segment: true,
|
|
feedrate: fr,
|
|
dist: dist,
|
|
distSum: this.totalDist,
|
|
timeMins: timeMinutes,
|
|
timeMinsSum: this.totalTime,
|
|
}
|
|
lines.push({
|
|
p2: p2sub,
|
|
'args': args
|
|
});
|
|
}
|
|
|
|
} else { // not an arc
|
|
lines.push({
|
|
p2: p2,
|
|
'args': args
|
|
});
|
|
}
|
|
|
|
|
|
// DISTANCE CALC
|
|
// add distance so we can calc estimated time to run
|
|
// see if arc
|
|
var dist = 0;
|
|
if (p2.arc) {
|
|
// calc dist of all lines
|
|
//console.log("this is an arc to calc dist for. p2.threeObjArc:", p2.threeObjArc, "p2:", p2);
|
|
var arcGeo = p2.threeObjArc.geometry;
|
|
//console.log("arcGeo:", arcGeo);
|
|
|
|
var tad2 = 0;
|
|
for (var arcLineCtr = 0; arcLineCtr < arcGeo.vertices.length - 1; arcLineCtr++) {
|
|
tad2 += arcGeo.vertices[arcLineCtr].distanceTo(arcGeo.vertices[arcLineCtr + 1]);
|
|
}
|
|
//console.log("tad2:", tad2);
|
|
|
|
|
|
// just do straight line calc
|
|
var a = new THREE.Vector3(p1.x, p1.y, p1.z);
|
|
var b = new THREE.Vector3(p2.x, p2.y, p2.z);
|
|
var straightDist = a.distanceTo(b);
|
|
|
|
//console.log("diff of straight line calc vs arc sum. straightDist:", straightDist);
|
|
|
|
dist = tad2;
|
|
|
|
} else {
|
|
// just do straight line calc
|
|
var a = new THREE.Vector3(p1.x, p1.y, p1.z);
|
|
var b = new THREE.Vector3(p2.x, p2.y, p2.z);
|
|
dist = a.distanceTo(b);
|
|
}
|
|
|
|
if (dist > 0) {
|
|
this.totalDist += dist;
|
|
}
|
|
|
|
// time to execute this move
|
|
// if this move is 10mm and we are moving at 100mm/min then
|
|
// this move will take 10/100 = 0.1 minutes or 6 seconds
|
|
var timeMinutes = 0;
|
|
if (dist > 0) {
|
|
var fr;
|
|
if (args.feedrate > 0) {
|
|
fr = args.feedrate
|
|
} else {
|
|
fr = 100;
|
|
}
|
|
timeMinutes = dist / fr;
|
|
|
|
// adjust for acceleration, meaning estimate
|
|
// this will run longer than estimated from the math
|
|
// above because we don't start moving at full feedrate
|
|
// obviously, we have to slowly accelerate in and out
|
|
timeMinutes = timeMinutes * 1.32;
|
|
}
|
|
this.totalTime += timeMinutes;
|
|
|
|
p2.feedrate = args.feedrate;
|
|
p2.dist = dist;
|
|
p2.distSum = this.totalDist;
|
|
p2.timeMins = timeMinutes;
|
|
p2.timeMinsSum = this.totalTime;
|
|
|
|
// console.log("calculating distance. dist:", dist, "totalDist:", this.totalDist, "feedrate:", args.feedrate, "timeMinsToExecute:", timeMinutes, "totalTime:", this.totalTime, "p1:", p1, "p2:", p2, "args:", args);
|
|
|
|
}
|
|
this.totalDist = 0;
|
|
this.totalTime = 0;
|
|
|
|
var relative = false;
|
|
|
|
this.delta = function(v1, v2) {
|
|
return relative ? v2 : v2 - v1;
|
|
}
|
|
|
|
this.absolute = function(v1, v2) {
|
|
return relative ? v1 + v2 : v2;
|
|
}
|
|
|
|
var ijkrelative = true; // For Mach3 Arc IJK Absolute mode
|
|
this.ijkabsolute = function(v1, v2) {
|
|
return ijkrelative ? v1 + v2 : v2;
|
|
}
|
|
|
|
this.addFakeSegment = function(args) {
|
|
//line.args = args;
|
|
var arg2 = {
|
|
isFake: true,
|
|
text: args.text,
|
|
indx: args.indx
|
|
};
|
|
if (arg2.text.match(/^(;|\(|<)/)) arg2.isComment = true;
|
|
lines.push({
|
|
p2: lastLine, // since this is fake, just use lastLine as xyz
|
|
'args': arg2
|
|
});
|
|
}
|
|
|
|
var cofg = this;
|
|
var parser = new this.GCodeParser({
|
|
//set the g92 offsets for the parser - defaults to no offset
|
|
/* When doing CNC, generally G0 just moves to a new location
|
|
as fast as possible which means no milling or extruding is happening in G0.
|
|
So, let's color it uniquely to indicate it's just a toolhead move. */
|
|
G0: function(args, indx) {
|
|
//G1.apply(this, args, line, 0x00ff00);
|
|
//console.log("G0", args);
|
|
var newLine = {
|
|
x: args.x !== undefined ? cofg.absolute(lastLine.x, args.x) + cofg.offsetG92.x : lastLine.x,
|
|
y: args.y !== undefined ? cofg.absolute(lastLine.y, args.y) + cofg.offsetG92.y : lastLine.y,
|
|
z: args.z !== undefined ? cofg.absolute(lastLine.z, args.z) + cofg.offsetG92.z : lastLine.z,
|
|
e: args.e !== undefined ? cofg.absolute(lastLine.e, args.e) + cofg.offsetG92.e : lastLine.e,
|
|
f: args.f !== undefined ? cofg.absolute(lastLine.f, args.f) : lastLine.f,
|
|
s: args.s !== undefined ? cofg.absolute(lastLine.s, args.s) : lastLine.s,
|
|
t: args.t !== undefined ? cofg.absolute(lastLine.t, args.t) : lastLine.t,
|
|
};
|
|
newLine.g0 = true;
|
|
//cofg.newLayer(newLine);
|
|
cofg.addSegment(lastLine, newLine, args);
|
|
//console.log("G0", lastLine, newLine, args, cofg.offsetG92);
|
|
lastLine = newLine;
|
|
},
|
|
G1: function(args, indx) {
|
|
// Example: G1 Z1.0 F3000
|
|
// G1 X99.9948 Y80.0611 Z15.0 F1500.0 E981.64869
|
|
// G1 E104.25841 F1800.0
|
|
// Go in a straight line from the current (X, Y) point
|
|
// to the point (90.6, 13.8), extruding material as the move
|
|
// happens from the current extruded length to a length of
|
|
// 22.4 mm.
|
|
var newLine = {
|
|
x: args.x !== undefined ? cofg.absolute(lastLine.x, args.x) + cofg.offsetG92.x : lastLine.x,
|
|
y: args.y !== undefined ? cofg.absolute(lastLine.y, args.y) + cofg.offsetG92.y : lastLine.y,
|
|
z: args.z !== undefined ? cofg.absolute(lastLine.z, args.z) + cofg.offsetG92.z : lastLine.z,
|
|
e: args.e !== undefined ? cofg.absolute(lastLine.e, args.e) + cofg.offsetG92.e : lastLine.e,
|
|
f: args.f !== undefined ? cofg.absolute(lastLine.f, args.f) : lastLine.f,
|
|
s: args.s !== undefined ? cofg.absolute(lastLine.s, args.s) : lastLine.s,
|
|
t: args.t !== undefined ? cofg.absolute(lastLine.t, args.t) : lastLine.t,
|
|
};
|
|
/* layer change detection is or made by watching Z, it's made by
|
|
watching when we extrude at a new Z position */
|
|
if (cofg.delta(lastLine.e, newLine.e) > 0) {
|
|
newLine.extruding = cofg.delta(lastLine.e, newLine.e) > 0;
|
|
if (layer == undefined || newLine.z != layer.z) cofg.newLayer(newLine);
|
|
}
|
|
newLine.g1 = true;
|
|
cofg.addSegment(lastLine, newLine, args);
|
|
//console.log("G1", lastLine, newLine, args, cofg.offsetG92);
|
|
lastLine = newLine;
|
|
},
|
|
G2: function(args, indx, gcp) {
|
|
/* this is an arc move from lastLine's xy to the new xy. we'll
|
|
show it as a light gray line, but we'll also sub-render the
|
|
arc itself by figuring out the sub-segments . */
|
|
var newLine = {
|
|
x: args.x !== undefined ? cofg.absolute(lastLine.x, args.x) + cofg.offsetG92.x : lastLine.x,
|
|
y: args.y !== undefined ? cofg.absolute(lastLine.y, args.y) + cofg.offsetG92.y : lastLine.y,
|
|
z: args.z !== undefined ? cofg.absolute(lastLine.z, args.z) + cofg.offsetG92.z : lastLine.z,
|
|
e: args.e !== undefined ? cofg.absolute(lastLine.e, args.e) + cofg.offsetG92.e : lastLine.e,
|
|
f: args.f !== undefined ? cofg.absolute(lastLine.f, args.f) : lastLine.f,
|
|
s: args.s !== undefined ? cofg.absolute(lastLine.s, args.s) : lastLine.s,
|
|
t: args.t !== undefined ? cofg.absolute(lastLine.t, args.t) : lastLine.t,
|
|
arci: args.i !== undefined ? cofg.ijkabsolute(lastLine.x, args.i) : lastLine.x,
|
|
arcj: args.j !== undefined ? cofg.ijkabsolute(lastLine.y, args.j) : lastLine.y,
|
|
arck: args.k !== undefined ? cofg.ijkabsolute(lastLine.z, args.k) : lastLine.z,
|
|
arcr: args.r ? args.r : null,
|
|
};
|
|
//console.log("G2 newLine:", newLine);
|
|
//newLine.g2 = true;
|
|
newLine.arc = true;
|
|
newLine.clockwise = true;
|
|
if (args.clockwise === false) newLine.clockwise = args.clockwise;
|
|
cofg.addSegment(lastLine, newLine, args);
|
|
//console.log("G2", lastLine, newLine, args, cofg.offsetG92);
|
|
lastLine = newLine;
|
|
//console.log("G2. args:", args);
|
|
},
|
|
G3: function(args, indx, gcp) {
|
|
/* this is an arc move from lastLine's xy to the new xy. same
|
|
as G2 but reverse*/
|
|
args.arc = true;
|
|
args.clockwise = false;
|
|
gcp.handlers.G2(args, indx, gcp);
|
|
},
|
|
|
|
G73: function(args, indx, gcp) {
|
|
// peck drilling. just treat as g1
|
|
newLine.g73 = true;
|
|
console.log("G73 gcp:", gcp);
|
|
gcp.handlers.G1(args);
|
|
},
|
|
|
|
G92: function(args) { // E0
|
|
// G92: Set Position
|
|
// Example: G92 E0
|
|
// Allows programming of absolute zero point, by reseting the
|
|
// current position to the values specified. This would set the
|
|
// machine's X coordinate to 10, and the extrude coordinate to 90.
|
|
// No physical motion will occur.
|
|
|
|
// TODO: Only support E0
|
|
var newLine = lastLine;
|
|
|
|
cofg.offsetG92.x = (args.x !== undefined ? (args.x === 0 ? newLine.x : newLine.x - args.x) : 0);
|
|
cofg.offsetG92.y = (args.y !== undefined ? (args.y === 0 ? newLine.y : newLine.y - args.y) : 0);
|
|
cofg.offsetG92.z = (args.z !== undefined ? (args.z === 0 ? newLine.z : newLine.z - args.z) : 0);
|
|
cofg.offsetG92.e = (args.e !== undefined ? (args.e === 0 ? newLine.e : newLine.e - args.e) : 0);
|
|
|
|
//newLine.x = args.x !== undefined ? args.x + newLine.x : newLine.x;
|
|
//newLine.y = args.y !== undefined ? args.y + newLine.y : newLine.y;
|
|
//newLine.z = args.z !== undefined ? args.z + newLine.z : newLine.z;
|
|
//newLine.e = args.e !== undefined ? args.e + newLine.e : newLine.e;
|
|
|
|
//console.log("G92", lastLine, newLine, args, cofg.offsetG92);
|
|
|
|
//lastLine = newLine;
|
|
cofg.addFakeSegment(args);
|
|
},
|
|
M30: function(args) {
|
|
cofg.addFakeSegment(args);
|
|
},
|
|
|
|
'default': function(args, info) {
|
|
//if (!args.isComment)
|
|
//console.log('Unknown command:', args.cmd, args, info);
|
|
cofg.addFakeSegment(args);
|
|
},
|
|
},
|
|
// Mode-setting non-motion commands, of which many may appear on one line
|
|
// These take no arguments
|
|
{
|
|
G17: function() {
|
|
console.log("SETTING XY PLANE");
|
|
},
|
|
|
|
G18: function() {
|
|
console.log("SETTING XZ PLANE");
|
|
},
|
|
|
|
G19: function() {
|
|
console.log("SETTING YZ PLANE");
|
|
},
|
|
|
|
G20: function() {
|
|
// G21: Set Units to Inches
|
|
// We don't really have to do anything since 3d viewer is unit agnostic
|
|
// However, we need to set a global property so the trinket decorations
|
|
// like toolhead, axes, grid, and extent labels are scaled correctly
|
|
// later on when they are drawn after the gcode is rendered
|
|
cofg.setUnits("inch");
|
|
},
|
|
|
|
G21: function() {
|
|
// G21: Set Units to Millimeters
|
|
// Example: G21
|
|
// Units from now on are in millimeters. (This is the RepRap default.)
|
|
cofg.setUnits("mm");
|
|
},
|
|
|
|
// A bunch of no-op modes that do not affect the viewer
|
|
G40: function() {}, // Tool radius compensation off
|
|
G41: function() {}, // Tool radius compensation left
|
|
G42: function() {}, // Tool radius compensation right
|
|
G45: function() {}, // Axis offset single increase
|
|
G46: function() {}, // Axis offset single decrease
|
|
G47: function() {}, // Axis offset double increase
|
|
G48: function() {}, // Axis offset double decrease
|
|
G49: function() {}, // Tool length offset compensation cancle
|
|
G54: function() {}, // Select work coordinate system 1
|
|
G55: function() {}, // Select work coordinate system 2
|
|
G56: function() {}, // Select work coordinate system 3
|
|
G57: function() {}, // Select work coordinate system 4
|
|
G58: function() {}, // Select work coordinate system 5
|
|
G59: function() {}, // Select work coordinate system 6
|
|
G61: function() {}, // Exact stop check mode
|
|
G64: function() {}, // Cancel G61
|
|
G69: function() {}, // Cancel G68
|
|
|
|
G90: function() {
|
|
// G90: Set to Absolute Positioning
|
|
// Example: G90
|
|
// All coordinates from now on are absolute relative to the
|
|
// origin of the machine. (This is the RepRap default.)
|
|
relative = false;
|
|
},
|
|
|
|
'G90.1': function() {
|
|
// G90.1: Set to Arc Absolute IJK Positioning
|
|
// Example: G90.1
|
|
// From now on, arc centers are specified directly by
|
|
// the IJK parameters, e.g. center_x = I_value
|
|
// This is Mach3-specific
|
|
ijkrelative = false;
|
|
},
|
|
|
|
G91: function() {
|
|
// G91: Set to Relative Positioning
|
|
// Example: G91
|
|
// All coordinates from now on are relative to the last position.
|
|
relative = true;
|
|
},
|
|
|
|
'G91.1': function() {
|
|
// G91.1: Set to Arc Relative IJK Positioning
|
|
// Example: G91.1
|
|
// From now on, arc centers are relative to the starting
|
|
// coordinate, e.g. center_x = this_x + I_value
|
|
// This is the default, and the only possibility for most
|
|
// controllers other than Mach3
|
|
ijkrelative = true;
|
|
},
|
|
|
|
// No-op modal macros that do not affect the viewer
|
|
M3: function() {}, // Spindle on
|
|
M5: function() {}, // Spindle off
|
|
M6: function(args) {}, // Pause for Toolchange
|
|
M07: function() {}, // Coolant on (mist)
|
|
M08: function() {}, // Coolant on (flood)
|
|
M09: function() {}, // Coolant off
|
|
M10: function() {}, // Pallet clamp on
|
|
M11: function() {}, // Pallet clamp off
|
|
M21: function() {}, // Mirror X axis
|
|
M22: function() {}, // Mirror Y axis
|
|
M23: function() {}, // Mirror off
|
|
M24: function() {}, // Thread pullout gradual off
|
|
M41: function() {}, // Select gear 1
|
|
M42: function() {}, // Select gear 2
|
|
M43: function() {}, // Select gear 3
|
|
M44: function() {}, // Select gear 4
|
|
M48: function() {}, // Allow feedrate override
|
|
M49: function() {}, // Disallow feedrate override
|
|
M52: function() {}, // Empty spindle
|
|
M60: function() {}, // Automatic pallet change
|
|
|
|
M82: function() {
|
|
// M82: Set E codes absolute (default)
|
|
// Descriped in Sprintrun source code.
|
|
|
|
// No-op, so long as M83 is not supported.
|
|
},
|
|
|
|
M84: function() {
|
|
// M84: Stop idle hold
|
|
// Example: M84
|
|
// Stop the idle hold on all axis and extruder. In some cases the
|
|
// idle hold causes annoying noises, which can be stopped by
|
|
// disabling the hold. Be aware that by disabling idle hold during
|
|
// printing, you will get quality issues. This is recommended only
|
|
// in between or after printjobs.
|
|
// No-op
|
|
},
|
|
});
|
|
// console.log("GCODE LENGTH " + gcode.length)
|
|
|
|
parser.parse(gcode);
|
|
var data = {
|
|
lines: lines,
|
|
inch: false,
|
|
totalDist: this.totalDist,
|
|
totalTime: this.totalTime,
|
|
}
|
|
|
|
if (!isUnitsMm) {
|
|
data.inch = true;
|
|
} else {
|
|
data.inch = false;
|
|
}
|
|
|
|
return data;
|
|
} // end of createObjectFromGCode()
|