Doodle3D-Slicer/src/slicer.js

539 lines
15 KiB
JavaScript
Raw Normal View History

2015-04-24 16:12:48 +02:00
/******************************************************
*
* Slicer
*
* TODO (optimalisatie)
* sorteer lijnen op laagste hoogte -> stop loop wanneer hij een lijn zonder intersectie heeft gevonden
* verwijder lijnen die ooit interactie gehad hebben, maar nu niet meer
2015-04-30 18:26:34 +02:00
* helft van lijnen toevoegen omdat 4face altijd recht is, en 3face dus te veel data bevat
*
* omliggende lagen -> difference && sum omliggende lijnen
* voor laag 5 = 5 diff (3 && 4 && 6 && 7))
2015-04-24 16:12:48 +02:00
*
******************************************************/
D3D.Slicer = function () {
2015-04-24 16:12:48 +02:00
"use strict";
};
D3D.Slicer.prototype.setMesh = function (mesh) {
"use strict";
2015-05-15 15:07:47 +02:00
//convert buffergeometry to geometry;
var geometry = mesh.geometry.clone();
2015-05-06 15:06:04 +02:00
if (geometry instanceof THREE.BufferGeometry) {
geometry = new THREE.Geometry().fromBufferGeometry(geometry);
}
2015-05-15 15:07:47 +02:00
//remove duplicate vertices;
for (var i = 0; i < geometry.vertices.length; i ++) {
var vertexA = geometry.vertices[i];
for (var j = i + 1; j < geometry.vertices.length; j ++) {
var vertexB = geometry.vertices[j];
if (vertexA.equals(vertexB)) {
geometry.vertices[j] = vertexA;
}
}
}
2015-05-12 11:29:01 +02:00
geometry.mergeVertices();
2015-05-15 15:07:47 +02:00
//apply mesh matrix on geometry;
mesh.updateMatrix();
2015-05-12 11:29:01 +02:00
geometry.applyMatrix(mesh.matrix);
2015-05-15 15:07:47 +02:00
geometry.computeFaceNormals();
geometry.computeBoundingBox();
this.geometry = geometry;
2015-05-15 15:07:47 +02:00
//get unique lines from geometry;
this.createLines();
return this;
};
D3D.Slicer.prototype.createLines = function () {
2015-05-01 14:09:45 +02:00
"use strict";
2015-04-24 16:12:48 +02:00
this.lines = [];
var lineLookup = {};
2015-04-24 16:12:48 +02:00
var self = this;
function addLine (a, b) {
2015-04-24 16:12:48 +02:00
//think lookup can only be b_a, a_b is only possible when face is flipped
var index = lineLookup[b + "_" + a] || lineLookup[a + "_" + b];
2015-04-24 16:12:48 +02:00
if (index === undefined) {
index = self.lines.length;
lineLookup[a + "_" + b] = index;
2015-04-24 16:12:48 +02:00
self.lines.push({
2015-05-07 14:09:36 +02:00
line: new THREE.Line3(self.geometry.vertices[a], self.geometry.vertices[b]),
connects: [],
2015-05-12 11:29:01 +02:00
normals: [],
ignore: 0
});
}
return index;
2015-05-07 11:04:48 +02:00
}
2015-04-24 16:12:48 +02:00
for (var i = 0; i < this.geometry.faces.length; i ++) {
var face = this.geometry.faces[i];
2015-05-13 12:12:15 +02:00
if (face.normal.y !== 1 && face.normal.y !== -1) {
var normal = new THREE.Vector2().set(face.normal.z, face.normal.x).normalize();
2015-05-13 12:12:15 +02:00
//check for only adding unique lines
//returns index of said line
var a = addLine(face.a, face.b);
var b = addLine(face.b, face.c);
var c = addLine(face.c, face.a);
//set connecting lines (based on face)
this.lines[a].connects.push(b, c);
this.lines[b].connects.push(c, a);
this.lines[c].connects.push(a, b);
this.lines[a].normals.push(normal);
this.lines[b].normals.push(normal);
this.lines[c].normals.push(normal);
}
2015-04-24 16:12:48 +02:00
}
};
D3D.Slicer.prototype.slice = function (height, step) {
"use strict";
var layersIntersections = [];
for (var i = 0; i < this.lines.length; i ++) {
var line = this.lines[i];
var min = Math.ceil(Math.min(line.line.start.y, line.line.end.y) / step);
var max = Math.floor(Math.max(line.line.start.y, line.line.end.y) / step);
2015-05-13 12:12:15 +02:00
for (var layerIndex = min; layerIndex <= max; layerIndex ++) {
if (layerIndex >= 0) {
if (layersIntersections[layerIndex] === undefined) {
layersIntersections[layerIndex] = [];
}
2015-05-13 12:12:15 +02:00
layersIntersections[layerIndex].push(i);
}
}
}
2015-04-24 16:12:48 +02:00
var slices = [];
//still error in first layer, so remove first layer & last layer
//see https://github.com/Doodle3D/Doodle3D-Slicer/issues/1
2015-05-13 17:37:52 +02:00
for (var layer = 1; layer < layersIntersections.length-1; layer ++) {
//for (var layer = 0; layer < layersIntersections.length; layer ++) {
var layerIntersections = layersIntersections[layer];
var y = layer*step;
2015-04-24 16:12:48 +02:00
var intersections = [];
for (var i = 0; i < layerIntersections.length; i ++) {
var index = layerIntersections[i];
var line = this.lines[index].line;
var alpha = (y - line.start.y) / (line.end.y - line.start.y);
2015-05-12 11:29:01 +02:00
var x = line.end.x * alpha + line.start.x * (1 - alpha);
var z = line.end.z * alpha + line.start.z * (1 - alpha);
intersections[index] = new THREE.Vector2(z, x);
2015-04-24 16:12:48 +02:00
}
var done = [];
var slice = [];
for (var i = 0; i < layerIntersections.length; i ++) {
var index = layerIntersections[i];
2015-04-24 16:12:48 +02:00
if (done.indexOf(index) === -1) {
2015-05-13 17:37:52 +02:00
var shape = [];
2015-04-24 16:12:48 +02:00
while (index !== -1) {
var intersection = intersections[index];
2015-04-30 18:26:34 +02:00
shape.push({X: intersection.x, Y: intersection.y});
2015-04-24 16:12:48 +02:00
done.push(index);
var connects = this.lines[index].connects;
var faceNormals = this.lines[index].normals;
2015-04-24 16:12:48 +02:00
for (var j = 0; j < connects.length; j ++) {
index = connects[j];
if (intersections[index] && done.indexOf(index) === -1) {
var a = new THREE.Vector2(intersection.x, intersection.y);
2015-04-30 20:34:57 +02:00
var b = intersections[index];
var normal = a.sub(b).normal().normalize();
2015-04-30 18:26:34 +02:00
var faceNormal = faceNormals[Math.floor(j/2)];
2015-04-28 18:10:16 +02:00
if (normal.dot(faceNormal) > 0) {
break;
}
else {
index = -1;
}
2015-04-24 16:12:48 +02:00
}
else {
index = -1;
}
}
}
/*
for (var i = 0; i < shape.length; i ++) {
var point = shape[i];
var previousPoint = shape[(i + shape.length - 1) % shape.length];
var nextPoint = shape[(i + 1) % shape.length];
var point = new THREE.Vector2(point.X, point.Y);
var previousPoint = new THREE.Vector2(previousPoint.X, previousPoint.Y);
var nextPoint = new THREE.Vector2(nextPoint.X, nextPoint.Y);
//var lineLength = nextPoint.sub(previousPoint).length();
var normal = nextPoint.sub(previousPoint).normal().normalize();
var distance = Math.abs(normal.dot(point.sub(previousPoint)));
//something better for offset check
if (distance <= 0.01) {
shape.splice(i, 1);
i --;
}
}
*/
2015-04-24 16:12:48 +02:00
//think this check is not nescesary, always higher as 0
if (shape.length > 0) {
2015-05-13 17:37:52 +02:00
slice.push(new D3D.Paths([shape]));
2015-04-24 16:12:48 +02:00
}
}
}
2015-05-13 17:37:52 +02:00
var layerParts = [];
for (var i = 0; i < slice.length; i ++) {
var layerPart1 = slice[i];
var merge = false;
2015-05-13 13:18:37 +02:00
2015-05-13 17:37:52 +02:00
for (var j = 0; j < layerParts.length; j ++) {
var layerPart2 = layerParts[j];
if (layerPart2.intersect(layerPart1).length > 0) {
layerPart2.join(layerPart1);
merge = true;
break;
}
}
if (!merge) {
layerParts.push(layerPart1);
}
}
//stop when ther are no intersects
if (layerParts.length > 0) {
slices.push(layerParts);
}
else {
break;
}
2015-04-24 16:12:48 +02:00
}
return slices;
};
2015-05-01 10:06:52 +02:00
D3D.Slicer.prototype.slicesToData = function (slices, printer) {
2015-04-30 20:34:57 +02:00
"use strict";
2015-04-30 18:26:34 +02:00
var scale = 100;
2015-05-01 10:06:52 +02:00
var layerHeight = printer.config["printer.layerHeight"] * scale;
var dimensionsZ = printer.config["printer.dimensions.z"] * scale;
var wallThickness = printer.config["printer.wallThickness"] * scale / 2;
2015-05-01 11:03:07 +02:00
var shellThickness = printer.config["printer.shellThickness"] * scale;
var fillSize = printer.config["printer.fillSize"] * scale;
var brimOffset = printer.config["printer.brimOffset"] * scale;
2015-05-18 13:53:49 +02:00
var bottomThickness = printer.config["printer.bottomThickness"] * scale;
var topThickness = printer.config["printer.topThickness"] * scale;
2015-05-18 13:53:49 +02:00
var bottomSkinCount = Math.ceil(bottomThickness/layerHeight);
var topSkinCount = Math.ceil(topThickness/layerHeight);
2015-05-01 11:03:07 +02:00
2015-05-15 11:14:44 +02:00
var start = new THREE.Vector2(0, 0);
2015-05-01 11:03:07 +02:00
var data = [];
2015-04-30 18:26:34 +02:00
2015-05-15 11:14:44 +02:00
var lowFillTemplate = this.getFillTemplate({
left: this.geometry.boundingBox.min.z * scale,
top: this.geometry.boundingBox.min.x * scale,
right: this.geometry.boundingBox.max.z * scale,
bottom: this.geometry.boundingBox.max.x * scale
2015-05-15 11:14:44 +02:00
}, fillSize, true, true);
2015-04-24 16:12:48 +02:00
for (var layer = 0; layer < slices.length; layer ++) {
var slice = slices[layer];
2015-05-13 17:37:52 +02:00
var layerData = [];
data.push(layerData);
2015-05-15 11:14:44 +02:00
var downSkin = new D3D.Paths([], true);
2015-05-18 13:53:49 +02:00
if (layer - bottomSkinCount >= 0) {
var downLayer = slices[layer - bottomSkinCount];
2015-05-13 17:37:52 +02:00
for (var i = 0; i < downLayer.length; i ++) {
downSkin.join(downLayer[i]);
}
}
2015-05-15 11:14:44 +02:00
var upSkin = new D3D.Paths([], true);
2015-05-18 13:53:49 +02:00
if (layer + topSkinCount < slices.length) {
var downLayer = slices[layer + topSkinCount];
2015-05-13 17:37:52 +02:00
for (var i = 0; i < downLayer.length; i ++) {
upSkin.join(downLayer[i]);
}
}
var surroundingLayer = upSkin.intersect(downSkin).scaleUp(scale);
2015-05-13 17:37:52 +02:00
var sliceData = [];
2015-04-30 18:26:34 +02:00
2015-05-13 12:12:15 +02:00
for (var i = 0; i < slice.length; i ++) {
var part = slice[i];
2015-05-18 13:53:49 +02:00
//var outerLayer = part.clone();
var outerLayer = part.clone().scaleUp(scale).offset(-wallThickness/2);
2015-04-24 16:12:48 +02:00
2015-05-18 13:53:49 +02:00
if (outerLayer.length > 0) {
var insets = new D3D.Paths([], true);
for (var offset = wallThickness; offset <= shellThickness; offset += wallThickness) {
var inset = outerLayer.offset(-offset);
2015-04-30 18:26:34 +02:00
2015-05-18 13:53:49 +02:00
insets.join(inset);
}
2015-05-13 12:12:15 +02:00
2015-05-18 13:53:49 +02:00
var fillArea = (inset || outerLayer).offset(-wallThickness/2);
//var fillArea = (inset || outerLayer).clone();
2015-05-13 12:12:15 +02:00
2015-05-18 13:53:49 +02:00
var highFillArea = fillArea.difference(surroundingLayer);
2015-05-13 12:12:15 +02:00
2015-05-18 13:53:49 +02:00
var lowFillArea = fillArea.difference(highFillArea);
2015-04-30 20:34:57 +02:00
2015-05-18 13:53:49 +02:00
var fill = new D3D.Paths([], false);
2015-05-13 12:12:15 +02:00
2015-05-18 13:53:49 +02:00
if (lowFillTemplate.length > 0) {
fill.join(lowFillTemplate.intersect(lowFillArea));
}
2015-04-30 20:34:57 +02:00
2015-05-18 13:53:49 +02:00
if (highFillArea.length > 0) {
var bounds = highFillArea.bounds();
var even = (layer % 2 === 0);
var highFillTemplate = this.getFillTemplate(bounds, wallThickness, even, !even);
fill.join(highFillTemplate.intersect(highFillArea));
}
outerLayer = outerLayer.optimizePath(start);
if (insets.length > 0) {
insets = insets.optimizePath(outerLayer.lastPoint());
fill = fill.optimizePath(insets.lastPoint());
}
else {
fill = fill.optimizePath(outerLayer.lastPoint());
}
2015-05-18 13:53:49 +02:00
if (fill.length > 0) {
start = fill.lastPoint();
}
else if (insets.length > 0) {
start = insets.lastPoint();
}
else {
start = outerLayer.lastPoint();
}
layerData.push({
outerLayer: outerLayer.scaleDown(scale),
fill: fill.scaleDown(scale),
insets: insets.scaleDown(scale)
});
}
2015-04-30 20:34:57 +02:00
}
2015-04-30 18:26:34 +02:00
}
return data;
};
2015-05-15 11:14:44 +02:00
D3D.Slicer.prototype.getFillTemplate = function (bounds, size, even, uneven) {
2015-05-12 11:29:01 +02:00
"use strict";
2015-05-13 17:37:52 +02:00
var paths = new D3D.Paths([], false);
2015-05-12 11:29:01 +02:00
if (even) {
for (var length = Math.floor(bounds.left/size)*size; length <= Math.ceil(bounds.right/size)*size; length += size) {
2015-05-15 11:14:44 +02:00
paths.push([{X: length, Y: bounds.top}, {X: length, Y: bounds.bottom}]);
2015-05-12 11:29:01 +02:00
}
}
if (uneven) {
for (var length = Math.floor(bounds.top/size)*size; length <= Math.floor(bounds.bottom/size)*size; length += size) {
2015-05-15 11:14:44 +02:00
paths.push([{X: bounds.left, Y: length}, {X: bounds.right, Y: length}]);
2015-05-12 11:29:01 +02:00
}
}
//return paths;
2015-05-13 17:37:52 +02:00
return paths;
2015-05-12 11:29:01 +02:00
};
2015-05-01 10:06:52 +02:00
D3D.Slicer.prototype.dataToGcode = function (data, printer) {
2015-04-30 18:26:34 +02:00
"use strict";
2015-05-01 10:06:52 +02:00
var layerHeight = printer.config["printer.layerHeight"];
var normalSpeed = printer.config["printer.speed"];
var bottomSpeed = printer.config["printer.bottomLayerSpeed"];
var firstLayerSlow = printer.config["printer.firstLayerSlow"];
var bottomFlowRate = printer.config["printer.bottomFlowRate"];
var travelSpeed = printer.config["printer.travelSpeed"];
var filamentThickness = printer.config["printer.filamentThickness"];
var wallThickness = printer.config["printer.wallThickness"];
var enableTraveling = printer.config["printer.enableTraveling"];
var retractionEnabled = printer.config["printer.retraction.enabled"];
var retractionSpeed = printer.config["printer.retraction.speed"];
var retractionMinDistance = printer.config["printer.retraction.minDistance"];
var retractionAmount = printer.config["printer.retraction.amount"];
2015-05-06 15:06:04 +02:00
2015-04-30 18:26:34 +02:00
function sliceToGcode (slice) {
var gcode = [];
2015-04-24 16:12:48 +02:00
2015-05-13 12:12:15 +02:00
for (var i = 0; i < slice.length; i ++) {
var shape = slice[i];
2015-04-24 16:12:48 +02:00
var previousPoint;
2015-05-13 17:37:52 +02:00
var length = slice.closed ? (shape.length + 1) : shape.length;
for (var j = 0; j < length; j ++) {
var point = shape[j % shape.length];
2015-04-24 16:12:48 +02:00
if (j === 0) {
//TODO
//add retraction
2015-04-30 18:26:34 +02:00
if (extruder > retractionMinDistance && retractionEnabled) {
2015-04-24 16:12:48 +02:00
gcode.push([
"G0",
2015-05-07 14:09:36 +02:00
"E" + (extruder - retractionAmount).toFixed(3),
2015-04-24 21:32:39 +02:00
"F" + (retractionSpeed * 60).toFixed(3)
2015-04-24 16:12:48 +02:00
].join(" "));
}
gcode.push([
"G0",
2015-04-30 18:26:34 +02:00
"X" + point.X.toFixed(3) + " Y" + point.Y.toFixed(3) + " Z" + z,
2015-05-15 11:14:44 +02:00
"F" + (travelSpeed * 60)
2015-04-24 16:12:48 +02:00
].join(" "));
2015-04-30 18:26:34 +02:00
if (extruder > retractionMinDistance && retractionEnabled) {
2015-04-24 16:12:48 +02:00
gcode.push([
"G0",
2015-05-07 14:09:36 +02:00
"E" + extruder.toFixed(3),
2015-04-24 21:32:39 +02:00
"F" + (retractionSpeed * 60).toFixed(3)
2015-04-24 16:12:48 +02:00
].join(" "));
}
}
else {
2015-05-19 19:04:20 +02:00
var a = new THREE.Vector2(point.X, point.Y);
var b = new THREE.Vector2(previousPoint.X, previousPoint.Y);
2015-04-30 18:26:34 +02:00
var lineLength = a.distanceTo(b);
2015-04-24 16:12:48 +02:00
extruder += lineLength * wallThickness * layerHeight / filamentSurfaceArea * flowRate;
gcode.push([
"G1",
2015-04-30 18:26:34 +02:00
"X" + point.X.toFixed(3) + " Y" + point.Y.toFixed(3) + " Z" + z,
2015-04-24 16:12:48 +02:00
"F" + speed,
"E" + extruder.toFixed(3)
].join(" "));
}
previousPoint = point;
}
}
2015-04-30 18:26:34 +02:00
return gcode;
}
2015-05-19 19:04:20 +02:00
var gcode = printer.getStartCode();
2015-04-30 18:26:34 +02:00
var extruder = 0.0;
var speed = firstLayerSlow ? (bottomSpeed*60).toFixed(3) : (normalSpeed*60).toFixed(3);
var filamentSurfaceArea = Math.pow((filamentThickness/2), 2) * Math.PI;
var flowRate = bottomFlowRate;
for (var layer = 0; layer < data.length; layer ++) {
var slice = data[layer];
//turn on fan on layer 2
if (layer === 2) {
gcode.push("M106");
speed = (normalSpeed*60).toFixed(3);
flowRate = 1;
}
var z = ((layer + 1) * layerHeight).toFixed(3);
2015-05-13 17:37:52 +02:00
for (var i = 0; i < slice.length; i ++) {
var layerPart = slice[i];
gcode = gcode.concat(sliceToGcode(layerPart.outerLayer));
gcode = gcode.concat(sliceToGcode(layerPart.insets));
gcode = gcode.concat(sliceToGcode(layerPart.fill));
}
2015-04-24 16:12:48 +02:00
}
2015-05-19 19:04:20 +02:00
gcode = gcode.concat(printer.getEndCode());
return gcode;
2015-05-01 10:06:52 +02:00
};
2015-05-12 11:29:01 +02:00
//only for debug purposes
2015-05-01 12:15:46 +02:00
D3D.Slicer.prototype.drawPaths = function (printer, min, max) {
"use strict";
var layerHeight = printer.config["printer.layerHeight"];
var dimensionsZ = printer.config["printer.dimensions.z"];
var slices = this.slice(dimensionsZ, layerHeight);
var data = this.slicesToData(slices, printer);
2015-05-01 14:09:45 +02:00
var canvas = document.createElement("canvas");
canvas.width = 400;
canvas.height = 400;
var context = canvas.getContext("2d");
2015-05-01 12:15:46 +02:00
for (var layer = min; layer < max; layer ++) {
var slice = data[layer % data.length];
2015-05-13 17:37:52 +02:00
for (var i = 0; i < slice.length; i ++) {
var layerPart = slice[i];
layerPart.insets.draw(context, "blue");
layerPart.outerLayer.draw(context, "green");
layerPart.fill.draw(context, "red");
}
2015-05-01 12:15:46 +02:00
}
return canvas;
};
2015-05-01 10:06:52 +02:00
D3D.Slicer.prototype.getGcode = function (printer) {
"use strict";
var layerHeight = printer.config["printer.layerHeight"];
var dimensionsZ = printer.config["printer.dimensions.z"];
2015-05-07 18:14:10 +02:00
var start = new Date().getTime();
2015-05-01 10:06:52 +02:00
var slices = this.slice(dimensionsZ, layerHeight);
2015-05-07 18:14:10 +02:00
var end = new Date().getTime();
console.log("Slicing: " + (end - start) + "ms");
var start = new Date().getTime();
2015-05-01 10:06:52 +02:00
var data = this.slicesToData(slices, printer);
2015-05-07 18:14:10 +02:00
var end = new Date().getTime();
console.log("Data: " + (end - start) + "ms");
var start = new Date().getTime();
2015-05-01 10:06:52 +02:00
var gcode = this.dataToGcode(data, printer);
2015-05-07 18:14:10 +02:00
var end = new Date().getTime();
console.log("Gcode: " + (end - start) + "ms");
2015-04-24 16:12:48 +02:00
return gcode;
};