path ops -- rewrite angle sort

src/pathops/SkPathOpsCubic.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkLineParameters.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
 #include "SkPathOpsQuad.h"
@@ skipping 385 matching lines @@
     double dx = dst[3].fX = interp_cubic_coords(&fPts[0].fX, t2);
     double dy = dst[3].fY = interp_cubic_coords(&fPts[0].fY, t2);
     double mx = ex * 27 - ax * 8 - dx;
     double my = ey * 27 - ay * 8 - dy;
     double nx = fx * 27 - ax - dx * 8;
     double ny = fy * 27 - ay - dy * 8;
     /* bx = */ dst[1].fX = (mx * 2 - nx) / 18;
     /* by = */ dst[1].fY = (my * 2 - ny) / 18;
     /* cx = */ dst[2].fX = (nx * 2 - mx) / 18;
     /* cy = */ dst[2].fY = (ny * 2 - my) / 18;
+    // FIXME: call align() ?
     return dst;
 }
 
+void SkDCubic::align(int endIndex, int ctrlIndex, SkDPoint* dstPt) const {  
+    if (fPts[endIndex].fX == fPts[ctrlIndex].fX) {
+        dstPt->fX = fPts[endIndex].fX;
+    }
+    if (fPts[endIndex].fY == fPts[ctrlIndex].fY) {
+        dstPt->fY = fPts[endIndex].fY;
+    }
+}
+
 void SkDCubic::subDivide(const SkDPoint& a, const SkDPoint& d,
                          double t1, double t2, SkDPoint dst[2]) const {
+    SkASSERT(t1 != t2);
+#if 0
     double ex = interp_cubic_coords(&fPts[0].fX, (t1 * 2 + t2) / 3);
     double ey = interp_cubic_coords(&fPts[0].fY, (t1 * 2 + t2) / 3);
     double fx = interp_cubic_coords(&fPts[0].fX, (t1 + t2 * 2) / 3);
     double fy = interp_cubic_coords(&fPts[0].fY, (t1 + t2 * 2) / 3);
     double mx = ex * 27 - a.fX * 8 - d.fX;
     double my = ey * 27 - a.fY * 8 - d.fY;
     double nx = fx * 27 - a.fX - d.fX * 8;
     double ny = fy * 27 - a.fY - d.fY * 8;
     /* bx = */ dst[0].fX = (mx * 2 - nx) / 18;
     /* by = */ dst[0].fY = (my * 2 - ny) / 18;
     /* cx = */ dst[1].fX = (nx * 2 - mx) / 18;
     /* cy = */ dst[1].fY = (ny * 2 - my) / 18;
+#else
+    // this approach assumes that the control points computed directly are accurate enough
+    SkDCubic sub = subDivide(t1, t2);
+    dst[0] = sub[1] + (a - sub[0]);
+    dst[1] = sub[2] + (d - sub[3]);
+#endif
+    if (t1 == 0 || t2 == 0) {
+        align(0, 1, t1 == 0 ? &dst[0] : &dst[1]);
+    }
+    if (t1 == 1 || t2 == 1) {
+        align(3, 2, t1 == 1 ? &dst[0] : &dst[1]);
+    }
+    if (precisely_subdivide_equal(dst[0].fX, a.fX)) {
+        dst[0].fX = a.fX;
+    }
+    if (precisely_subdivide_equal(dst[0].fY, a.fY)) {
+        dst[0].fY = a.fY;
+    }
+    if (precisely_subdivide_equal(dst[1].fX, d.fX)) {
+        dst[1].fX = d.fX;
+    }
+    if (precisely_subdivide_equal(dst[1].fY, d.fY)) {
+        dst[1].fY = d.fY;
+    }
 }
 
 /* classic one t subdivision */
 static void interp_cubic_coords(const double* src, double* dst, double t) {
     double ab = SkDInterp(src[0], src[2], t);
     double bc = SkDInterp(src[2], src[4], t);
     double cd = SkDInterp(src[4], src[6], t);
     double abc = SkDInterp(ab, bc, t);
     double bcd = SkDInterp(bc, cd, t);
     double abcd = SkDInterp(abc, bcd, t);
@@ skipping 21 matching lines @@
         dst.pts[4].fY = (fPts[1].fY + 2 * fPts[2].fY + fPts[3].fY) / 4;
         dst.pts[5].fX = (fPts[2].fX + fPts[3].fX) / 2;
         dst.pts[5].fY = (fPts[2].fY + fPts[3].fY) / 2;
         dst.pts[6] = fPts[3];
         return dst;
     }
     interp_cubic_coords(&fPts[0].fX, &dst.pts[0].fX, t);
     interp_cubic_coords(&fPts[0].fY, &dst.pts[0].fY, t);
     return dst;
 }