implimentent layer parts

build/d3d.js

@@ -568,140 +568,135 @@ D3D.Printer.prototype.subsituteVariables = function (gcode) {
 *
 ******************************************************/
 
-D3D.Path = function (path, closed) {
+D3D.Paths = function (paths, closed) {
 	"use strict";
 
-	this.path = path || [];
+	Array.call(this);
+
+	this.setPaths(paths || []);
+
 	this.closed = (closed !== undefined) ? closed : true;
 };
-D3D.Path.prototype.setPath = function (path) {
+D3D.Paths.prototype = Object.create(Array.prototype);
+D3D.Paths.prototype.setPaths = function (paths) {
 	"use strict";
 
-	this.path = path;
+	for (var i = 0; i < paths.length; i ++) {
+		var path = paths[i];
+		this.push(path);
+	}
 
 	return this;
 };
-D3D.Path.prototype.union = function (path) {
+D3D.Paths.prototype.clip = function (path, type) {
 	"use strict";
 
 	var solution = new ClipperLib.Paths();
 
 	var clipper = new ClipperLib.Clipper();
-	clipper.AddPaths(this.path, ClipperLib.PolyType.ptSubject, this.closed);
+	clipper.AddPaths(this, ClipperLib.PolyType.ptSubject, this.closed);
-	clipper.AddPaths(path.path, ClipperLib.PolyType.ptClip, path.closed);
+	clipper.AddPaths(path, ClipperLib.PolyType.ptClip, path.closed);
-	clipper.Execute(ClipperLib.ClipType.ctUnion, solution);
+	clipper.Execute(type, solution);
 
-	return new D3D.Path(solution, this.closed);
+	return new D3D.Paths(solution);
 };
-D3D.Path.prototype.difference = function (path) {
+D3D.Paths.prototype.union = function (path) {
 	"use strict";
 
-	var solution = new ClipperLib.Paths();
+	return this.clip(path, ClipperLib.ClipType.ctUnion);
-
-	var clipper = new ClipperLib.Clipper();
-	clipper.AddPaths(this.path, ClipperLib.PolyType.ptSubject, this.closed);
-	clipper.AddPaths(path.path, ClipperLib.PolyType.ptClip, path.closed);
-	clipper.Execute(ClipperLib.ClipType.ctDifference, solution);
-
-	return new D3D.Path(solution, this.closed);
 };
-D3D.Path.prototype.intersect = function (path) {
+D3D.Paths.prototype.difference = function (path) {
 	"use strict";
 
-	var solution = new ClipperLib.Paths();
+	return this.clip(path, ClipperLib.ClipType.ctDifference);
-
-	var clipper = new ClipperLib.Clipper();
-	clipper.AddPaths(this.path, ClipperLib.PolyType.ptSubject, this.closed);
-	clipper.AddPaths(path.path, ClipperLib.PolyType.ptClip, path.closed);
-	clipper.Execute(ClipperLib.ClipType.ctIntersection, solution);
-
-	return new D3D.Path(solution, this.closed);
 };
-D3D.Path.prototype.xor = function () {
+D3D.Paths.prototype.intersect = function (path) {
 	"use strict";
 
-	var solution = new ClipperLib.Paths();
+	return this.clip(path, ClipperLib.ClipType.ctIntersection);
-
-	var clipper = new ClipperLib.Clipper();
-	clipper.AddPaths(this.path, ClipperLib.PolyType.ptSubject, this.closed);
-	clipper.AddPaths(path.path, ClipperLib.PolyType.ptClip, path.closed);
-	clipper.Execute(ClipperLib.ClipType.ctXor, solution);
-
-	return new D3D.Path(solution, this.closed);
 };
-D3D.Path.prototype.offset = function (offset) {
+D3D.Paths.prototype.xor = function () {
+	"use strict";
+
+	return this.clip(path, ClipperLib.ClipType.ctXor);
+};
+D3D.Paths.prototype.offset = function (offset) {
 	"use strict";
 
 	var solution = new ClipperLib.Paths();
 	var co = new ClipperLib.ClipperOffset(1, 1);
-	co.AddPaths(this.path, ClipperLib.JoinType.jtRound, ClipperLib.EndType.etClosedPolygon);
+	co.AddPaths(this, ClipperLib.JoinType.jtRound, ClipperLib.EndType.etClosedPolygon);
 	co.Execute(solution, offset);
 
-	return new D3D.Path(solution, this.closed);
+	return new D3D.Paths(solution);
 };
-D3D.Path.prototype.scaleUp = function (factor) {
+D3D.Paths.prototype.scaleUp = function (factor) {
 	"use strict";
 
-	var path = ClipperLib.JS.ScaleUpPaths(this.path, factor);
+	var path = ClipperLib.JS.ScaleUpPaths(this, factor);
 
 	return this;
 };
-D3D.Path.prototype.scaleDown = function (factor) {
+D3D.Paths.prototype.scaleDown = function (factor) {
 	"use strict";
 
-	var path = ClipperLib.JS.ScaleDownPaths(this.path, factor);
+	var path = ClipperLib.JS.ScaleDownPaths(this, factor);
 
 	return this;
 };
-D3D.Path.prototype.tresholdArea = function (minArea) {
+D3D.Paths.prototype.tresholdArea = function (minArea) {
 	"use strict";
 
-	for (var i = 0; i < this.path.length; i ++) {
+	for (var i = 0; i < this.length; i ++) {
-		var shape = this.path[i];
+		var shape = this[i];
 
 		var area = ClipperLib.Clipper.Area(shape);
 
 		if (area < minArea) {
-			this.path.splice(i, 1);
+			this.splice(i, 1);
 			i --;
 		}
 	}
 	
 	return areas;
 };
-D3D.Path.prototype.area = function () {
+D3D.Paths.prototype.area = function () {
 	"use strict";
 
-	var areas = [];
+	return ClipperLib.Clipper.Area(this);
+};
+D3D.Paths.prototype.join = function (path) {
+	"use strict";
 
-	for (var i = 0; i < this.path.length; i ++) {
+	for (var i = 0; i < path.length; i ++) {
-		var shape = this.path[i];
+		this.push(path[i]);
-
-		areas.push(ClipperLib.Clipper.Area(shape))
 	}
 
-	return areas;
+	return this;
 };
-D3D.Path.prototype.join = function (path) {
+D3D.Paths.prototype.clone = function () {
 	"use strict";
 
-	this.path = this.path.concat(path.path);
+	return new D3D.Paths(ClipperLib.JS.Clone(this), this.closed);
+};
+D3D.Paths.prototype.bounds = function () {
+	"use strict";
+
+	return ClipperLib.Clipper.GetBounds(this);
+};
+D3D.Paths.prototype.reverse = function () {
+	"use strict";
+
+	ClipperLib.Clipper.ReversePaths(this);
 
 	return this;
-}
+};
-D3D.Path.prototype.clone = function () {
+D3D.Paths.prototype.draw = function (context, color) {
-	"use strict";
-
-	var path = ClipperLib.JS.Clone(this.path);
-
-	return new D3D.Path(path, this.closed);
-}
-D3D.Path.prototype.draw = function (context, color) {
 	"use strict";
 
 	context.strokeStyle = color;
-	for (var i = 0; i < this.path.length; i ++) {
+	for (var i = 0; i < this.length; i ++) {
-		var shape = this.path[i];
+		var shape = this[i];
 
 		context.beginPath();
 		var length = this.closed ? (shape.length + 1) : shape.length;
@@ -738,12 +733,11 @@ D3D.Slicer.prototype.setMesh = function (mesh) {
 	mesh.updateMatrix();
 
 	var geometry = mesh.geometry.clone();
-	geometry.mergeVertices();
-	geometry.applyMatrix(mesh.matrix);
-
 	if (geometry instanceof THREE.BufferGeometry) {
 		geometry = new THREE.Geometry().fromBufferGeometry(geometry);
 	}
+	geometry.mergeVertices();
+	geometry.applyMatrix(mesh.matrix);
 
 	this.geometry = geometry;
 
@@ -770,7 +764,8 @@ D3D.Slicer.prototype.createLines = function () {
 			self.lines.push({
 				line: new THREE.Line3(self.geometry.vertices[a], self.geometry.vertices[b]), 
 				connects: [], 
-				normals: []
+				normals: [],
+				ignore: 0
 			});
 		}
 
@@ -779,22 +774,25 @@ D3D.Slicer.prototype.createLines = function () {
 
 	for (var i = 0; i < this.geometry.faces.length; i ++) {
 		var face = this.geometry.faces[i];
-		var normal = new THREE.Vector2().set(face.normal.x, face.normal.z).normalize();
 
-		//check for only adding unique lines
+		//if (face.normal.y !== 1 && face.normal.y !== -1) {
-		//returns index of said line
+			var normal = new THREE.Vector2().set(face.normal.x, face.normal.z).normalize();
-		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)
+			//check for only adding unique lines
-		this.lines[a].connects.push(b, c);
+			//returns index of said line
-		this.lines[b].connects.push(c, a);
+			var a = addLine(face.a, face.b);
-		this.lines[c].connects.push(a, b);
+			var b = addLine(face.b, face.c);
+			var c = addLine(face.c, face.a);
 
-		this.lines[a].normals.push(normal);
+			//set connecting lines (based on face)
-		this.lines[b].normals.push(normal);
+			this.lines[a].connects.push(b, c);
-		this.lines[c].normals.push(normal);
+			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);
+		//}
 	}
 };
 D3D.Slicer.prototype.slice = function (height, step) {
@@ -820,7 +818,7 @@ D3D.Slicer.prototype.slice = function (height, step) {
 
 	var slices = [];
 
-	for (var layer = 1; layer < layersIntersections.length; layer ++) {
+	for (var layer = 1; layer < layersIntersections.length-1; layer ++) {
 		var layerIntersections = layersIntersections[layer];
 		var y = layer*step;
 
@@ -837,7 +835,7 @@ D3D.Slicer.prototype.slice = function (height, step) {
 		}
 
 		var done = [];
-		var slice = [];
+		var slice = new D3D.Paths([], true);
 		for (var i = 0; i < layerIntersections.length; i ++) {
 			var index = layerIntersections[i];
 
@@ -898,15 +896,34 @@ D3D.Slicer.prototype.slice = function (height, step) {
 
 				//think this check is not nescesary, always higher as 0
 				if (shape.length > 0) {
-					slice.push(shape);
+					slice.push(new D3D.Paths([shape]));
 				}
 			}
 		}
 
+		var layerParts = [];
+
+		for (var i = 0; i < slice.length; i ++) {
+			var layerPart1 = slice[i];
+			var merge = false;
+
+			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 (slice.length > 0) {
+		if (layerParts.length > 0) {
-			slices.push(new D3D.Path(slice, true));
+			slices.push(layerParts);
-			//slices.push(slice);
 		}
 		else {
 			break;
@@ -935,36 +952,58 @@ D3D.Slicer.prototype.slicesToData = function (slices, printer) {
 	for (var layer = 0; layer < slices.length; layer ++) {
 		var slice = slices[layer];
 		
-		var outerLayer = slice.clone();
+		var layerData = [];
-		outerLayer.scaleUp(scale);
+		data.push(layerData);
 		
-		var insets = new D3D.Path();
+		var downSkin = new D3D.Paths();
-		for (var offset = wallThickness; offset <= shellThickness; offset += wallThickness) {
+		if (layer - skinCount >= 0) {
-			var inset = outerLayer.offset(-offset);
+			var downLayer = slices[layer - skinCount];
-
+			for (var i = 0; i < downLayer.length; i ++) {
-			insets.join(inset);
+				downSkin.join(downLayer[i]);
+			}
 		}
+		var upSkin = new D3D.Paths();
+		if (layer + skinCount < slices.length) {
+			var downLayer = slices[layer + skinCount];
+			for (var i = 0; i < downLayer.length; i ++) {
+				upSkin.join(downLayer[i]);
+			}
+		}
+		var surroundingLayer = upSkin.intersect(downSkin).clone().scaleUp(scale);
+		var sliceData = [];
 
-		var fillArea = (inset || outerLayer).offset(-wallThickness/2);
+		for (var i = 0; i < slice.length; i ++) {
+			var part = slice[i];
 
-		var downFill = (layer - skinCount >= 0) ? slices[layer - skinCount] : new D3D.Path();
+			var outerLayer = part.clone();
-		var upFill = (layer + skinCount < slices.length) ? slices[layer + skinCount] : new D3D.Path();
+			outerLayer.scaleUp(scale);
-		var highFillArea = fillArea.difference(downFill.intersect(upFill).scaleUp(scale));
 
-		var lowFillArea = fillArea.difference(highFillArea);
+			var insets = new D3D.Paths();
+			for (var offset = wallThickness; offset <= shellThickness; offset += wallThickness) {
+				var inset = outerLayer.offset(-offset);
+
+				insets.join(inset);
+			}
+
+			var fillArea = (inset || outerLayer).offset(-wallThickness/2);
+
+			var highFillArea = fillArea.difference(surroundingLayer);
+
+			var lowFillArea = fillArea.difference(highFillArea);
+
+			var fill = new D3D.Paths([]);
+
+			fill.join(lowFillTemplate.intersect(lowFillArea));
 
-		var fill = new D3D.Path([], false);
-		fill.join(lowFillTemplate.intersect(lowFillArea));
-		if (highFillArea.path.length > 0) {
 			var highFillTemplate = this.getFillTemplate(dimensionsZ, wallThickness, (layer % 2 === 0), (layer % 2 === 1));
 			fill.join(highFillTemplate.intersect(highFillArea));
-		}
 
-		data.push({
+			layerData.push({
-			outerLayer: outerLayer.scaleDown(scale), 
+				outerLayer: outerLayer.scaleDown(scale),
-			insets: insets.scaleDown(scale), 
+				fill: fill.scaleDown(scale),
-			fill: fill.scaleDown(scale)
+				insets: insets.scaleDown(scale)
-		});
+			});
+		}
 	}
 
 	return data;
@@ -972,7 +1011,7 @@ D3D.Slicer.prototype.slicesToData = function (slices, printer) {
 D3D.Slicer.prototype.getFillTemplate = function (dimension, size, even, uneven) {
 	"use strict";
 
-	var paths = [];
+	var paths = new D3D.Paths([], false);
 
 	if (even) {
 		for (var length = 0; length <= dimension; length += size) {
@@ -986,7 +1025,7 @@ D3D.Slicer.prototype.getFillTemplate = function (dimension, size, even, uneven)
 	}
 	
 	//return paths;
-	return new D3D.Path(paths, false);
+	return paths;
 };
 D3D.Slicer.prototype.dataToGcode = function (data, printer) {
 	"use strict";
@@ -1008,13 +1047,15 @@ D3D.Slicer.prototype.dataToGcode = function (data, printer) {
 	function sliceToGcode (slice) {
 		var gcode = [];
 
-		for (var i = 0; i < slice.path.length; i ++) {
+		for (var i = 0; i < slice.length; i ++) {
-			var shape = slice.path[i];
+			var shape = slice[i];
 
 			var previousPoint;
 
-			for (var j = 0; j < shape.length; j ++) {
+			var length = slice.closed ? (shape.length + 1) : shape.length;
-				var point = shape[j];
+
+			for (var j = 0; j < length; j ++) {
+				var point = shape[j % shape.length];
 
 				if (j === 0) {
 					//TODO
@@ -1082,9 +1123,13 @@ D3D.Slicer.prototype.dataToGcode = function (data, printer) {
 
 		var z = ((layer + 1) * layerHeight).toFixed(3);
 
-		gcode = gcode.concat(sliceToGcode(slice.outerLayer));
+		for (var i = 0; i < slice.length; i ++) {
-		gcode = gcode.concat(sliceToGcode(slice.insets));
+			var layerPart = slice[i];
-		gcode = gcode.concat(sliceToGcode(slice.fill));
+
+			gcode = gcode.concat(sliceToGcode(layerPart.outerLayer));
+			gcode = gcode.concat(sliceToGcode(layerPart.insets));
+			gcode = gcode.concat(sliceToGcode(layerPart.fill));
+		}
 	}
 
 	gcode = gcode.concat(printer.getEndCode());
@@ -1106,13 +1151,16 @@ D3D.Slicer.prototype.drawPaths = function (printer, min, max) {
 	canvas.height = 400;
 	var context = canvas.getContext("2d");
 
-
 	for (var layer = min; layer < max; layer ++) {
 		var slice = data[layer % data.length];
 
-		slice.insets.draw(context, "blue");
+		for (var i = 0; i < slice.length; i ++) {
-		slice.outerLayer.draw(context, "green");
+			var layerPart = slice[i];
-		slice.fill.draw(context, "red");
+
+			layerPart.insets.draw(context, "blue");
+			layerPart.outerLayer.draw(context, "green");
+			layerPart.fill.draw(context, "red");
+		}
 	}
 
 	return canvas;

gulpfile.js

@@ -11,7 +11,6 @@ var files = [
 	"src/box.js", 
 	"src/printer.js", 
 	"src/paths.js", 
-	"src/path.js", 
 	"src/slicer.js"
 ];
 

slice_test.html

@@ -12,7 +12,6 @@
 <script src="src/box.js"></script>
 <script src="src/printer.js"></script>
 <script src="src/paths.js"></script>
-<script src="src/path.js"></script>
 <script src="src/slicer.js"></script>
 
 <script src="gcode/testgcode.js"></script>
@@ -119,6 +118,31 @@ var loader = new THREE.STLLoader();
 loader.load("models/diamond.stl", function (geometry) {
 	var geometry = new THREE.BoxGeometry(10, 10, 10, 1, 1, 1);
 	//var geometry = new THREE.TorusGeometry(20, 10, 30, 30);
+
+	var geometry = (function () {
+		"use strict";
+
+		var circle = new THREE.Shape();
+		circle.absarc(0, 0, 10, 0, Math.PI*2, false);
+
+		var hole = new THREE.Path();
+		hole.absarc(0, 0, 5, 0, Math.PI*2, true );
+
+		circle.holes.push(hole);
+
+		var matrix = new THREE.Matrix4();
+		matrix.makeRotationX(Math.PI*1.5);
+
+		var geometry = new THREE.ExtrudeGeometry(circle, {
+			amount: 3, 
+			bevelEnabled: false, 
+			steps: 1
+		});
+		geometry.applyMatrix(matrix);
+
+		return geometry;
+	})();
+
 	var mesh = new THREE.Mesh(geometry, material);
 	
 	mesh.position.x = 100;
@@ -137,8 +161,8 @@ loader.load("models/diamond.stl", function (geometry) {
 	var canvas = document.getElementById("canvas");
 	var context = canvas.getContext("2d");
 
-	var img = slicer.drawPaths(printer, 0, 10);
+	//var img = slicer.drawPaths(printer, 7, 8);
-	context.drawImage(img, 0, 0);
+	//context.drawImage(img, 0, 0);
 
 	gcode = slicer.getGcode(printer);
 });

src/path.js

@@ -1,140 +0,0 @@
-/******************************************************
-*
-* Path
-*
-* Abstraction layer for annoying clipper js
-*
-******************************************************/
-
-D3D.Path = function (path, closed) {
-	"use strict";
-
-	Array.call(this);
-
-	this.setPath(path || []);
-
-	this.closed = (closed !== undefined) ? closed : true;
-};
-D3D.Path.prototype = Object.create(Array.prototype);
-D3D.Path.prototype.setPath = function (path) {
-	"use strict";
-
-	for (var i = 0; i < path.length; i ++) {
-		this.push(path[i]);
-	}
-
-	return this;
-};
-D3D.Path.prototype.clip = function (path, type) {
-	"use strict";
-
-	var solution = new ClipperLib.Paths();
-
-	var clipper = new ClipperLib.Clipper();
-	clipper.AddPath(this, ClipperLib.PolyType.ptSubject, true);
-	if (path instanceof D3D.Path) {
-		clipper.AddPath(path, ClipperLib.PolyType.ptClip, true);
-	}
-	else if (path instanceof D3D.Paths) {
-		clipper.AddPaths(path, ClipperLib.PolyType.ptClip, true);
-	}
-	clipper.Execute(type, solution);
-
-	return new D3D.Paths(solution, this.closed);
-};
-D3D.Path.prototype.union = function (path) {
-	"use strict";
-
-	return this.clip(path, ClipperLib.ClipType.ctUnion);
-};
-D3D.Path.prototype.difference = function (path) {
-	"use strict";
-
-	return this.clip(path, ClipperLib.ClipType.ctDifference);
-};
-D3D.Path.prototype.intersect = function (path) {
-	"use strict";
-
-	return this.clip(path, ClipperLib.ClipType.ctIntersection);
-};
-D3D.Path.prototype.xor = function () {
-	"use strict";
-
-	return this.clip(path, ClipperLib.ClipType.ctXor);
-};
-D3D.Path.prototype.offset = function (offset) {
-	"use strict";
-
-	var solution = new ClipperLib.Path();
-	var co = new ClipperLib.ClipperOffset(2, 0.25);
-	co.AddPath(this, ClipperLib.JoinType.jtRound, ClipperLib.EndType.etClosedPolygon);
-	co.Execute(solution, offset);
-
-	return new D3D.Path(solution[0], this.closed);
-};
-D3D.Path.prototype.scaleUp = function (factor) {
-	"use strict";
-
-	ClipperLib.JS.ScaleUpPath(this, factor);
-
-	return this;
-};
-D3D.Path.prototype.scaleDown = function (factor) {
-	"use strict";
-
-	var path = ClipperLib.JS.ScaleDownPath(this, factor);
-
-	return this;
-};
-D3D.Path.prototype.tresholdArea = function (minArea) {
-	"use strict";
-
-	for (var i = 0; i < this.length; i ++) {
-		var shape = this[i];
-
-		var area = ClipperLib.Clipper.Area(shape);
-
-		if (area < minArea) {
-			this.splice(i, 1);
-			i --;
-		}
-	}
-	
-	return areas;
-};
-D3D.Path.prototype.area = function () {
-	"use strict";
-
-	return ClipperLib.Clipper.Area(this);
-};
-D3D.Path.prototype.join = function (path) {
-	"use strict";
-
-	this.setPath(this.concat(path));
-
-	return this;
-}
-D3D.Path.prototype.clone = function () {
-	"use strict";
-
-	var path = ClipperLib.JS.Clone(this);
-
-	return new D3D.Path(path, this.closed);
-}
-D3D.Path.prototype.draw = function (context, color) {
-	"use strict";
-
-	context.strokeStyle = color;
-	for (var i = 0; i < this.length; i ++) {
-		var shape = this[i];
-
-		context.beginPath();
-		var length = this.closed ? (shape.length + 1) : shape.length;
-		for (var j = 0; j < length; j ++) {
-			var point = shape[j % shape.length];
-
-			context.lineTo(point.X*2, point.Y*2);
-		}
-		context.stroke();
-	}
-};

src/paths.js

@@ -6,14 +6,14 @@
 *
 ******************************************************/
 
-D3D.Paths = function (paths) {
+D3D.Paths = function (paths, closed) {
 	"use strict";
 
 	Array.call(this);
 
 	this.setPaths(paths || []);
 
-	this.closed = (this[0] !== undefined) ? this[0].closed : true;
+	this.closed = (closed !== undefined) ? closed : true;
 };
 D3D.Paths.prototype = Object.create(Array.prototype);
 D3D.Paths.prototype.setPaths = function (paths) {
@@ -21,10 +21,6 @@ D3D.Paths.prototype.setPaths = function (paths) {
 
 	for (var i = 0; i < paths.length; i ++) {
 		var path = paths[i];
-		if (!(path instanceof D3D.Path)) {
-			//console.log("Path not instance of D3D.Path, converting path to D3D.Path");
-			path = new D3D.Path(path, true);
-		}
 		this.push(path);
 	}
 
@@ -37,12 +33,7 @@ D3D.Paths.prototype.clip = function (path, type) {
 
 	var clipper = new ClipperLib.Clipper();
 	clipper.AddPaths(this, ClipperLib.PolyType.ptSubject, this.closed);
-	if (path instanceof D3D.Paths) {
+	clipper.AddPaths(path, ClipperLib.PolyType.ptClip, path.closed);
-		clipper.AddPaths(path, ClipperLib.PolyType.ptClip, path.closed);
-	}
-	else if (path instanceof D3D.Path) {
-		clipper.AddPath(path, ClipperLib.PolyType.ptClip, path.closed);
-	}
 	clipper.Execute(type, solution);
 
 	return new D3D.Paths(solution);
@@ -124,13 +115,19 @@ D3D.Paths.prototype.join = function (path) {
 D3D.Paths.prototype.clone = function () {
 	"use strict";
 
-	var paths = [];
+	return new D3D.Paths(ClipperLib.JS.Clone(this), this.closed);
+};
+D3D.Paths.prototype.bounds = function () {
+	"use strict";
 
-	for (var i = 0; i < this.length; i ++) {
+	return ClipperLib.Clipper.GetBounds(this);
-		paths.push(this[i].clone());
+};
-	}
+D3D.Paths.prototype.reverse = function () {
+	"use strict";
 
-	return new D3D.Paths(paths);
+	ClipperLib.Clipper.ReversePaths(this);
+
+	return this;
 };
 D3D.Paths.prototype.draw = function (context, color) {
 	"use strict";

src/slicer.js

@@ -65,7 +65,7 @@ D3D.Slicer.prototype.createLines = function () {
 	for (var i = 0; i < this.geometry.faces.length; i ++) {
 		var face = this.geometry.faces[i];
 
-		if (!(face.normal.y === 1 || face.normal.y === -1)) {
+		//if (face.normal.y !== 1 && face.normal.y !== -1) {
 			var normal = new THREE.Vector2().set(face.normal.x, face.normal.z).normalize();
 
 			//check for only adding unique lines
@@ -82,7 +82,7 @@ D3D.Slicer.prototype.createLines = function () {
 			this.lines[a].normals.push(normal);
 			this.lines[b].normals.push(normal);
 			this.lines[c].normals.push(normal);
-		}
+		//}
 	}
 };
 D3D.Slicer.prototype.slice = function (height, step) {
@@ -108,7 +108,7 @@ D3D.Slicer.prototype.slice = function (height, step) {
 
 	var slices = [];
 
-	for (var layer = 1; layer < layersIntersections.length; layer ++) {
+	for (var layer = 1; layer < layersIntersections.length-1; layer ++) {
 		var layerIntersections = layersIntersections[layer];
 		var y = layer*step;
 
@@ -130,7 +130,7 @@ D3D.Slicer.prototype.slice = function (height, step) {
 			var index = layerIntersections[i];
 
 			if (done.indexOf(index) === -1) {
-				var shape = new D3D.Path([], true);
+				var shape = [];
 
 				while (index !== -1) {
 					var intersection = intersections[index];
@@ -186,16 +186,34 @@ D3D.Slicer.prototype.slice = function (height, step) {
 
 				//think this check is not nescesary, always higher as 0
 				if (shape.length > 0) {
-					slice.push(shape);
+					slice.push(new D3D.Paths([shape]));
 				}
 			}
 		}
 
-		//stop when ther are no intersects
+		var layerParts = [];
-		if (slice.length > 0) {
-			var layerParts = [];
 
-			slices.push(slice);
+		for (var i = 0; i < slice.length; i ++) {
+			var layerPart1 = slice[i];
+			var merge = false;
+
+			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;
@@ -224,15 +242,25 @@ D3D.Slicer.prototype.slicesToData = function (slices, printer) {
 	for (var layer = 0; layer < slices.length; layer ++) {
 		var slice = slices[layer];
 		
-		var insets = new D3D.Paths();
+		var layerData = [];
-		var fills = new D3D.Paths();
+		data.push(layerData);
-		var outerLayers = new D3D.Paths();
 		
-		var downFill = (layer - skinCount >= 0) ? slices[layer - skinCount] : new D3D.Paths();
+		var downSkin = new D3D.Paths();
-		var upFill = (layer + skinCount < slices.length) ? slices[layer + skinCount] : new D3D.Paths();
+		if (layer - skinCount >= 0) {
-		//var surroundingLayer = downFill.intersect(upFill);
+			var downLayer = slices[layer - skinCount];
-		var surroundingLayer = upFill.clone().scaleUp(scale);
+			for (var i = 0; i < downLayer.length; i ++) {
-		//D3D.Paths surroundingLayer
+				downSkin.join(downLayer[i]);
+			}
+		}
+		var upSkin = new D3D.Paths();
+		if (layer + skinCount < slices.length) {
+			var downLayer = slices[layer + skinCount];
+			for (var i = 0; i < downLayer.length; i ++) {
+				upSkin.join(downLayer[i]);
+			}
+		}
+		var surroundingLayer = upSkin.intersect(downSkin).clone().scaleUp(scale);
+		var sliceData = [];
 
 		for (var i = 0; i < slice.length; i ++) {
 			var part = slice[i];
@@ -240,10 +268,11 @@ D3D.Slicer.prototype.slicesToData = function (slices, printer) {
 			var outerLayer = part.clone();
 			outerLayer.scaleUp(scale);
 
+			var insets = new D3D.Paths();
 			for (var offset = wallThickness; offset <= shellThickness; offset += wallThickness) {
 				var inset = outerLayer.offset(-offset);
 
-				insets.push(inset);
+				insets.join(inset);
 			}
 
 			var fillArea = (inset || outerLayer).offset(-wallThickness/2);
@@ -254,19 +283,17 @@ D3D.Slicer.prototype.slicesToData = function (slices, printer) {
 
 			var fill = new D3D.Paths([]);
 
-			fills.join(lowFillTemplate.intersect(lowFillArea));
+			fill.join(lowFillTemplate.intersect(lowFillArea));
 
 			var highFillTemplate = this.getFillTemplate(dimensionsZ, wallThickness, (layer % 2 === 0), (layer % 2 === 1));
-			fills.join(highFillTemplate.intersect(highFillArea));
+			fill.join(highFillTemplate.intersect(highFillArea));
 
-			outerLayers.push(outerLayer);
+			layerData.push({
+				outerLayer: outerLayer.scaleDown(scale),
+				fill: fill.scaleDown(scale),
+				insets: insets.scaleDown(scale)
+			});
 		}
-
-		data.push({
-			outerLayer: outerLayers.scaleDown(scale), 
-			insets: insets.scaleDown(scale), 
-			fill: fills.scaleDown(scale)
-		});
 	}
 
 	return data;
@@ -274,21 +301,21 @@ D3D.Slicer.prototype.slicesToData = function (slices, printer) {
 D3D.Slicer.prototype.getFillTemplate = function (dimension, size, even, uneven) {
 	"use strict";
 
-	var paths = [];
+	var paths = new D3D.Paths([], false);
 
 	if (even) {
 		for (var length = 0; length <= dimension; length += size) {
-			paths.push(new D3D.Path([{X: length, Y: 0}, {X: length, Y: dimension}], false));
+			paths.push([{X: length, Y: 0}, {X: length, Y: dimension}]);
 		}
 	}
 	if (uneven) {
 		for (var length = 0; length <= dimension; length += size) {
-			paths.push(new D3D.Path([{X: 0, Y: length}, {X: dimension, Y: length}], false));
+			paths.push([{X: 0, Y: length}, {X: dimension, Y: length}]);
 		}
 	}
 	
 	//return paths;
-	return new D3D.Paths(paths);
+	return paths;
 };
 D3D.Slicer.prototype.dataToGcode = function (data, printer) {
 	"use strict";
@@ -315,8 +342,10 @@ D3D.Slicer.prototype.dataToGcode = function (data, printer) {
 
 			var previousPoint;
 
-			for (var j = 0; j < shape.length; j ++) {
+			var length = slice.closed ? (shape.length + 1) : shape.length;
-				var point = shape[j];
+
+			for (var j = 0; j < length; j ++) {
+				var point = shape[j % shape.length];
 
 				if (j === 0) {
 					//TODO
@@ -384,9 +413,13 @@ D3D.Slicer.prototype.dataToGcode = function (data, printer) {
 
 		var z = ((layer + 1) * layerHeight).toFixed(3);
 
-		gcode = gcode.concat(sliceToGcode(slice.outerLayer));
+		for (var i = 0; i < slice.length; i ++) {
-		gcode = gcode.concat(sliceToGcode(slice.insets));
+			var layerPart = slice[i];
-		gcode = gcode.concat(sliceToGcode(slice.fill));
+
+			gcode = gcode.concat(sliceToGcode(layerPart.outerLayer));
+			gcode = gcode.concat(sliceToGcode(layerPart.insets));
+			gcode = gcode.concat(sliceToGcode(layerPart.fill));
+		}
 	}
 
 	gcode = gcode.concat(printer.getEndCode());
@@ -411,9 +444,13 @@ D3D.Slicer.prototype.drawPaths = function (printer, min, max) {
 	for (var layer = min; layer < max; layer ++) {
 		var slice = data[layer % data.length];
 
-		//slice.insets.draw(context, "blue");
+		for (var i = 0; i < slice.length; i ++) {
-		slice.outerLayer.draw(context, "green");
+			var layerPart = slice[i];
-		slice.fill.draw(context, "red");
+
+			layerPart.insets.draw(context, "blue");
+			layerPart.outerLayer.draw(context, "green");
+			layerPart.fill.draw(context, "red");
+		}
 	}
 
 	return canvas;
@@ -437,7 +474,6 @@ D3D.Slicer.prototype.getGcode = function (printer) {
 	var data = this.slicesToData(slices, printer);
 	var end = new Date().getTime();
 
-	console.log(data);
 	console.log("Data: " + (end - start) + "ms");
 
 	//return data;