use conics

src/core/SkPathMeasure.cpp

 
 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPathMeasure.h"
 #include "SkGeometry.h"
 #include "SkPath.h"
 #include "SkTSearch.h"
 
-// these must be 0,1,2 since they are in our 2-bit field
+// these must be 0,1,2,3 since they are in our 2-bit field
 enum {
     kLine_SegType,
     kQuad_SegType,
-    kCubic_SegType
+    kCubic_SegType,
+    kConic_SegType,
 };
 
 #define kMaxTValue  32767
 
 static inline SkScalar tValue2Scalar(int t) {
     SkASSERT((unsigned)t <= kMaxTValue);
     return t * 3.05185e-5f; // t / 32767
 }
 
 SkScalar SkPathMeasure::Segment::getScalarT() const {
@@ skipping 67 matching lines @@
             Segment* seg = fSegments.append();
             seg->fDistance = distance;
             seg->fPtIndex = ptIndex;
             seg->fType = kQuad_SegType;
             seg->fTValue = maxt;
         }
     }
     return distance;
 }
 
+SkScalar SkPathMeasure::compute_conic_segs(const SkConic& conic,
+                                           SkScalar distance, int mint, int maxt, int ptIndex) {
+    if (tspan_big_enough(maxt - mint) && quad_too_curvy(conic.fPts)) {
+        SkConic tmp[2];
+        conic.chop(tmp);
+
+        int halft = (mint + maxt) >> 1;
+        distance = this->compute_conic_segs(tmp[0], distance, mint, halft, ptIndex);
+        distance = this->compute_conic_segs(tmp[1], distance, halft, maxt, ptIndex);
+    } else {
+        SkScalar d = SkPoint::Distance(conic.fPts[0], conic.fPts[2]);
+        SkScalar prevD = distance;
+        distance += d;
+        if (distance > prevD) {
+            Segment* seg = fSegments.append();
+            seg->fDistance = distance;
+            seg->fPtIndex = ptIndex;
+            seg->fType = kConic_SegType;
+            seg->fTValue = maxt;
+        }
+    }
+    return distance;
+}
+
 SkScalar SkPathMeasure::compute_cubic_segs(const SkPoint pts[4],
                            SkScalar distance, int mint, int maxt, int ptIndex) {
     if (tspan_big_enough(maxt - mint) && cubic_too_curvy(pts)) {
         SkPoint tmp[7];
         int     halft = (mint + maxt) >> 1;
 
         SkChopCubicAtHalf(pts, tmp);
         distance = this->compute_cubic_segs(tmp, distance, mint, halft, ptIndex);
         distance = this->compute_cubic_segs(&tmp[3], distance, halft, maxt, ptIndex);
     } else {
@@ skipping 23 matching lines @@
      *  as we accumulate distance, we have to check that the result of +=
      *  actually made it larger, since a very small delta might be > 0, but
      *  still have no effect on distance (if distance >>> delta).
      *
      *  We do this check below, and in compute_quad_segs and compute_cubic_segs
      */
     fSegments.reset();
     bool done = false;
     do {
         switch (fIter.next(pts)) {
-            case SkPath::kConic_Verb:
-                SkASSERT(0);
-                break;
             case SkPath::kMove_Verb:
                 ptIndex += 1;
                 fPts.append(1, pts);
                 if (!firstMoveTo) {
                     done = true;
                     break;
                 }
                 firstMoveTo = false;
                 break;
 
             case SkPath::kLine_Verb: {
                 SkScalar d = SkPoint::Distance(pts[0], pts[1]);
                 SkASSERT(d >= 0);
                 SkScalar prevD = distance;
                 distance += d;
                 if (distance > prevD) {
                     seg = fSegments.append();
                     seg->fDistance = distance;
                     seg->fPtIndex = ptIndex;
                     seg->fType = kLine_SegType;
                     seg->fTValue = kMaxTValue;
                     fPts.append(1, pts + 1);
                     ptIndex++;
                 }
             } break;
 
             case SkPath::kQuad_Verb: {
                 SkScalar prevD = distance;
-                distance = this->compute_quad_segs(pts, distance, 0,
-                                                   kMaxTValue, ptIndex);
+                distance = this->compute_quad_segs(pts, distance, 0, kMaxTValue, ptIndex);
                 if (distance > prevD) {
                     fPts.append(2, pts + 1);
                     ptIndex += 2;
                 }
             } break;
 
+            case SkPath::kConic_Verb: {
+                const SkConic conic(pts, fIter.conicWeight());
+                SkScalar prevD = distance;
+                distance = this->compute_conic_segs(conic, distance, 0, kMaxTValue, ptIndex);
+                if (distance > prevD) {
+                    // we store the conic weight in our next point, followed by the last 2 pts
+                    // thus to reconstitue a conic, you'd need to say
+                    // SkConic(pts[0], pts[2], pts[3], weight = pts[1].fX)
+                    fPts.append()->set(conic.fW, 0);
+                    fPts.append(2, pts + 1);
+                    ptIndex += 3;
+                }
+            } break;
+
             case SkPath::kCubic_Verb: {
                 SkScalar prevD = distance;
-                distance = this->compute_cubic_segs(pts, distance, 0,
-                                                    kMaxTValue, ptIndex);
+                distance = this->compute_cubic_segs(pts, distance, 0, kMaxTValue, ptIndex);
                 if (distance > prevD) {
                     fPts.append(3, pts + 1);
                     ptIndex += 3;
                 }
             } break;
 
             case SkPath::kClose_Verb:
                 isClosed = true;
                 break;
 
@@ skipping 46 matching lines @@
             if (tangent) {
                 tangent->setNormalize(pts[1].fX - pts[0].fX, pts[1].fY - pts[0].fY);
             }
             break;
         case kQuad_SegType:
             SkEvalQuadAt(pts, t, pos, tangent);
             if (tangent) {
                 tangent->normalize();
             }
             break;
+        case kConic_SegType: {
+            SkConic(pts[0], pts[2], pts[3], pts[1].fX).evalAt(t, pos, tangent);
+            if (tangent) {
+                tangent->normalize();
+            }
+        } break;
         case kCubic_SegType:
             SkEvalCubicAt(pts, t, pos, tangent, NULL);
             if (tangent) {
                 tangent->normalize();
             }
             break;
         default:
             SkDEBUGFAIL("unknown segType");
     }
 }
 
 static void seg_to(const SkPoint pts[], int segType,
                    SkScalar startT, SkScalar stopT, SkPath* dst) {
     SkASSERT(startT >= 0 && startT <= SK_Scalar1);
     SkASSERT(stopT >= 0 && stopT <= SK_Scalar1);
     SkASSERT(startT <= stopT);
 
     if (startT == stopT) {
         return; // should we report this, to undo a moveTo?
     }
 
-    SkPoint         tmp0[7], tmp1[7];
+    SkPoint tmp0[7], tmp1[7];
 
     switch (segType) {
         case kLine_SegType:
             if (SK_Scalar1 == stopT) {
                 dst->lineTo(pts[1]);
             } else {
                 dst->lineTo(SkScalarInterp(pts[0].fX, pts[1].fX, stopT),
                             SkScalarInterp(pts[0].fY, pts[1].fY, stopT));
             }
             break;
         case kQuad_SegType:
             if (0 == startT) {
                 if (SK_Scalar1 == stopT) {
                     dst->quadTo(pts[1], pts[2]);
                 } else {
                     SkChopQuadAt(pts, tmp0, stopT);
                     dst->quadTo(tmp0[1], tmp0[2]);
                 }
             } else {
                 SkChopQuadAt(pts, tmp0, startT);
                 if (SK_Scalar1 == stopT) {
                     dst->quadTo(tmp0[3], tmp0[4]);
                 } else {
                     SkChopQuadAt(&tmp0[2], tmp1, SkScalarDiv(stopT - startT,
                                                          SK_Scalar1 - startT));
                     dst->quadTo(tmp1[1], tmp1[2]);
                 }
             }
             break;
+        case kConic_SegType: {
+            SkConic conic(pts[0], pts[2], pts[3], pts[1].fX);
+
+            if (0 == startT) {
+                if (SK_Scalar1 == stopT) {
+                    dst->conicTo(conic.fPts[1], conic.fPts[2], conic.fW);
+                } else {
+                    SkConic tmp[2];
+                    conic.chopAt(stopT, tmp);
+                    dst->conicTo(tmp[0].fPts[1], tmp[0].fPts[2], tmp[0].fW);
+                }
+            } else {
+                SkConic tmp1[2];
+                conic.chopAt(startT, tmp1);
+                if (SK_Scalar1 == stopT) {
+                    dst->conicTo(tmp1[1].fPts[1], tmp1[1].fPts[2], tmp1[1].fW);
+                } else {
+                    SkConic tmp2[2];
+                    tmp1[1].chopAt((stopT - startT) / (SK_Scalar1 - startT), tmp2);
+                    dst->conicTo(tmp2[0].fPts[1], tmp2[0].fPts[2], tmp2[0].fW);
+                }
+            }
+        } break;
         case kCubic_SegType:
             if (0 == startT) {
                 if (SK_Scalar1 == stopT) {
                     dst->cubicTo(pts[1], pts[2], pts[3]);
                 } else {
                     SkChopCubicAt(pts, tmp0, stopT);
                     dst->cubicTo(tmp0[1], tmp0[2], tmp0[3]);
                 }
             } else {
                 SkChopCubicAt(pts, tmp0, startT);
@@ skipping 208 matching lines @@
 
     for (int i = 0; i < fSegments.count(); i++) {
         const Segment* seg = &fSegments[i];
         SkDebugf("pathmeas: seg[%d] distance=%g, point=%d, t=%g, type=%d\n",
                 i, seg->fDistance, seg->fPtIndex, seg->getScalarT(),
                  seg->fType);
     }
 }
 
 #endif