replace arcto quads with a conic

samplecode/SampleQuadStroker.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 "sk_tool_utils.h"
 #include "SampleCode.h"
 #include "SkView.h"
@@ skipping 59 matching lines @@
             default:
                 break;
         }
     }
     if (count > 0) {
         contourCounts->push_back(count);
     }
 }
 
 static void erase(SkSurface* surface) {
-    surface->getCanvas()->clear(SK_ColorTRANSPARENT);
+    SkCanvas* canvas = surface->getCanvas();
+    if (canvas) {
+        canvas->clear(SK_ColorTRANSPARENT);
+    }
 }
 
 struct StrokeTypeButton {
     SkRect fBounds;
     char fLabel;
     bool fEnabled;
 };
 
 struct CircleTypeButton : public StrokeTypeButton {
     bool fFill;
 };
 
 class QuadStrokerView : public SampleView {
     enum {
         SKELETON_COLOR = 0xFF0000FF,
         WIREFRAME_COLOR = 0x80FF0000
     };
 
     enum {
-        kCount = 15
+        kCount = 18
     };
     SkPoint fPts[kCount];
     SkRect fWeightControl;
+    SkRect fRadiusControl;
     SkRect fErrorControl;
     SkRect fWidthControl;
     SkRect fBounds;
     SkMatrix fMatrix, fInverse;
     SkAutoTUnref<SkShader> fShader;
     SkAutoTUnref<SkSurface> fMinSurface;
     SkAutoTUnref<SkSurface> fMaxSurface;
     StrokeTypeButton fCubicButton;
     StrokeTypeButton fConicButton;
     StrokeTypeButton fQuadButton;
+    StrokeTypeButton fArcButton;
     StrokeTypeButton fRRectButton;
     CircleTypeButton fCircleButton;
     StrokeTypeButton fTextButton;
     SkString fText;
     SkScalar fTextSize;
     SkScalar fWeight;
+    SkScalar fRadius;
     SkScalar fWidth, fDWidth;
     SkScalar fWidthScale;
     int fW, fH, fZoom;
     bool fAnimate;
     bool fDrawRibs;
     bool fDrawTangents;
     bool fDrawTDivs;
 #ifdef SK_DEBUG
     #define kStrokerErrorMin 0.001f
     #define kStrokerErrorMax 5
@@ skipping 10 matching lines @@
         fPts[3].set(300, 50);
 
         fPts[4].set(350, 200);  // conic
         fPts[5].set(350, 100);
         fPts[6].set(450, 50);
 
         fPts[7].set(150, 300);  // quad
         fPts[8].set(150, 200);
         fPts[9].set(250, 150);
 
-        fPts[10].set(200, 200); // rrect
-        fPts[11].set(400, 400);
+        fPts[10].set(250, 200);  // arc
+        fPts[11].set(250, 300);
+        fPts[12].set(150, 350);
 
-        fPts[12].set(250, 250);  // oval
-        fPts[13].set(450, 450);
+        fPts[13].set(200, 200); // rrect
+        fPts[14].set(400, 400);
+
+        fPts[15].set(250, 250);  // oval
+        fPts[16].set(450, 450);
 
         fText = "a";
         fTextSize = 12;
         fWidth = 50;
         fDWidth = 0.25f;
         fWeight = 1;
+        fRadius = 150;
 
         fCubicButton.fLabel = 'C';
         fCubicButton.fEnabled = false;
         fConicButton.fLabel = 'K';
-        fConicButton.fEnabled = true;
+        fConicButton.fEnabled = false;
         fQuadButton.fLabel = 'Q';
         fQuadButton.fEnabled = false;
+        fArcButton.fLabel = 'A';
+        fArcButton.fEnabled = true;
         fRRectButton.fLabel = 'R';
         fRRectButton.fEnabled = false;
         fCircleButton.fLabel = 'O';
-        fCircleButton.fEnabled = false;
-        fCircleButton.fFill = false;
+        fCircleButton.fEnabled = true;
+        fCircleButton.fFill = true;
         fTextButton.fLabel = 'T';
         fTextButton.fEnabled = false;
-        fAnimate = true;
+        fAnimate = false;
         setAsNeeded();
     }
 
 protected:
     bool onQuery(SkEvent* evt) override {
         if (SampleCode::TitleQ(*evt)) {
             SampleCode::TitleR(evt, "QuadStroker");
             return true;
         }
         SkUnichar uni;
@@ skipping 12 matching lines @@
                 default:
                     fText.appendUnichar(uni);
             }
             this->inval(nullptr);
             return true;
         }
         return this->INHERITED::onQuery(evt);
     }
 
     void onSizeChange() override {
+        fRadiusControl.setXYWH(this->width() - 200, 30, 30, 400);
         fWeightControl.setXYWH(this->width() - 150, 30, 30, 400);
         fErrorControl.setXYWH(this->width() - 100, 30, 30, 400);
         fWidthControl.setXYWH(this->width() -  50, 30, 30, 400);
         int buttonOffset = 450;
         fCubicButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
         buttonOffset += 50;
         fConicButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
         buttonOffset += 50;
         fQuadButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
         buttonOffset += 50;
+        fArcButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
+        buttonOffset += 50;
         fRRectButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
         buttonOffset += 50;
         fCircleButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
         buttonOffset += 50;
         fTextButton.fBounds.setXYWH(this->width() - 50, SkIntToScalar(buttonOffset), 30, 30);
         this->INHERITED::onSizeChange();
     }
 
      void copyMinToMax() {
         erase(fMaxSurface);
@@ skipping 284 matching lines @@
     }
 
     void setForSingles() {
         setForGeometry();
         fDrawTDivs = true;
     }
 
     void setAsNeeded() {
         if (fConicButton.fEnabled || fCubicButton.fEnabled || fQuadButton.fEnabled) {
             setForSingles();
-        } else if (fRRectButton.fEnabled || fCircleButton.fEnabled) {
+        } else if (fRRectButton.fEnabled || fCircleButton.fEnabled || fArcButton.fEnabled) {
             setForGeometry();
         } else {
             setForText();
         }
     }
 
