Fix repeated point quads/cubics in convex pr and update convexpaths GM

gm/convexpaths.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "gm.h"
 #include "SkRandom.h"
 #include "SkTArray.h"
@@ skipping 30 matching lines @@
 
     virtual SkISize onISize() {
         return make_isize(1200, 1100);
     }
 
     void makePaths() {
         if (fOnce.alreadyDone()) {
             return;
         }
         fOnce.accomplished();
-        // CW

[bsalomon, 2013/08/13 15:21:21]

When the convex PR was first written it was useful to have all these CW and CCW
paths. After this change there are still paths that wind each way, just not
paths that are identical other than their winding.

+
         fPaths.push_back().moveTo(0, 0);
         fPaths.back().quadTo(50 * SK_Scalar1, 100 * SK_Scalar1,
                              0, 100 * SK_Scalar1);
         fPaths.back().lineTo(0, 0);
 
-        // CCW
-        fPaths.push_back().moveTo(0, 0);
-        fPaths.back().lineTo(0, 100 * SK_Scalar1);
-        fPaths.back().quadTo(50 * SK_Scalar1, 100 * SK_Scalar1,
-                             0, 0);
-
-        // CW
         fPaths.push_back().moveTo(0, 50 * SK_Scalar1);
         fPaths.back().quadTo(50 * SK_Scalar1, 0,
                              100 * SK_Scalar1, 50 * SK_Scalar1);
         fPaths.back().quadTo(50 * SK_Scalar1, 100 * SK_Scalar1,
                              0, 50 * SK_Scalar1);
 
-        // CCW
-        fPaths.push_back().moveTo(0, 50 * SK_Scalar1);
-        fPaths.back().quadTo(50 * SK_Scalar1, 100 * SK_Scalar1,
-                             100 * SK_Scalar1, 50 * SK_Scalar1);
-        fPaths.back().quadTo(50 * SK_Scalar1, 0,
-                             0, 50 * SK_Scalar1);
-
         fPaths.push_back().addRect(0, 0,
                                    100 * SK_Scalar1, 100 * SK_Scalar1,
                                    SkPath::kCW_Direction);
 
         fPaths.push_back().addRect(0, 0,
                                    100 * SK_Scalar1, 100 * SK_Scalar1,
                                    SkPath::kCCW_Direction);
 
         fPaths.push_back().addCircle(50  * SK_Scalar1, 50  * SK_Scalar1,
                                      50  * SK_Scalar1, SkPath::kCW_Direction);
 
-        fPaths.push_back().addCircle(50  * SK_Scalar1, 50  * SK_Scalar1,
-                                     40  * SK_Scalar1, SkPath::kCCW_Direction);
 
         fPaths.push_back().addOval(SkRect::MakeXYWH(0, 0,
                                                     50 * SK_Scalar1,
                                                     100 * SK_Scalar1),
                                    SkPath::kCW_Direction);
 
         fPaths.push_back().addOval(SkRect::MakeXYWH(0, 0,
                                                     100 * SK_Scalar1,
-                                                    50 * SK_Scalar1),
-                                   SkPath::kCCW_Direction);
-
-        fPaths.push_back().addOval(SkRect::MakeXYWH(0, 0,
-                                                    100 * SK_Scalar1,
                                                     5 * SK_Scalar1),
                                    SkPath::kCCW_Direction);
 
         fPaths.push_back().addOval(SkRect::MakeXYWH(0, 0,
                                                     SK_Scalar1,
                                                     100 * SK_Scalar1),
-                                   SkPath::kCCW_Direction);
+                                                    SkPath::kCCW_Direction);
 
         fPaths.push_back().addRoundRect(SkRect::MakeXYWH(0, 0,
                                                          SK_Scalar1 * 100,
                                                          SK_Scalar1 * 100),
                                         40 * SK_Scalar1, 20 * SK_Scalar1,
                                         SkPath::kCW_Direction);
 
