From: <adr...@us...> - 2011-05-11 10:08:00
|
Revision: 4128 http://reprap.svn.sourceforge.net/reprap/?rev=4128&view=rev Author: adrian-bowyer Date: 2011-05-11 10:07:53 +0000 (Wed, 11 May 2011) Log Message: ----------- Implementation of Rhys's idea to join up polygons whose ends nearly match (within 2*filament-thickness). It also joins closed polygons which have any pair of points closer too. Tested, but experimental. Probably works best if you turn Middle Starts off for all extruders. Modified Paths: -------------- trunk/software/host/src/org/reprap/geometry/Producer.java trunk/software/host/src/org/reprap/geometry/polygons/RrPolygon.java trunk/software/host/src/org/reprap/geometry/polygons/RrPolygonList.java trunk/software/host/src/org/reprap/machines/GCodeRepRap.java Modified: trunk/software/host/src/org/reprap/geometry/Producer.java =================================================================== --- trunk/software/host/src/org/reprap/geometry/Producer.java 2011-05-09 08:46:20 UTC (rev 4127) +++ trunk/software/host/src/org/reprap/geometry/Producer.java 2011-05-11 10:07:53 UTC (rev 4128) @@ -265,6 +265,7 @@ } RrPolygonList allPolygons[] = new RrPolygonList[totalPhysicalExtruders]; + RrPolygonList tempPolygons[] = new RrPolygonList[totalPhysicalExtruders]; boolean firstTimeRound = true; @@ -300,7 +301,9 @@ fills = fills.cullShorts(); shield = false; RrPolygonList support = allSTLs.computeSupport(stl, layerRules); - borders = borders.nearEnds(startNearHere, false, -1); + /* + borders = borders.nearEnds(startNearHere, false, -1); + if(borders.size() > 0) { RrPolygon last = borders.polygon(borders.size() - 1); @@ -318,24 +321,43 @@ RrPolygon last = support.polygon(support.size() - 1); startNearHere = last.point(last.size() - 1); } + */ + for(int physicalExtruder = 0; physicalExtruder < allPolygons.length; physicalExtruder++) + tempPolygons[physicalExtruder] = new RrPolygonList(); for(int pol = 0; pol < borders.size(); pol++) { //shield = false; RrPolygon p = borders.polygon(pol); - allPolygons[p.getAttributes().getExtruder().getPhysicalExtruderNumber()].add(p); + tempPolygons[p.getAttributes().getExtruder().getPhysicalExtruderNumber()].add(p); } for(int pol = 0; pol < fills.size(); pol++) { //shield = false; RrPolygon p = fills.polygon(pol); - allPolygons[p.getAttributes().getExtruder().getPhysicalExtruderNumber()].add(p); + tempPolygons[p.getAttributes().getExtruder().getPhysicalExtruderNumber()].add(p); } for(int pol = 0; pol < support.size(); pol++) { //shield = false; RrPolygon p = support.polygon(pol); - allPolygons[p.getAttributes().getExtruder().getPhysicalExtruderNumber()].add(p); + tempPolygons[p.getAttributes().getExtruder().getPhysicalExtruderNumber()].add(p); } + for(int physicalExtruder = 0; physicalExtruder < allPolygons.length; physicalExtruder++) + { + if(tempPolygons[physicalExtruder].size() > 0) + { + double linkUp = tempPolygons[physicalExtruder].polygon(0).getAttributes().getExtruder().getExtrusionSize(); + linkUp = (4*linkUp*linkUp); + tempPolygons[physicalExtruder].radicalReOrder(linkUp); + tempPolygons[physicalExtruder] = tempPolygons[physicalExtruder].nearEnds(startNearHere, false, -1); + if(tempPolygons[physicalExtruder].size() > 0) + { + RrPolygon last = tempPolygons[physicalExtruder].polygon(tempPolygons[physicalExtruder].size() - 1); + startNearHere = last.point(last.size() - 1); + } + allPolygons[physicalExtruder].add(tempPolygons[physicalExtruder]); + } + } } Modified: trunk/software/host/src/org/reprap/geometry/polygons/RrPolygon.java =================================================================== --- trunk/software/host/src/org/reprap/geometry/polygons/RrPolygon.java 2011-05-09 08:46:20 UTC (rev 4127) +++ trunk/software/host/src/org/reprap/geometry/polygons/RrPolygon.java 2011-05-11 10:07:53 UTC (rev 4128) @@ -129,49 +129,23 @@ private int extrudeEnd; /** + * The squared distance from the end of the polygon of the extrude end + */ + private double extrudeEndDistance2; + + /** * The index of the last point at which the valve (if any) is open. */ private int valveEnd; /** - * Destroy me and all that I point to + * The squared distance from the end of the polygon of the valve end */ -// public void destroy() -// { -// if(beingDestroyed) // Prevent infinite loop -// return; -// beingDestroyed = true; -// -// if(speeds != null) -// { -// for(int i = 0; i < size(); i++) -// speeds.set(i, null); -// } -// speeds = null; -// -// if(points != null) -// { -// for(int i = 0; i < size(); i++) -// { -// points.get(i).destroy(); -// points.set(i, null); -// } -// } -// points = null; -// -// if(box != null) -// box.destroy(); -// box = null; -// -// // Don't destroy the attribute - that may still be needed -// -// //if(att != null) -// // att.destroy(); -// att = null; -// beingDestroyed = false; -// } + private double valveEndDistance2; + + /** * Make an empty polygon */ @@ -186,10 +160,28 @@ closed = c; extrudeEnd = -1; valveEnd = -1; + extrudeEndDistance2 = 0; + valveEndDistance2 = 0; pa = null; } /** + * Set the polygon as closed + */ + public void setClosed() + { + closed = true; + } + + /** + * Set the polygon not closed + */ + public void setOpen() + { + closed = false; + } + + /** * Get the data * @param i * @return i-th point object of polygon @@ -257,6 +249,31 @@ } /** + * Something has been done to the polygon that may require its + * extrude and valve endings to be updated + */ + private void updateExtrudeValveEnd() + { + if(extrudeEnd >= 0) + { + if(extrudeEndDistance2 <= 0) + { + extrudeEnd = -1; + extrudeEndDistance2 = 0; + return; + } + double d2 = 0; + System.out.println("Updating e..."); + } + if(valveEnd >= 0) + { + System.out.println("Updating v..."); + } + // if speeds are set, interpolate + } + + + /** * What's the last point to plot to? * @return */ @@ -308,6 +325,8 @@ closed = p.closed; extrudeEnd = p.extrudeEnd; valveEnd = p.valveEnd; + extrudeEndDistance2 = p.extrudeEndDistance2; + valveEndDistance2 = p.valveEndDistance2; if(p.pa != null) pa = new PolygonAttributes(p.pa); else @@ -334,6 +353,7 @@ Debug.e("Rr2Point.add(): adding a point to a polygon with its speeds set."); points.add(new Rr2Point(p)); box.expand(p); + updateExtrudeValveEnd(); } /** @@ -345,12 +365,20 @@ { if(speeds != null) Debug.e("Rr2Point.add(): adding a point to a polygon with its speeds set."); + points.add(i, new Rr2Point(p)); box.expand(p); + boolean update = false; if(i <= extrudeEnd) extrudeEnd++; + else + update = true; if(i <= valveEnd) valveEnd++; + else + update = true; + if(update) + updateExtrudeValveEnd(); } /** @@ -364,6 +392,7 @@ Debug.e("Rr2Point.set(): adding a point to a polygon with its speeds set."); points.set(i, new Rr2Point(p)); box.expand(p); // Note if the old point was on the convex hull, and the new one is within, box will be too big after this + updateExtrudeValveEnd(); } /** @@ -375,14 +404,24 @@ public void add(int i, Rr2Point p, double s) { if(speeds == null) + { Debug.e("Rr2Point.add(): adding a point and a speed to a polygon without its speeds set."); + return; + } points.add(i, new Rr2Point(p)); speeds.add(i, s); box.expand(p); + boolean update = false; if(i <= extrudeEnd) extrudeEnd++; + else + update = true; if(i <= valveEnd) valveEnd++; + else + update = true; + if(update) + updateExtrudeValveEnd(); } /** @@ -398,6 +437,7 @@ points.set(i, new Rr2Point(p)); speeds.set(i, s); box.expand(p); // Note if the old point was on the convex hull, and the new one is within, box will be too big after this + updateExtrudeValveEnd(); } /** @@ -421,18 +461,20 @@ * Eet the last point to plot to * @param d */ - public void setExtrudeEnd(int d) + public void setExtrudeEnd(int d, double d2) { extrudeEnd = d; + extrudeEndDistance2 = d2; } /** * Eet the last point to valve-open to * @param d */ - public void setValveEnd(int d) + public void setValveEnd(int d, double d2) { valveEnd = d; + valveEndDistance2 = d2; } /** @@ -471,13 +513,8 @@ if(extrudeEnd >= 0 || valveEnd >= 0) Debug.e("Rr2Point.add(): adding a polygon to another polygon with its extrude or valve ending set."); for(int i = 0; i < p.size(); i++) - { - if(i == p.extrudeEnd) - extrudeEnd = size(); - if(i == p.valveEnd) - valveEnd = size(); points.add(new Rr2Point(p.point(i))); - } + box.expand(p.box); if(speeds == null) { @@ -494,6 +531,7 @@ { speeds.add(new Double(p.speed(i))); } + updateExtrudeValveEnd(); } /** @@ -511,30 +549,17 @@ { Debug.e("Rr2Point.add(): attempt to add a polygon to another polygon when one has speeds and the other doesn't."); return; - } - if(k <= extrudeEnd || k <= valveEnd) - Debug.e("Rr2Point.add(): adding a polygon to another polygon with its extrude or valve ending set."); - int de = -1; - int dv = -1; - if (extrudeEnd >= 0) - de = extrudeEnd + p.size(); - if (valveEnd >= 0) - dv = valveEnd + p.size(); + } for(int i = 0; i < p.size(); i++) { - if(i == p.extrudeEnd) - extrudeEnd = size(); - if(i == p.valveEnd) - valveEnd = size(); if(speeds != null) add(k, new Rr2Point(p.point(i)), p.speed(i)); else points.add(k, new Rr2Point(p.point(i))); k++; } - extrudeEnd = Math.max(extrudeEnd, de); - valveEnd = Math.max(valveEnd, dv); box.expand(p.box); + updateExtrudeValveEnd(); } /** @@ -585,8 +610,6 @@ */ public RrPolygon negate() { - if(extrudeEnd >= 0 || valveEnd >= 0) - Debug.e("Rr2Point.negate(): negating a polygon with its extrude or valve ending set."); RrPolygon result = new RrPolygon(att, closed); for(int i = size() - 1; i >= 0; i--) { @@ -598,6 +621,9 @@ { result.setSpeed(i, speed(i)); } + result.setExtrudeEnd(extrudeEnd, extrudeEndDistance2); + result.setValveEnd(valveEnd, valveEndDistance2); + result.updateExtrudeValveEnd(); return result; } @@ -606,8 +632,6 @@ */ public RrPolygon randomStart() { - if(extrudeEnd >= 0 || valveEnd >= 0) - Debug.e("Rr2Point.randomStart(: randomizing a polygon with its extrude or valve ending set."); return newStart(rangen.nextInt(size())); } @@ -618,8 +642,7 @@ { if(!isClosed()) Debug.e("RrPolygon.newStart(i): reordering an open polygon!"); - if(extrudeEnd >= 0 || valveEnd >= 0) - Debug.e("Rr2Point.newStart(i): reordering a polygon with its extrude or valve ending set."); + if(i < 0 || i >= size()) { Debug.e("RrPolygon.newStart(i): dud index: " + i); @@ -635,7 +658,9 @@ if(i >= size()) i = 0; } - + result.setExtrudeEnd(extrudeEnd, extrudeEndDistance2); + result.setValveEnd(valveEnd, valveEndDistance2); + result.updateExtrudeValveEnd(); return result; } @@ -646,8 +671,6 @@ { if(size() == 0 || lc.getModelLayer() < 0) return this; - if(extrudeEnd >= 0 || valveEnd >= 0) - Debug.e("Rr2Point.incrementedStart(): incrementing a polygon with its extrude or valve ending set."); int i = lc.getModelLayer() % size(); return newStart(i); } @@ -690,8 +713,7 @@ { if(!p.isClosed()) Debug.e("RrPolygon.nearestVertexReorder(): called for non-closed polygon."); - if(extrudeEnd >= 0 || p.extrudeEnd >= 0 || valveEnd >= 0 || p.valveEnd >= 0) - Debug.e("Rr2Point.nearestVertexReorderMerge(): merging polygons with a extrude or valve ending set."); + double d = Double.POSITIVE_INFINITY; int myPoint = -1; int itsPoint = -1; @@ -711,6 +733,7 @@ RrPolygon ro = p.newStart(itsPoint); ro.add(0, point(myPoint)); add(myPoint, ro); + updateExtrudeValveEnd(); return true; } else return false; @@ -809,7 +832,7 @@ /** * Backtrack a given distance, inserting a new point there and set extrudeEnd to it. - * If drawEnd is already set, backtrack from that. + * If extrudeEnd is already set, backtrack from that. * @param distance to backtrack * @return index of the inserted point */ @@ -822,9 +845,15 @@ int start, last; if(extrudeEnd >= 0) + { start = extrudeEnd; - else - start = size() - 1; + extrudeEndDistance2 = Math.sqrt(extrudeEndDistance2) + d; + extrudeEndDistance2 *= extrudeEndDistance2; + } else + { + start = size() - 1; + extrudeEndDistance2 = d*d; + } if(!isClosed() && extrudeEnd < 0) start--; @@ -872,7 +901,7 @@ /** * Backtrack a given distance, inserting a new point there and set valveEnd to it. - * If drawEnd is already set, backtrack from that. + * If valveEnd is already set, backtrack from that. * @param distance to backtrack * @return index of the inserted point */ @@ -885,9 +914,15 @@ int start, last; if(valveEnd >= 0) + { start = valveEnd; - else - start = size() - 1; + valveEndDistance2 = Math.sqrt(valveEndDistance2) + d; + valveEndDistance2 *= valveEndDistance2; + } else + { + start = size() - 1; + valveEndDistance2 = d*d; + } if(!isClosed() && valveEnd < 0) start--; Modified: trunk/software/host/src/org/reprap/geometry/polygons/RrPolygonList.java =================================================================== --- trunk/software/host/src/org/reprap/geometry/polygons/RrPolygonList.java 2011-05-09 08:46:20 UTC (rev 4127) +++ trunk/software/host/src/org/reprap/geometry/polygons/RrPolygonList.java 2011-05-11 10:07:53 UTC (rev 4128) @@ -703,7 +703,7 @@ * This is a heuristic - it does not do a full travelling salesman... * This deals with both open and closed polygons, but it only allows closed ones to * be re-ordered if reOrder is true. If any point on a closed polygon is closer to - * any point on any other than linkUp, the two polygons are merged at their closest + * any point on any other than sqrt(linkUp), the two polygons are merged at their closest * points. This is suppressed by setting linkUp negative. * * @param startNearHere @@ -841,6 +841,174 @@ } /** + * Take all the polygons in a list, both open and closed, and reorder them such that + * accessible points on any that have a squared distance less than linkUp to accessible + * points on any others are joined to form single polygons. + * + * For an open polygon the accessible points are just its ends. For a closed polygon + * all its points are accessible. + * + * This is a fairly radical remove in-air movement strategy. + * + * All the polygons in the list must be plotted with the same physical extruder (otherwise + * it would be nonsense to join them). It is the calling function's responsibility to + * make sure this is the case. + * + * @param linkUp + */ + public void radicalReOrder(double linkUp) + { + if(size() < 2) + return; + + // First check that we all have the same physical extruder + + int physicalExtruder = polygon(0).getAttributes().getExtruder().getPhysicalExtruderNumber(); + for(int i = 1; i < size(); i++) + if(polygon(i).getAttributes().getExtruder().getPhysicalExtruderNumber() != physicalExtruder) + { + Debug.e("RrPolygonList.radicalReOrder(): more than one physical extruder needed by the list!"); + return; + } + + // Now go through the polygons pairwise + + for(int i = 0; i < size() - 1; i++) + { + RrPolygon myPolygon = polygon(i); + for(int j = i+1; j < size(); j++) + { + double d = Double.POSITIVE_INFINITY; + double d2; + int myPoint = -1; + int itsPoint = -1; + int myTempPoint, itsTempPoint; + boolean reverseMe, reverseIt; + RrPolygon itsPolygon = polygon(j); + + // Swap the odd half of the asymmetric cases so they're all the same + + if(!myPolygon.isClosed() && itsPolygon.isClosed()) + { + polygons.set(i, itsPolygon); + polygons.set(j, myPolygon); + myPolygon = polygon(i); + itsPolygon = polygon(j); + } + + // Three possibilities ... + + if(!myPolygon.isClosed() && !itsPolygon.isClosed()) + { + // ... both open + // Just compare the four ends + + reverseMe = true; + reverseIt = false; + d = Rr2Point.dSquared(myPolygon.point(0), itsPolygon.point(0)); + + d2 = Rr2Point.dSquared(myPolygon.point(myPolygon.size() - 1), itsPolygon.point(0)); + if(d2 < d) + { + reverseMe = false; + reverseIt = false; + d = d2; + } + + d2 = Rr2Point.dSquared(myPolygon.point(0), itsPolygon.point(itsPolygon.size() - 1)); + if(d2 < d) + { + reverseMe = true; + reverseIt = true; + d = d2; + } + + d2 = Rr2Point.dSquared(myPolygon.point(myPolygon.size() - 1), itsPolygon.point(itsPolygon.size() - 1)); + if(d2 < d) + { + reverseMe = false; + reverseIt = true; + d = d2; + } + + if(d < linkUp) + { + if(reverseMe) + myPolygon = myPolygon.negate(); + if(reverseIt) + itsPolygon = itsPolygon.negate(); + myPolygon.add(itsPolygon); + polygons.set(i, myPolygon); + polygons.remove(j); + } + + } else if(myPolygon.isClosed() && !itsPolygon.isClosed()) + { + // ... I'm closed; it's open + // Compare all my points with its two ends + + reverseIt = false; + myPoint = myPolygon.nearestVertex(itsPolygon.point(0)); + d = Rr2Point.dSquared(myPolygon.point(myPoint), itsPolygon.point(0)); + myTempPoint = myPolygon.nearestVertex(itsPolygon.point(itsPolygon.size() - 1)); + d2 = Rr2Point.dSquared(myPolygon.point(myTempPoint), itsPolygon.point(itsPolygon.size() -1 )); + if(d2 < d) + { + myPoint = myTempPoint; + reverseIt = true; + d = d2; + } + + if(d < linkUp) + { + myPolygon = myPolygon.newStart(myPoint); + myPolygon.add(myPolygon.point(0)); // Make sure the first half really is closed + if(reverseIt) + itsPolygon = itsPolygon.negate(); + myPolygon.add(itsPolygon); + myPolygon.setOpen(); // We were closed, but we must now be open + polygons.set(i, myPolygon); + polygons.remove(j); + } + + } else if(myPolygon.isClosed() && itsPolygon.isClosed()) + { + // ... both closed + // Compare all my points with all its points + + for(int k = 0; k < itsPolygon.size(); k++) + { + myTempPoint = myPolygon.nearestVertex(itsPolygon.point(k)); + d2 = Rr2Point.dSquared(myPolygon.point(myTempPoint), itsPolygon.point(k)); + if(d2 < d) + { + myPoint = myTempPoint; + itsPoint = k; + d = d2; + } + } + + if(d < linkUp) + { + myPolygon = myPolygon.newStart(myPoint); + myPolygon.add(myPolygon.point(0)); // Make sure we come back to the start + itsPolygon = itsPolygon.newStart(itsPoint); + myPolygon.add(itsPolygon); + myPolygon.setOpen(); // We were closed, but we must now be open + polygons.set(i, myPolygon); + polygons.remove(j); + } + + } else + { + // ... Horrible impossibility + Debug.e("RrPolygonList.radicalReOrder(): Polygons are neither closed nor open!"); + } + } + } + } + + /** * Remove polygon pol from the list, replacing it with two polygons, the * first being pol's vertices from 0 to st inclusive, and the second being * pol's vertices from en to its end inclusive. It is permissible for @@ -884,11 +1052,13 @@ * Search a polygon list to find the nearest point on all the polygons within it * to the point p. If omit is non-negative, ignore that polygon in the search. * + * Only polygons with the same physical extruder are compared. + * * @param p * @param omit * @return */ - private PolPoint ppSearch(Rr2Point p, int omit) + private PolPoint ppSearch(Rr2Point p, int omit, int physicalExtruder) { double d = Double.POSITIVE_INFINITY; PolPoint result = null; @@ -901,28 +1071,31 @@ if(i != omit) { RrPolygon pgon = polygon(i); - int n = pgon.nearestVertex(p); - double d2 = Rr2Point.dSquared(p, pgon.point(n)); - if(d2 < d) + if(physicalExtruder == pgon.getAttributes().getExtruder().getPhysicalExtruderNumber()) { - if(result == null) - result = new PolPoint(n, i, pgon, d2); - else - result.set(n, i, pgon, d2); - d = d2; + int n = pgon.nearestVertex(p); + double d2 = Rr2Point.dSquared(p, pgon.point(n)); + if(d2 < d) + { + if(result == null) + result = new PolPoint(n, i, pgon, d2); + else + result.set(n, i, pgon, d2); + d = d2; + } } } } if(result == null) - Debug.e("RrPolygonList.ppSearch(): no point found!"); + Debug.d("RrPolygonList.ppSearch(): no point found!"); return result; } /** - * This assumes that the RrPolygonList for which it is called is all the outline + * This assumes that the RrPolygonList for which it is called is all the closed outline * polygons, and that hatching is their infill hatch. It goes through the outlines * and the hatch modifying both so that that outlines actually start and end half-way * along a hatch line (that half of the hatch line being deleted). When the outlines @@ -931,6 +1104,8 @@ * The outline polygons are re-ordered before the start so that their first point is * the most extreme one in the current hatch direction. * + * Only hatches and outlines whose physical extruders match are altered. + * * @param hatching * @param lc */ @@ -948,7 +1123,7 @@ outline = outline.newStart(outline.maximalVertex(l)); Rr2Point start = outline.point(0); - PolPoint pp = hatching.ppSearch(start, -1); + PolPoint pp = hatching.ppSearch(start, -1, outline.getAttributes().getExtruder().getPhysicalExtruderNumber()); boolean failed = true; if(pp != null) { @@ -972,7 +1147,7 @@ if(slice.membership(pq1) & slice.membership(pq2) & slice.membership(pq3)) { outline.add(start); - outline.setExtrudeEnd(outline.size() - 1); + outline.setExtrudeEnd(-1, 0); if(en >= st) { Modified: trunk/software/host/src/org/reprap/machines/GCodeRepRap.java =================================================================== --- trunk/software/host/src/org/reprap/machines/GCodeRepRap.java 2011-05-09 08:46:20 UTC (rev 4127) +++ trunk/software/host/src/org/reprap/machines/GCodeRepRap.java 2011-05-11 10:07:53 UTC (rev 4128) @@ -95,7 +95,7 @@ if(xyFeedrate < feedrate) { - Debug.e("GCodeRepRap().qXYMove: feedrate (" + feedrate + ") exceeds maximum (" + xyFeedrate + ")."); + Debug.d("GCodeRepRap().qXYMove: feedrate (" + feedrate + ") exceeds maximum (" + xyFeedrate + ")."); feedrate = xyFeedrate; } @@ -150,7 +150,7 @@ if(zFeedrate < feedrate) { - Debug.e("GCodeRepRap().qZMove: feedrate (" + feedrate + ") exceeds maximum (" + zFeedrate + ")."); + Debug.d("GCodeRepRap().qZMove: feedrate (" + feedrate + ") exceeds maximum (" + zFeedrate + ")."); feedrate = zFeedrate; } @@ -218,7 +218,7 @@ boolean xyMove = dx!= 0 || dy != 0; if(zMove && xyMove) - Debug.e("GcodeRepRap.moveTo(): attempt to move in X|Y and Z simultaneously: (x, y, z) = (" + x + ", " + y + ", " + z + ")"); + Debug.d("GcodeRepRap.moveTo(): attempt to move in X|Y and Z simultaneously: (x, y, z) = (" + x + ", " + y + ", " + z + ")"); double zFeedrate = round(getMaxFeedrateZ(), 1); @@ -232,12 +232,20 @@ qFeedrate(feedrate); } - if(xyMove) - qXYMove(x, y, feedrate); + if(dz > 0) + { + if(zMove) + qZMove(z, feedrate); + if(xyMove) + qXYMove(x, y, feedrate); + } else + { + if(xyMove) + qXYMove(x, y, feedrate); + if(zMove) + qZMove(z, feedrate); + } - if(zMove) - qZMove(z, feedrate); - if(endUp && !startUp) { qZMove(liftedZ, zFeedrate); @@ -273,7 +281,7 @@ boolean xyMove = dx != 0 || dy != 0; if(zMove && xyMove) - Debug.e("GcodeRepRap.singleMove(): attempt to move in X|Y and Z simultaneously: (x, y, z) = (" + x + ", " + y + ", " + z + ")"); + Debug.d("GcodeRepRap.singleMove(): attempt to move in X|Y and Z simultaneously: (x, y, z) = (" + x + ", " + y + ", " + z + ")"); try { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |