path ops -- rewrite angle sort

src/pathops/SkLineParameters.h

 /*
  * 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 "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
 #include "SkPathOpsQuad.h"
 
 // Sources
 // computer-aided design - volume 22 number 9 november 1990 pp 538 - 549
 // online at http://cagd.cs.byu.edu/~tom/papers/bezclip.pdf
 
 // This turns a line segment into a parameterized line, of the form
 // ax + by + c = 0
 // When a^2 + b^2 == 1, the line is normalized.
 // The distance to the line for (x, y) is d(x,y) = ax + by + c
 //
 // Note that the distances below are not necessarily normalized. To get the true
 // distance, it's necessary to either call normalize() after xxxEndPoints(), or
 // divide the result of xxxDistance() by sqrt(normalSquared())
 
 class SkLineParameters {
 public:
     void cubicEndPoints(const SkDCubic& pts) {
-        cubicEndPoints(pts, 0, 3);
+        cubicEndPoints(pts, 0, 1);
+        if (dx() == 0 && dy() == 0) {
+            cubicEndPoints(pts, 0, 2);
+            if (dx() == 0 && dy() == 0) {
+                cubicEndPoints(pts, 0, 3);
+            }
+        }
     }
 
     void cubicEndPoints(const SkDCubic& pts, int s, int e) {
-        a = approximately_pin(pts[s].fY - pts[e].fY);
-        b = approximately_pin(pts[e].fX - pts[s].fX);
+        a = pts[s].fY - pts[e].fY;
+        b = pts[e].fX - pts[s].fX;
         c = pts[s].fX * pts[e].fY - pts[e].fX * pts[s].fY;
     }
 
     void lineEndPoints(const SkDLine& pts) {
-        a = approximately_pin(pts[0].fY - pts[1].fY);
-        b = approximately_pin(pts[1].fX - pts[0].fX);
+        a = pts[0].fY - pts[1].fY;
+        b = pts[1].fX - pts[0].fX;
         c = pts[0].fX * pts[1].fY - pts[1].fX * pts[0].fY;
     }
 
     void quadEndPoints(const SkDQuad& pts) {
-        quadEndPoints(pts, 0, 2);
+        quadEndPoints(pts, 0, 1);
+        if (dx() == 0 && dy() == 0) {
+            quadEndPoints(pts, 0, 2);
+        }
     }
 
     void quadEndPoints(const SkDQuad& pts, int s, int e) {
-        a = approximately_pin(pts[s].fY - pts[e].fY);
-        b = approximately_pin(pts[e].fX - pts[s].fX);
+        a = pts[s].fY - pts[e].fY;
+        b = pts[e].fX - pts[s].fX;
         c = pts[s].fX * pts[e].fY - pts[e].fX * pts[s].fY;
     }
 
     double normalSquared() const {
         return a * a + b * b;
     }
 
     bool normalize() {
         double normal = sqrt(normalSquared());
         if (approximately_zero(normal)) {
@@ skipping 42 matching lines @@
 
     double dy() const {
         return -a;
     }
 
 private:
     double a;
     double b;
     double c;
 };