Fix simplify leaving way too small line segments.

src/slicer.cpp

@@ -1089,7 +1089,7 @@ coord_t Slicer::interpolate(const coord_t x, const coord_t x0, const coord_t x1,
 {
     const coord_t dx_01 = x1 - x0;
     coord_t num = (y1 - y0) * (x - x0);
-    num += num > 0 ? dx_01 / 2 : -dx_01 / 2; // add in offset to round result
+    num += num > 0 ? dx_01 / 4 : -dx_01 / 4; // add in offset to round result
     return y0 + num / dx_01;
 }
 

src/utils/polygon.cpp

@@ -295,6 +295,34 @@ Polygons ConstPolygonRef::offset(int distance, ClipperLib::JoinType join_type, d
     return ret;
 }
 
+bool lineLineIntersection(Point A, Point B, Point C, Point D, Point* output)
+{
+    // Line AB represented as a1x + b1y = c1
+    double a1 = B.Y - A.Y;
+    double b1 = A.X - B.X;
+    double c1 = a1*(A.X) + b1*(A.Y);
+
+    // Line CD represented as a2x + b2y = c2
+    double a2 = D.Y - C.Y;
+    double b2 = C.X - D.X;
+    double c2 = a2*(C.X)+ b2*(C.Y);
+
+    double determinant = a1 * b2 - a2 * b1;
+
+    if (determinant == 0)
+    {
+        // The lines are parallel
+        return false;
+    }
+    else
+    {
+        output->X = (b2 * c1 - b1 * c2) / determinant;
+        output->Y = (a1 * c2 - a2 * c1) / determinant;
+        return true;
+    }
+}
+
+
 void PolygonRef::simplify(const coord_t smallest_line_segment_squared, const coord_t allowed_error_distance_squared)
 {
     if (size() < 3)
@@ -309,6 +337,7 @@ void PolygonRef::simplify(const coord_t smallest_line_segment_squared, const coo
 
     ClipperLib::Path new_path;
     Point previous = path->back();
+    Point previous_previous = path->at(path->size() -3);
     Point current = path->at(0);
 
     /* When removing a vertex, we check the height of the triangle of the area
@@ -370,21 +399,58 @@ void PolygonRef::simplify(const coord_t smallest_line_segment_squared, const coo
         //h^2 = L^2 / b^2     [factor the divisor]
         const coord_t height_2 = area_removed_so_far * area_removed_so_far / base_length_2;
         if ((height_2 <= 1 //Almost exactly colinear (barring rounding errors).
-            && LinearAlg2D::getDist2FromLine(current, previous, next) <= 1) // make sure that height_2 is not small because of cancellation of positive and negative areas
-            || (length2 < smallest_line_segment_squared
-                && next_length2 < smallest_line_segment_squared // Segments are small
-                && height_2 <= allowed_error_distance_squared) // removing the vertex doesn't introduce too much error.
-        )
+            && LinearAlg2D::getDist2FromLine(current, previous, next) <= 1)) // make sure that height_2 is not small because of cancellation of positive and negative areas
         {
-            continue; //Remove the vertex.
+            continue;
+        }
+
+        if (length2 < smallest_line_segment_squared
+            && height_2 <= allowed_error_distance_squared) // removing the vertex doesn't introduce too much error.)
+        {
+            if (next_length2 > smallest_line_segment_squared)
+            {
+                // Special case; The next line is long. If we were to remove this, it could happen that we get quite noticeable artifacts.
+                // We should instead move this point to a location where both edges are kept and then remove the previous point that we wanted to keep.
+                // By taking the intersection of these two lines, we get a point that perseves the direction (so it makes the corner a bit more pointy)
+                Point intersection_point;
+                bool has_intersection = lineLineIntersection(previous_previous, previous, current, next, &intersection_point);
+
+                if (!has_intersection || LinearAlg2D::getDist2FromLine(intersection_point, previous, current) > allowed_error_distance_squared)
+                {
+                    if(length2 < 25)
+                    {
+                        // We're allowed to always delete segments of less than 5 micron.
+                        continue;
+                    }
+                    // We can't find a better spot for it, but the size of the line is more than 5 micron.
+                    // So the only thing we can do here is leave it in...
+                }
+                else
+                {
+                    // New point seems like a valid one.
+                    current = intersection_point;
+
+                    // If there was a previous point added, remove it.
+                    if(new_path.size() > 0)
+                    {
+                        new_path.pop_back();
+                    }
+                }
+            }
+            else
+            {
+                continue; //Remove the vertex.
+            }
         }
 
         //Don't remove the vertex.
-
         accumulated_area_removed = removed_area_next; // so that in the next iteration it's the area between the origin, [previous] and [current]
+        previous_previous = previous;
         previous = current; //Note that "previous" is only updated if we don't remove the vertex.
         new_path.push_back(current);
     }
+
+
     *path = new_path;
 }
 

src/utils/polygon.h

@@ -449,15 +449,19 @@ class PolygonRef : public ConstPolygonRef
     /*! 
      * Removes consecutive line segments with same orientation and changes this polygon.
      * 
-     * Removes verts which are connected to line segments which are both too small.
-     * Removes verts which detour from a direct line from the previous and next vert by a too small amount.
+     * 1. Removes verts which are connected to line segments which are too small.
+     * 2. Removes verts which detour from a direct line from the previous and next vert by a too small amount.
+     * 3. Moves a vert when a small line segment is connected to a much longer one. in order to maintain the outline of the object.
+     * 4. Don't remove a vert when the impact on the outline of the object is too great.
      *
-     * Criteria:
-     * 1. Never remove a vertex if either of the connceted segments is larger than \p smallest_line_segment
-     * 2. Never remove a vertex if the distance between that vertex and the final resulting polygon would be higher than \p allowed_error_distance
-     * 3. Simplify uses a heuristic and doesn't neccesarily remove all removable vertices under the above criteria.
-     * 4. But simplify may never violate these criteria.
-     * 5. Unless the segments or the distance is smaller than the rounding error of 5 micron
+     * Note that the simplify is a best effort algorithm. It does not guarantee that no lines below the provided smallest_line_segment_squared are left.
+     *
+     * The following example (Two very long line segments (" & , respectively) that are connected by a very small line segment (i) is unsimplifable by this
+     * function, even though the actual area change of removing line segment i is very small. The reason for this is that in the case of long lines, even a small
+     * deviation from it's original direction is very noticeable in the final result, especially if the polygons above make a slightly different choice.
+     *
+     * """"""""""""""""""""""""""""""""i,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+
      * 
      * \param smallest_line_segment_squared maximal squared length of removed line segments
      * \param allowed_error_distance_squared The square of the distance of the middle point to the line segment of the consecutive and previous point for which the middle point is removed

tests/utils/PolygonTest.cpp

@@ -335,6 +335,14 @@ TEST_F(PolygonTest, simplifyLimitedError)
         // apply simplify iteratively for each point until nothing is simplifiable any more
         spiral_polygons.simplify(10000, max_height);
     }
+
+    if (visualize)
+    {
+        SVG svg("output/simplifyLimitedError.svg", AABB(spiral_before));
+        svg.writePolygon(spiral_before);
+        svg.nextLayer();
+        svg.writePolygon(spiral, SVG::Color::RED);
+    }
 
     EXPECT_THAT(spiral.size(), testing::Eq(4)) << "Should simplify all spiral points except those connected to far away geometry.";
 }