+    bool arcCenter(SkPoint* center) {
+        SkPath path;
+        path.moveTo(fPts[10]);
+        path.arcTo(fPts[11], fPts[12], fRadius);
+        SkPath::Iter iter(path, false);
+        SkPoint pts[4];
+        iter.next(pts);
+        if (SkPath::kLine_Verb == iter.next(pts)) {
+            iter.next(pts);
+        }
+        SkVector before = pts[0] - pts[1];
+        SkVector after = pts[1] - pts[2];
+        before.setLength(fRadius);
+        after.setLength(fRadius);
+        SkVector beforeCCW, afterCCW;
+        before.rotateCCW(&beforeCCW);
+        after.rotateCCW(&afterCCW);
+        beforeCCW += pts[0];
+        afterCCW += pts[2];
+        *center = beforeCCW;
+        if (SkScalarNearlyEqual(beforeCCW.fX, afterCCW.fX)
+                && SkScalarNearlyEqual(beforeCCW.fY, afterCCW.fY)) {
+            return true;
+        }
+        SkVector beforeCW, afterCW;
+        before.rotateCW(&beforeCW);
+        after.rotateCW(&afterCW);
+        beforeCW += pts[0];
+        afterCW += pts[2];
+        *center = beforeCW;
+        return SkScalarNearlyEqual(beforeCW.fX, afterCW.fX)
+                && SkScalarNearlyEqual(beforeCCW.fY, afterCW.fY);
+    }
+
     void onDrawContent(SkCanvas* canvas) override {
         SkPath path;
         SkScalar width = fWidth;
 
         if (fCubicButton.fEnabled) {
             path.moveTo(fPts[0]);
             path.cubicTo(fPts[1], fPts[2], fPts[3]);
             setForSingles();
             draw_stroke(canvas, path, width, 950, false);
         }
 
         if (fConicButton.fEnabled) {
             path.reset();
             path.moveTo(fPts[4]);
             path.conicTo(fPts[5], fPts[6], fWeight);
             setForSingles();
             draw_stroke(canvas, path, width, 950, false);
         }
 
         if (fQuadButton.fEnabled) {
             path.reset();
             path.moveTo(fPts[7]);
             path.quadTo(fPts[8], fPts[9]);
             setForSingles();
             draw_stroke(canvas, path, width, 950, false);
         }
 
+        if (fArcButton.fEnabled) {
+            path.reset();
+            path.moveTo(fPts[10]);
+            path.arcTo(fPts[11], fPts[12], fRadius);
+            setForGeometry();
+            draw_stroke(canvas, path, width, 950, false);
+            SkPath pathPts;
+            pathPts.moveTo(fPts[10]);
+            pathPts.lineTo(fPts[11]);
+            pathPts.lineTo(fPts[12]);
+            draw_points(canvas, pathPts, SK_ColorDKGRAY, true);
+        }
+
         if (fRRectButton.fEnabled) {
             SkScalar rad = 32;
             SkRect r;
-            r.set(&fPts[10], 2);
+            r.set(&fPts[13], 2);
             path.reset();
             SkRRect rr;
             rr.setRectXY(r, rad, rad);
             path.addRRect(rr);
             setForGeometry();
             draw_stroke(canvas, path, width, 950, false);
 
             path.reset();
             SkRRect rr2;
             rr.inset(width/2, width/2, &rr2);
             path.addRRect(rr2, SkPath::kCCW_Direction);
             rr.inset(-width/2, -width/2, &rr2);
             path.addRRect(rr2, SkPath::kCW_Direction);
             SkPaint paint;
             paint.setAntiAlias(true);
             paint.setColor(0x40FF8844);
             canvas->drawPath(path, paint);
         }
 
         if (fCircleButton.fEnabled) {
             path.reset();
             SkRect r;
-            r.set(&fPts[12], 2);
+            r.set(&fPts[15], 2);
             path.addOval(r);
             setForGeometry();
             if (fCircleButton.fFill) {
+                if (fArcButton.fEnabled) {
+                    SkPoint center;
+                    if (arcCenter(&center)) {
+                        r.set(center.fX - fRadius, center.fY - fRadius, center.fX + fRadius, 
+                                center.fY + fRadius);
+                    }
+                }
                 draw_fill(canvas, r, width);
             } else {
                 draw_stroke(canvas, path, width, 950, false);
             }
         }
 
         if (fTextButton.fEnabled) {
             path.reset();
             SkPaint paint;
             paint.setAntiAlias(true);
             paint.setTextSize(fTextSize);
             paint.getTextPath(fText.c_str(), fText.size(), 0, fTextSize, &path);
             setForText();
             draw_stroke(canvas, path, width * fWidthScale / fTextSize, fTextSize, true);
         }
 
         if (fAnimate) {
             fWidth += fDWidth;
             if (fDWidth > 0 && fWidth > kWidthMax) {
                 fDWidth = -fDWidth;
             } else if (fDWidth < 0 && fWidth < kWidthMin) {
                 fDWidth = -fDWidth;
             }
         }
         setAsNeeded();
         if (fConicButton.fEnabled) {
             draw_control(canvas, fWeightControl, fWeight, 0, 5, "weight");
         }
+        if (fArcButton.fEnabled) {
+            draw_control(canvas, fRadiusControl, fRadius, 0, 500, "radius");
+        }
 #ifdef SK_DEBUG
         draw_control(canvas, fErrorControl, gDebugStrokerError, kStrokerErrorMin, kStrokerErrorMax,
                 "error");
 #endif
         draw_control(canvas, fWidthControl, fWidth * fWidthScale, kWidthMin * fWidthScale,
                 kWidthMax * fWidthScale, "width");
         draw_button(canvas, fQuadButton);
         draw_button(canvas, fCubicButton);
         draw_button(canvas, fConicButton);
+        draw_button(canvas, fArcButton);
         draw_button(canvas, fRRectButton);
         draw_button(canvas, fCircleButton);
         draw_button(canvas, fTextButton);
         this->inval(nullptr);
     }
 
     class MyClick : public Click {
     public:
         int fIndex;
         MyClick(SkView* target, int index) : Click(target), fIndex(index) {}
     };
 
     virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y,
                                               unsigned modi) override {
         for (size_t i = 0; i < SK_ARRAY_COUNT(fPts); ++i) {
             if (hittest(fPts[i], x, y)) {
                 return new MyClick(this, (int)i);
             }
         }
         const SkRect& rectPt = SkRect::MakeXYWH(x, y, 1, 1);
         if (fWeightControl.contains(rectPt)) {
             return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 1);
         }
