update to trunk

(bzr r13708.1.21)

1 files changed, 307 insertions, 135 deletions

diff --git a/src/helper/geom-pathstroke.cpp b/src/helper/geom-pathstroke.cpp
index 1b8f90104..1908f2db7 100644
--- a/src/helper/geom-pathstroke.cpp
+++ b/src/helper/geom-pathstroke.cpp
@@ -6,11 +6,13 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#include <iomanip>
 #include <2geom/path-sink.h>
 #include <2geom/point.h>
 #include <2geom/bezier-curve.h>
 #include <2geom/svg-elliptical-arc.h>
 #include <2geom/sbasis-to-bezier.h> // cubicbezierpath_from_sbasis
+#include <2geom/path-intersection.h>
 
 #include "helper/geom-pathstroke.h"
 
@@ -18,6 +20,74 @@ namespace Geom {
 // 2geom/circle-circle.cpp, no header
 int circle_circle_intersection(Point X0, double r0, Point X1, double r1, Point &p0, Point &p1);
 
+/**
+ * Determine the intersection points between a circle C0 and a line defined
+ * by two points, X0 and X1.
+ *
+ * Which intersection point is assigned to p0 or p1 is unspecified, and callers
+ * should not depend on any particular intersection always being assigned to p0.
+ *
+ * Returns:
+ *   If the line and circle do not cross, 0 is returned.
+ *   If solution(s) exist, 2 is returned, and the results are written to p0 and p1.
+ */
+static int circle_line_intersection(Circle C0, Point X0, Point X1, Point &p0, Point &p1)
+{
+    /* equation of a circle: (x - h)^2 + (y - k)^2 = r^2 */
+    Coord r = C0.ray();
+    Coord h = C0.center()[X];
+    Coord k = C0.center()[Y];
+
+    Coord x0, y0;
+    Coord x1, y1;
+
+    if (are_near(X1[X], X0[X])) {
+        /* slope is undefined (vertical line) */
+        Coord c = X0[X];
+        Coord det = r*r - (c-h)*(c-h);
+
+        /* no intersection */
+        if (det < 0)
+            return 0;
+
+        /* solve for y */
+        y0 = k + std::sqrt(det);
+        y1 = k - std::sqrt(det);
+
+        // x == c (always)
+        x0 = c;
+        x1 = c;
+    } else {
+        /* equation of a line: y = mx + b */
+        Coord m = (X1[Y] - X0[Y]) / (X1[X] - X0[X]);
+        Coord b = X0[Y] - m*X0[X];
+
+        /* obtain quadratic for x: */
+        Coord A = m*m + 1;
+        Coord B = 2*h - 2*b*m + 2*k*m;
+        Coord C = b*b + h*h + k*k - r*r - 2*b*k;
+
+        Coord det = B*B - 4*A*C;
+        
+        /* no intersection, circle and line do not cross */
+        if (det < 0)
+            return 0;
+
+        /* solve quadratic */
+        x0 = (B + std::sqrt(det)) / (2*A);
+        x1 = (B - std::sqrt(det)) / (2*A);
+
+        /* substitute the calculated x times to determine the y values */
+        y0 = m*x0 + b;
+        y1 = m*x1 + b;
+    }
+
+    p0 = Point(x0, y0);
+    p1 = Point(x1, y1);
+
+    return 2;
+}
+
 static Point intersection_point(Point origin_a, Point vector_a, Point origin_b, Point vector_b)
 {
     Coord denom = cross(vector_b, vector_a);
@@ -57,122 +127,221 @@ static Circle touching_circle( D2<SBasis> const &curve, double t, double tol=0.0
 
 namespace {
 
+// Join functions may:
+// - inspect any curve of the current path
+// - append any type of curve to the current path
+// - inspect the outgoing path
+// 
+// Join functions must:
+// - append the outgoing curve
+// OR
+// - end at outgoing.finalPoint
+
 typedef void join_func(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width);
 
 void bevel_join(Geom::Path& res, Geom::Curve const& outgoing, double /*miter*/, double /*width*/)
 {
     res.appendNew<Geom::LineSegment>(outgoing.initialPoint());
+    res.append(outgoing);
 }
 
 void round_join(Geom::Path& res, Geom::Curve const& outgoing, double /*miter*/, double width)
 {
     res.appendNew<Geom::SVGEllipticalArc>(width, width, 0, false, width <= 0, outgoing.initialPoint());
+    res.append(outgoing);
 }
 
-void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width)
+void miter_join_internal(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width, bool clip)
 {
     Geom::Curve const& incoming = res.back();
     Geom::Point tang1 = Geom::unitTangentAt(reverse(incoming.toSBasis()), 0.);
     Geom::Point tang2 = outgoing.unitTangentAt(0);
     Geom::Point p = Geom::intersection_point(incoming.finalPoint(), tang1, outgoing.initialPoint(), tang2);
+
+    bool satisfied = false;
+
     if (p.isFinite()) {
         // check size of miter
-        Geom::Point point_on_path = incoming.finalPoint() - Geom::rot90(tang1)*width;
-        double len = Geom::distance(p, point_on_path);
-        if (len <= miter) {
+        Geom::Point point_on_path = incoming.finalPoint() + Geom::rot90(tang1)*width;
+        satisfied = Geom::distance(p, point_on_path) <= miter * 2.0 * width;
+        if (satisfied) {
             // miter OK, check to see if we can do a relocation
-            // TODO FIXME
-            /*if (auto line = cast(const(LineSegment))res.back_open) {
-                Curve copy = line.duplicate;
-                copy.setFinal(p);
-                res.erase_last();
-                res.append(copy);
-            } else {*/
+            bool ls = res.back_open().degreesOfFreedom() <= 4;
+            if (ls) {
+                res.setFinal(p);
+            } else {
                 res.appendNew<Geom::LineSegment>(p);
-            //}
+            }
+        } else if (clip) {
+            // miter needs clipping, find two points
+            Geom::Line bisector(point_on_path, p);
+            Geom::Point point_limit = point_on_path + miter * 2.0 * width * bisector.versor();
+
+            Geom::Line line_limit =
+                Geom::Line::from_origin_and_versor( point_limit, bisector.versor().cw() );
+
+            Geom::Line incoming_line( incoming.finalPoint(), p );
+            Geom::Line outgoing_line( p, outgoing.initialPoint() );
+
+            Geom::OptCrossing i1 = intersection( line_limit, incoming_line );
+            Geom::OptCrossing i2 = intersection( line_limit, outgoing_line );
+
+            // It would be nice to have a simple point returned by intersection!
+            Geom::Point p1 = line_limit.pointAt( (*i1).ta );
+            Geom::Point p2 = line_limit.pointAt( (*i2).ta );
+            
+            bool ls = res.back_open().degreesOfFreedom() <= 4;
+            if (ls) {
+                res.setFinal(p1);
+            } else {
+                res.appendNew<Geom::LineSegment>(p1);
+            }
+            res.appendNew<Geom::LineSegment>(p2);
         }
     }
+
     res.appendNew<Geom::LineSegment>(outgoing.initialPoint());
+
+    // check if we can do another relocation
+    bool ls = outgoing.degreesOfFreedom() <= 4;
+
+    if ( (satisfied || clip) && ls) {
+        res.setFinal(outgoing.finalPoint());
+    } else {
+        res.append(outgoing);
+    }
+}
+
+void miter_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width) {
+    miter_join_internal( res, outgoing, miter, width, false );
+}
+
+void miter_clip_join(Geom::Path& res, Geom::Curve const& outgoing, double miter, double width) {
+    miter_join_internal( res, outgoing, miter, width, true );
+}
+
+Geom::Point pick_solution(Geom::Point points[2], Geom::Point tang2, Geom::Point endPt)
+{
+    Geom::Point sol;
+    if ( dot(tang2,points[0]-endPt) > 0 ) {
+        // points[0] is bad, choose points[1]
+        sol = points[1];
+    } else if ( dot(tang2,points[1]-endPt) > 0 ) { // points[0] could be good, now check points[1]
+        // points[1] is bad, choose points[0]
+        sol = points[0];
+    } else {
+        // both points are good, choose nearest
+        sol = ( distanceSq(endPt, points[0]) < distanceSq(endPt, points[1]) ) ? points[0] : points[1];
+    }
+    return sol;
 }
 
-// might need a little reworking
 void extrapolate_join(Geom::Path& path_builder, Geom::Curve const& outgoing, double miter_limit, double line_width)
 {
     using namespace Geom;
     Geom::Curve const& incoming = path_builder.back();
     Geom::Point endPt = outgoing.initialPoint();
+    Geom::Point tang2 = Geom::unitTangentAt(outgoing.toSBasis(), 0);
+
+    Geom::Circle circle1 = Geom::touching_circle(Geom::reverse(incoming.toSBasis()), 0.);
+    Geom::Circle circle2 = Geom::touching_circle(outgoing.toSBasis(), 0);
 
-    // The method used when extrapolating curves fails to work when either side of the join to be extrapolated
-    // is a line segment. When this situation is encountered, fall back to a regular miter join.
-    bool lineProblem = (dynamic_cast<LineSegment const *>(&incoming)) || (dynamic_cast<LineSegment const*>(&outgoing));
-    if (lineProblem == false) {
-        // Geom::Point tang1 = Geom::unitTangentAt(Geom::reverse(incoming.toSBasis()), 0.);
-        Geom::Point tang2 = Geom::unitTangentAt(outgoing.toSBasis(), 0);
+    bool inc_ls = !circle1.center().isFinite();
+    bool out_ls = !circle2.center().isFinite();
 
-        Geom::Circle circle1 = Geom::touching_circle(Geom::reverse(incoming.toSBasis()), 0.);
-        Geom::Circle circle2 = Geom::touching_circle(outgoing.toSBasis(), 0);
+    Geom::Point points[2];
 
-        Geom::Point points[2];
-        int solutions = Geom::circle_circle_intersection(circle1.center(), circle1.ray(),
-                                                         circle2.center(), circle2.ray(),
-                                                         points[0], points[1]);
+    int solutions = 0;
+    Geom::EllipticalArc *arc0 = NULL;
+    Geom::EllipticalArc *arc1 = NULL;
+
+    if (!inc_ls && !out_ls) {
+        solutions = Geom::circle_circle_intersection(circle1.center(), circle1.ray(),
+                                                     circle2.center(), circle2.ray(),
+                                                     points[0], points[1]);
         if (solutions == 2) {
-            Geom::Point sol(0,0);
-            if ( dot(tang2,points[0]-endPt) > 0 ) {
-                // points[0] is bad, choose points[1]
-                sol = points[1];
-            } else if ( dot(tang2,points[1]-endPt) > 0 ) { // points[0] could be good, now check points[1]
-                // points[1] is bad, choose points[0]
-                sol = points[0];
-            } else {
-                // both points are good, choose nearest
-                sol = ( distanceSq(endPt, points[0]) < distanceSq(endPt, points[1]) ) ? points[0] : points[1];
-            }
+            Geom::Point sol = pick_solution(points, tang2, endPt);
 
-            Geom::EllipticalArc *arc0 = circle1.arc(incoming.finalPoint(), 0.5*(incoming.finalPoint()+sol), sol, true);
-            Geom::EllipticalArc *arc1 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true);
-            try {
-                if (arc0) {
-                    path_builder.append(*arc0);
-                    delete arc0;
-                    arc0 = NULL;
-                } else { 
-                    throw std::exception();
-                }
-
-                if (arc1) {
-                    path_builder.append(*arc1);
-                    delete arc1;
-                    arc1 = NULL;
-                } else {
-                    throw std::exception();
-                }
-
-            } catch (std::exception const & ex) {
-                printf("WARNING: Error extrapolating line join: %s\n", ex.what());
-                path_builder.appendNew<Geom::LineSegment>(endPt);
-            }
-        } else {
-            // 1 or no solutions found, default to miter
-            miter_join(path_builder, outgoing, miter_limit, line_width);
+            arc0 = circle1.arc(incoming.finalPoint(), 0.5*(incoming.finalPoint()+sol), sol, true);
+            arc1 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true);
+        }
+    } else if (inc_ls && !out_ls) {
+        solutions = Geom::circle_line_intersection(circle2, incoming.initialPoint(), incoming.finalPoint(), points[0], points[1]);
+
+        if (solutions == 2) {
+            Geom::Point sol = pick_solution(points, tang2, endPt);
+            path_builder.setFinal(sol);
+            arc1 = circle2.arc(sol, 0.5*(sol+endPt), endPt, true);
+        }
+    } else if (!inc_ls && out_ls) {
+        solutions = Geom::circle_line_intersection(circle1, outgoing.initialPoint(), outgoing.finalPoint(), points[0], points[1]);
+        
+        if (solutions == 2) {
+            Geom::Point sol = pick_solution(points, tang2, endPt);
+            arc0 = circle1.arc(incoming.finalPoint(), 0.5*(sol+incoming.finalPoint()), sol, true);
         }
-    } else {
-        // Line segments exist
-        miter_join(path_builder, outgoing, miter_limit, line_width);
     }
+
+    if (solutions != 2)
+        // no solutions available, fall back to miter
+        return miter_join(path_builder, outgoing, miter_limit, line_width);
+
+    if (arc0)
+        path_builder.append(*arc0);
+    if (arc1)
+        path_builder.append(*arc1);
+
+    delete arc0;
+    delete arc1;
+
+    if (!inc_ls && out_ls)
+        path_builder.appendNew<Geom::LineSegment>(outgoing.finalPoint());
+    else
+        path_builder.append(outgoing);
 }
 
 void join_inside(Geom::Path& res, Geom::Curve const& outgoing)
 {
-    res.appendNew<Geom::LineSegment>(outgoing.initialPoint());
+    Geom::Curve const& incoming = res.back_open();
+    Geom::Crossings cross = Geom::crossings(incoming, outgoing);
+    
+    if (!cross.empty()) {
+        // yeah if we could avoid allocing that'd be great
+        Geom::Curve *d1 = incoming.portion(0., cross[0].ta);
+        res.erase_last();
+        res.append(*d1);
+        delete d1;
+
+        Geom::Curve *d2 = outgoing.portion(cross[0].tb, 1.);
+        res.setFinal(d2->initialPoint());
+        res.append(*d2);
+        delete d2;
+    } else {
+        res.appendNew<Geom::LineSegment>(outgoing.initialPoint());
+        res.append(outgoing);
+    }
 }
 
 void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, double miter, Inkscape::LineJoinType join)
 {
-    Geom::Point tang1 = -Geom::unitTangentAt(reverse(res.back().toSBasis()), 0.);
-    //Geom::Point tang2 = to_add[0].unitTangentAt(0);
-    Geom::Point discontinuity_vec = to_add.initialPoint() - res.finalPoint();
-    bool on_outside = (Geom::dot(tang1, discontinuity_vec) >= 0);
+    if (res.size() == 0 || to_add.size() == 0)
+        return;
+
+    Geom::Curve const& outgoing = to_add[0];
+    if (Geom::are_near(res.finalPoint(), outgoing.initialPoint())) {
+        // if the points are /that/ close, just ignore this one
+        res.setFinal(outgoing.initialPoint());
+        res.append(outgoing);
+        return;
+    }
+
+    Geom::Point tang1 =  Geom::unitTangentAt(reverse(res.back().toSBasis()), 0.);
+    Geom::Point tang2 =  Geom::unitTangentAt(to_add.front().toSBasis(), 0.);
+    // Geom::Point discontinuity_vec = to_add.initialPoint() - res.finalPoint();
+    bool on_outside = (Geom::cross(tang1, tang2) < 0);
+    // std::cout << std::fixed << std::setprecision(3)
+    //           << "  in: " << tang1 << "  out: " << tang2
+    //           << "  side: " << (on_outside?"inside":"outside") << std::endl;
 
     if (on_outside) {
         join_func *jf;
@@ -186,15 +355,16 @@ void outline_helper(Geom::Path& res, Geom::Path const& to_add, double width, dou
             case Inkscape::JOIN_EXTRAPOLATE:
                 jf = &extrapolate_join;
                 break;
+            case Inkscape::JOIN_MITER_CLIP:
+                jf = &miter_clip_join;
+                break;
             default:
                 jf = &miter_join;
         }
-        jf(res, to_add[0], miter, width);
+        jf(res, outgoing, miter, width);
     } else {
-        join_inside(res, to_add[0]);
+        join_inside(res, outgoing);
     }
-
-    res.append(to_add);
 }
 
 // Offsetting a line segment is mathematically stable and quick to do
@@ -324,9 +494,11 @@ void offset_quadratic(Geom::Path& p, Geom::QuadraticBezier const& bez, double wi
 
 void offset_curve(Geom::Path& res, Geom::Curve const* current, double width)
 {
-    double const tolerance = 0.0025;
+    double const tolerance = 0.005;
     size_t levels = 8;
 
+    if (current->isDegenerate()) return; // don't do anything
+
     // TODO: we can handle SVGEllipticalArc here as well, do that!
 
     if (Geom::BezierCurve const *b = dynamic_cast<Geom::BezierCurve const*>(current)) {
@@ -346,7 +518,7 @@ void offset_curve(Geom::Path& res, Geom::Curve const* current, double width)
                 break;
             }
             default: {
-                Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(current->toSBasis(), 0.1);
+                Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(current->toSBasis(), tolerance);
                 for (size_t i = 0; i < sbasis_path.size(); ++i)
                     offset_curve(res, &sbasis_path[i], width);
                 break;
@@ -359,8 +531,40 @@ void offset_curve(Geom::Path& res, Geom::Curve const* current, double width)
     }
 }
 
+typedef void cap_func(Geom::PathBuilder& res, Geom::Path const& with_dir, Geom::Path const& against_dir, double width);
+
+void flat_cap(Geom::PathBuilder& res, Geom::Path const&, Geom::Path const& against_dir, double)
+{
+    res.lineTo(against_dir.initialPoint());
+}
+
+void round_cap(Geom::PathBuilder& res, Geom::Path const&, Geom::Path const& against_dir, double width)
+{
+    res.arcTo(width / 2., width / 2., 0., true, false, against_dir.initialPoint());
+}
+
+void square_cap(Geom::PathBuilder& res, Geom::Path const& with_dir, Geom::Path const& against_dir, double width)
+{
+    width /= 2.;
+    Geom::Point normal_1 = -Geom::unitTangentAt(Geom::reverse(with_dir.back().toSBasis()), 0.);
+    Geom::Point normal_2 = -against_dir[0].unitTangentAt(0.);
+    res.lineTo(with_dir.finalPoint() + normal_1*width);
+    res.lineTo(against_dir.initialPoint() + normal_2*width);
+    res.lineTo(against_dir.initialPoint());
+}
+
+void peak_cap(Geom::PathBuilder& res, Geom::Path const& with_dir, Geom::Path const& against_dir, double width)
+{
+    width /= 2.;
+    Geom::Point normal_1 = -Geom::unitTangentAt(Geom::reverse(with_dir.back().toSBasis()), 0.);
+    Geom::Point normal_2 = -against_dir[0].unitTangentAt(0.);
+    Geom::Point midpoint = ((with_dir.finalPoint() + normal_1*width) + (against_dir.initialPoint() + normal_2*width)) * 0.5;
+    res.lineTo(midpoint);
+    res.lineTo(against_dir.initialPoint());
 }
 
+} // namespace
+
 namespace Inkscape {
 
 Geom::PathVector outline(Geom::Path const& input, double width, double miter, LineJoinType join, LineCapType butt)
@@ -374,67 +578,36 @@ Geom::PathVector outline(Geom::Path const& input, double width, double miter, Li
     res.moveTo(with_dir[0].initialPoint());
     res.append(with_dir);
 
+    cap_func *cf;
+    switch (butt) {
+        case BUTT_ROUND:
+            cf = &round_cap;
+            break;
+        case BUTT_SQUARE:
+            cf = &square_cap;
+            break;
+        case BUTT_PEAK:
+            cf = &peak_cap;
+            break;
+        default:
+            cf = &flat_cap;
+    }
+
     // glue caps
     if (!input.closed()) {
-        switch (butt) {
-            case BUTT_ROUND:
-                res.arcTo(width / 2., width / 2., 0., true, false, against_dir.initialPoint());
-                break;
-            case BUTT_SQUARE: {
-                Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(input[input.size()-1].toSBasis()), 0.);
-                double radius = 0.5 * Geom::distance(with_dir.finalPoint(), against_dir.initialPoint());
-                res.lineTo(with_dir.finalPoint() + end_deriv*radius);
-                res.lineTo(against_dir.initialPoint() + end_deriv*radius);
-                res.lineTo(against_dir.initialPoint());
-                break;
-            }
-            case BUTT_PEAK: {
-                Geom::Point end_deriv = -Geom::unitTangentAt(Geom::reverse(input[input.size()-1].toSBasis()), 0.);
-                double radius = 0.5 * Geom::distance(with_dir.finalPoint(), against_dir.initialPoint());
-                Geom::Point midpoint = ((with_dir.finalPoint() + against_dir.initialPoint()) * 0.5) + end_deriv*radius;
-                res.lineTo(midpoint);
-                res.lineTo(against_dir.initialPoint());
-                break;
-            }
-            case BUTT_FLAT:
-            default:
-                res.lineTo(against_dir.initialPoint());
-                break;
-        }
+        cf(res, with_dir, against_dir, width);
     } else {
+        res.closePath();
         res.moveTo(against_dir.initialPoint());
     }
 
     res.append(against_dir);
 
     if (!input.closed()) {
-        switch(butt) {
-            case BUTT_ROUND:
-                res.arcTo(width / 2., width / 2., 0., true, false, with_dir.initialPoint());
-                break;
-            case BUTT_SQUARE: {
-                Geom::Point end_deriv = -input[0].unitTangentAt(0.);
-                double radius = 0.5 * Geom::distance(against_dir.finalPoint(), with_dir.initialPoint());
-                res.lineTo(against_dir.finalPoint() + end_deriv*radius);
-                res.lineTo(with_dir.initialPoint() + end_deriv*radius);
-                res.lineTo(with_dir.initialPoint());
-                break;
-            }
-            case BUTT_PEAK: {
-                Geom::Point end_deriv = -input[0].unitTangentAt(0.);
-                double radius = 0.5 * Geom::distance(against_dir.finalPoint(), with_dir.initialPoint());
-                Geom::Point midpoint = ((against_dir.finalPoint() + with_dir.initialPoint()) * 0.5) + end_deriv*radius;
-                res.lineTo(midpoint);
-                res.lineTo(with_dir.initialPoint());
-                break;
-            }
-            case BUTT_FLAT:
-            default:
-                res.lineTo(with_dir.initialPoint());
-        }
-        res.closePath();
+        cf(res, against_dir, with_dir, width);
     }
 
+    res.closePath();
     res.flush();
     return res.peek();
 }
@@ -451,7 +624,8 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin
     res.start(start);
 
     // Do two curves at a time for efficiency, since the join function needs to know the outgoing curve as well
-    const size_t k = input.size_default();
+    const size_t k = (input.back_closed().isDegenerate() && input.closed())
+            ?input.size_default()-1:input.size_default();
     for (size_t u = 0; u < k; u += 2) {
         temp = Geom::Path();
 
@@ -462,6 +636,8 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin
             res.append(temp);
         } else {
             outline_helper(res, temp, width, miter, join);
+            if (temp.size() > 0)
+                res.insert(res.end(), ++temp.begin(), temp.end());
         }
 
         // odd number of paths
@@ -469,15 +645,12 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin
             temp = Geom::Path();
             offset_curve(temp, &input[u+1], width);
             outline_helper(res, temp, width, miter, join);
+            if (temp.size() > 0)
+                res.insert(res.end(), ++temp.begin(), temp.end());
         }
     }
 
     if (input.closed()) {
-        if (input.back_closed().isDegenerate()) {
-            res.erase_last();
-            res.erase_last(); // ?
-        }
-
         Geom::Curve const &c1 = res.back();
         Geom::Curve const &c2 = res.front();
         temp = Geom::Path();
@@ -485,9 +658,8 @@ Geom::Path half_outline(Geom::Path const& input, double width, double miter, Lin
         Geom::Path temp2;
         temp2.append(c2);
         outline_helper(temp, temp2, width, miter, join);
-        temp.erase_last(); // we already outlined c2
-        temp.erase(temp.begin()); // we already outlined c1
-
+        res.erase(res.begin());
+        res.erase_last();
         //
         res.append(temp);
         res.close();