-        fPaths.push_back().addRoundRect(SkRect::MakeXYWH(0, 0,
-                                                         SK_Scalar1 * 100,
-                                                         SK_Scalar1 * 100),
-                                        20 * SK_Scalar1, 40 * SK_Scalar1,
-                                        SkPath::kCCW_Direction);
-
         // large number of points
         enum {
             kLength = 100,
             kPtsPerSide = (1 << 12),
         };
         fPaths.push_back().moveTo(0, 0);
         for (int i = 1; i < kPtsPerSide; ++i) { // skip the first point due to moveTo.
             fPaths.back().lineTo(kLength * SkIntToScalar(i) / kPtsPerSide, 0);
         }
         for (int i = 0; i < kPtsPerSide; ++i) {
             fPaths.back().lineTo(kLength, kLength * SkIntToScalar(i) / kPtsPerSide);
         }
         for (int i = kPtsPerSide; i > 0; --i) {
             fPaths.back().lineTo(kLength * SkIntToScalar(i) / kPtsPerSide, kLength);
         }
         for (int i = kPtsPerSide; i > 0; --i) {
             fPaths.back().lineTo(0, kLength * SkIntToScalar(i) / kPtsPerSide);
         }
 
         // shallow diagonals
         fPaths.push_back().lineTo(100 * SK_Scalar1, SK_Scalar1);
         fPaths.back().lineTo(98 * SK_Scalar1, 100 * SK_Scalar1);
         fPaths.back().lineTo(3 * SK_Scalar1, 96 * SK_Scalar1);
 
-        //It turns out arcTos are not automatically marked as convex and they

[bsalomon, 2013/08/13 15:21:21]

no longer true

-        //may in fact be ever so slightly concave.
-        //fPaths.push_back().arcTo(SkRect::MakeXYWH(0, 0,
-        //                                          50 * SK_Scalar1,
-        //                                          100 * SK_Scalar1),
-        //                         25 * SK_Scalar1,  130 * SK_Scalar1, false);
+        fPaths.push_back().arcTo(SkRect::MakeXYWH(0, 0,
+                                                  50 * SK_Scalar1,
+                                                  100 * SK_Scalar1),
+                                                  25 * SK_Scalar1,  130 * SK_Scalar1, false);
 
         // cubics
         fPaths.push_back().cubicTo( 1 * SK_Scalar1,  1 * SK_Scalar1,
                                    10 * SK_Scalar1,  90 * SK_Scalar1,
                                     0 * SK_Scalar1, 100 * SK_Scalar1);
         fPaths.push_back().cubicTo(100 * SK_Scalar1,  50 * SK_Scalar1,
                                     20 * SK_Scalar1, 100 * SK_Scalar1,
                                      0 * SK_Scalar1,   0 * SK_Scalar1);
 
         // path that has a cubic with a repeated first control point and
@@ skipping 41 matching lines @@
                               20 * SK_Scalar1, SK_Scalar1,
                               30 * SK_Scalar1, 0);
 
         // triangle where one edge is a degenerate quad
         fPaths.push_back().moveTo(SkFloatToScalar(8.59375f), 45 * SK_Scalar1);
         fPaths.back().quadTo(SkFloatToScalar(16.9921875f),   45 * SK_Scalar1,
                              SkFloatToScalar(31.25f),        45 * SK_Scalar1);
         fPaths.back().lineTo(100 * SK_Scalar1,              100 * SK_Scalar1);
         fPaths.back().lineTo(SkFloatToScalar(8.59375f),      45 * SK_Scalar1);
 
-        // point degenerate
+        // triangle where one edge is a quad with a repeated point
+        fPaths.push_back().moveTo(0, 25 * SK_Scalar1);
+        fPaths.back().lineTo(50 * SK_Scalar1, 0);
+        fPaths.back().quadTo(50 * SK_Scalar1, 50 * SK_Scalar1, 50 * SK_Scalar1, 50 * SK_Scalar1);
+
+        // triangle where one edge is a cubic with a 3x repeated point
+        fPaths.push_back().moveTo(0, 25 * SK_Scalar1);
+        fPaths.back().lineTo(50 * SK_Scalar1, 0);
+        fPaths.back().cubicTo(50 * SK_Scalar1, 0,
+                              50 * SK_Scalar1, 50 * SK_Scalar1,
+                              50 * SK_Scalar1, 50 * SK_Scalar1);
+
+        // triangle where one edge is a quad with a nearly repeated point
+        fPaths.push_back().moveTo(0, 25 * SK_Scalar1);
+        fPaths.back().lineTo(50 * SK_Scalar1, 0);
+        fPaths.back().quadTo(50 * SK_Scalar1, SkFloatToScalar(49.95f),
+                             50 * SK_Scalar1, 50 * SK_Scalar1);
+
+        // triangle where one edge is a cubic with a 2x nearly repeated point
+        fPaths.push_back().moveTo(0, 25 * SK_Scalar1);
+        fPaths.back().lineTo(50 * SK_Scalar1, 0);
+        fPaths.back().cubicTo(50 * SK_Scalar1, SkFloatToScalar(49.95f),
+                              50 * SK_Scalar1, SkFloatToScalar(49.97f),
+                              50 * SK_Scalar1, 50 * SK_Scalar1);
+
+        // point line
         fPaths.push_back().moveTo(50 * SK_Scalar1, 50 * SK_Scalar1);
         fPaths.back().lineTo(50 * SK_Scalar1, 50 * SK_Scalar1);
 