+        if (fRadiusControl.contains(rectPt)) {
+            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 2);
+        }
 #ifdef SK_DEBUG
         if (fErrorControl.contains(rectPt)) {
-            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 2);
+            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 3);
         }
 #endif
         if (fWidthControl.contains(rectPt)) {
-            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 3);
+            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 4);
         }
         if (fCubicButton.fBounds.contains(rectPt)) {
             fCubicButton.fEnabled ^= true;
-            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 4);
+            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 5);
         }
         if (fConicButton.fBounds.contains(rectPt)) {
             fConicButton.fEnabled ^= true;
-            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 5);
+            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 6);
         }
         if (fQuadButton.fBounds.contains(rectPt)) {
             fQuadButton.fEnabled ^= true;
-            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 6);
+            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 7);
+        }
+        if (fArcButton.fBounds.contains(rectPt)) {
+            fArcButton.fEnabled ^= true;
+            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 8);
         }
         if (fRRectButton.fBounds.contains(rectPt)) {
             fRRectButton.fEnabled ^= true;
-            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 7);
+            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 9);
         }
         if (fCircleButton.fBounds.contains(rectPt)) {
             bool wasEnabled = fCircleButton.fEnabled;
             fCircleButton.fEnabled = !fCircleButton.fFill;
             fCircleButton.fFill = wasEnabled && !fCircleButton.fFill;
-            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 8);
+            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 10);
         }
         if (fTextButton.fBounds.contains(rectPt)) {
             fTextButton.fEnabled ^= true;
-            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 9);
+            return new MyClick(this, (int) SK_ARRAY_COUNT(fPts) + 11);
         }
         return this->INHERITED::onFindClickHandler(x, y, modi);
     }
 
     static SkScalar MapScreenYtoValue(int y, const SkRect& control, SkScalar min,
             SkScalar max) {
         return (SkIntToScalar(y) - control.fTop) / control.height() * (max - min) + min;
     }
 
     bool onClick(Click* click) override {
         int index = ((MyClick*)click)->fIndex;
         if (index < (int) SK_ARRAY_COUNT(fPts)) {
             fPts[index].offset(SkIntToScalar(click->fICurr.fX - click->fIPrev.fX),
                                SkIntToScalar(click->fICurr.fY - click->fIPrev.fY));
             this->inval(nullptr);
         } else if (index == (int) SK_ARRAY_COUNT(fPts) + 1) {
             fWeight = MapScreenYtoValue(click->fICurr.fY, fWeightControl, 0, 5);
+        } else if (index == (int) SK_ARRAY_COUNT(fPts) + 2) {
+            fRadius = MapScreenYtoValue(click->fICurr.fY, fRadiusControl, 0, 500);
         }
 #ifdef SK_DEBUG
-        else if (index == (int) SK_ARRAY_COUNT(fPts) + 2) {
+        else if (index == (int) SK_ARRAY_COUNT(fPts) + 3) {
             gDebugStrokerError = SkTMax(FLT_EPSILON, MapScreenYtoValue(click->fICurr.fY,
                     fErrorControl, kStrokerErrorMin, kStrokerErrorMax));
             gDebugStrokerErrorSet = true;
         }
 #endif
-        else if (index == (int) SK_ARRAY_COUNT(fPts) + 3) {
+        else if (index == (int) SK_ARRAY_COUNT(fPts) + 4) {
             fWidth = SkTMax(FLT_EPSILON, MapScreenYtoValue(click->fICurr.fY, fWidthControl,
                     kWidthMin, kWidthMax));
             fAnimate = fWidth <= kWidthMin;
         }
         return true;
     }
 
 private:
     typedef SkView INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkView* F2() { return new QuadStrokerView; }
 static SkViewRegister gR2(F2);