Menu
▾
▴
[reprap-commits] SF.net SVN: reprap:[4128] trunk/software/host/src/org/reprap
|
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.
|