+        // point quad
         fPaths.push_back().moveTo(50 * SK_Scalar1, 50 * SK_Scalar1);
         fPaths.back().quadTo(50 * SK_Scalar1, 50 * SK_Scalar1,
                              50 * SK_Scalar1, 50 * SK_Scalar1);
+
+        // point cubic
         fPaths.push_back().moveTo(50 * SK_Scalar1, 50 * SK_Scalar1);
         fPaths.back().cubicTo(50 * SK_Scalar1, 50 * SK_Scalar1,
                               50 * SK_Scalar1, 50 * SK_Scalar1,
                               50 * SK_Scalar1, 50 * SK_Scalar1);
 
         // moveTo only paths
         fPaths.push_back().moveTo(0, 0);
         fPaths.back().moveTo(0, 0);
         fPaths.back().moveTo(SK_Scalar1, SK_Scalar1);
         fPaths.back().moveTo(SK_Scalar1, SK_Scalar1);
         fPaths.back().moveTo(10 * SK_Scalar1, 10 * SK_Scalar1);
 
         fPaths.push_back().moveTo(0, 0);
         fPaths.back().moveTo(0, 0);
 
         // line degenerate
         fPaths.push_back().lineTo(100 * SK_Scalar1, 100 * SK_Scalar1);
         fPaths.push_back().quadTo(100 * SK_Scalar1, 100 * SK_Scalar1, 0, 0);
         fPaths.push_back().quadTo(100 * SK_Scalar1, 100 * SK_Scalar1,
                                   50 * SK_Scalar1, 50 * SK_Scalar1);
         fPaths.push_back().quadTo(50 * SK_Scalar1, 50 * SK_Scalar1,
                                   100 * SK_Scalar1, 100 * SK_Scalar1);
         fPaths.push_back().cubicTo(0, 0,
                                    0, 0,
                                    100 * SK_Scalar1, 100 * SK_Scalar1);
 
         // small circle. This is listed last so that it has device coords far
         // from the origin (small area relative to x,y values).
-        fPaths.push_back().addCircle(0, 0, SkFloatToScalar(0.8f));
+        fPaths.push_back().addCircle(0, 0, SkFloatToScalar(1.2f));
     }
 
     virtual void onDraw(SkCanvas* canvas) {
         this->makePaths();
 
     SkPaint paint;
     paint.setAntiAlias(true);
     SkRandom rand;
     canvas->translate(20 * SK_Scalar1, 20 * SK_Scalar1);
+
+    // As we've added more paths this has gotten pretty big. Scale the whole thing down.
+    canvas->scale(2 * SK_Scalar1 / 3, 2 * SK_Scalar1 / 3);
+
     for (int i = 0; i < fPaths.count(); ++i) {
         canvas->save();
         // position the path, and make it at off-integer coords.
-        canvas->translate(SK_Scalar1 * 200 * (i % 5) + SK_Scalar1 / 4,
-                          SK_Scalar1 * 200 * (i / 5) + 3 * SK_Scalar1 / 4);
+        canvas->translate(SK_Scalar1 * 200 * (i % 5) + SK_Scalar1 / 10,
+                          SK_Scalar1 * 200 * (i / 5) + 9 * SK_Scalar1 / 10);
         SkColor color = rand.nextU();
         color |= 0xff000000;
         paint.setColor(color);
         SkASSERT(fPaths[i].isConvex());
         canvas->drawPath(fPaths[i], paint);
         canvas->restore();
     }
     }
 
 private:
     typedef GM INHERITED;
     SkTArray<SkPath> fPaths;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static GM* MyFactory(void*) { return new ConvexPathsGM; }
 static GMRegistry reg(MyFactory);
 
 }