add asserts to point<-->verb helpers

src/pathops/SkOpSegment.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 "SkIntersections.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
 #include "SkTSort.h"
@@ skipping 115 matching lines @@
         }
         {
             const SkPoint& xy = xyAtT(&span);
             if (topPt.fY > xy.fY || (topPt.fY == xy.fY && topPt.fX > xy.fX)) {
                 topPt = xy;
                 if (firstT) {
                     *firstT = index;
                 }
             }
             if (fVerb != SkPath::kLine_Verb && !lastDone) {
-                SkPoint curveTop = (*CurveTop[fVerb])(fPts, lastT, span.fT);
+                SkPoint curveTop = (*CurveTop[SkPathOpsVerbToPoints(fVerb)])(fPts, lastT, span.fT);
                 if (topPt.fY > curveTop.fY || (topPt.fY == curveTop.fY
                         && topPt.fX > curveTop.fX)) {
                     topPt = curveTop;
                     if (firstT) {
                         *firstT = index;
                     }
                 }
             }
             lastT = span.fT;
         }
@@ skipping 56 matching lines @@
     bool result = gUnaryActiveEdge[from][to];
     return result;
 }
 
 void SkOpSegment::addAngle(SkTDArray<SkOpAngle>* anglesPtr, int start, int end) const {
     SkASSERT(start != end);
     SkOpAngle* angle = anglesPtr->append();
 #if DEBUG_ANGLE
     SkTDArray<SkOpAngle>& angles = *anglesPtr;
     if (angles.count() > 1 && !fTs[start].fTiny) {
-        SkPoint angle0Pt = (*CurvePointAtT[angles[0].verb()])(angles[0].pts(),
+        SkPoint angle0Pt = (*CurvePointAtT[SkPathOpsVerbToPoints(angles[0].verb())])(angles[0].pts(),
                 (*angles[0].spans())[angles[0].start()].fT);
-        SkPoint newPt = (*CurvePointAtT[fVerb])(fPts, fTs[start].fT);
+        SkPoint newPt = (*CurvePointAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, fTs[start].fT);
         bool match = AlmostEqualUlps(angle0Pt.fX, newPt.fX);
         match &= AlmostEqualUlps(angle0Pt.fY, newPt.fY);
         if (!match) {
             SkDebugf("%s no match\n", __FUNCTION__);
             SkASSERT(0);
         }
     }
 #endif
     angle->set(fPts, fVerb, this, start, end, fTs);
 }
@@ skipping 121 matching lines @@
     if (lastT < 0 || (start == 0 && end == lastT) || (start == lastT && end == 0)) {
         ePtr = fPts;
     } else {
     // OPTIMIZE? if not active, skip remainder and return xyAtT(end)
         subDivide(start, end, edge);
         ePtr = edge;
     }
     if (active) {
         bool reverse = ePtr == fPts && start != 0;
         if (reverse) {
-            path->deferredMoveLine(ePtr[fVerb]);
+            path->deferredMoveLine(ePtr[SkPathOpsVerbToPoints(fVerb)]);
             switch (fVerb) {
                 case SkPath::kLine_Verb:
                     path->deferredLine(ePtr[0]);
                     break;
                 case SkPath::kQuad_Verb:
                     path->quadTo(ePtr[1], ePtr[0]);
                     break;
                 case SkPath::kCubic_Verb:
                     path->cubicTo(ePtr[2], ePtr[1], ePtr[0]);
                     break;
@@ skipping 11 matching lines @@
                     path->quadTo(ePtr[1], ePtr[2]);
                     break;
                 case SkPath::kCubic_Verb:
                     path->cubicTo(ePtr[1], ePtr[2], ePtr[3]);
                     break;
                 default:
                     SkASSERT(0);
             }
         }
     }
-  //  return ePtr[fVerb];
+  //  return ePtr[SkPathOpsVerbToPoints(fVerb)];
 }
 
 void SkOpSegment::addLine(const SkPoint pts[2], bool operand, bool evenOdd) {
     init(pts, SkPath::kLine_Verb, operand, evenOdd);
     fBounds.set(pts, 2);
 }
 
 // add 2 to edge or out of range values to get T extremes
 void SkOpSegment::addOtherT(int index, double otherT, int otherIndex) {
     SkOpSpan& span = fTs[index];
@@ skipping 572 matching lines @@
         return bestTIndex;
     }
     if (fBounds.fLeft == fBounds.fRight) {
         // if vertical, and directly above test point, wait for another one
         return AlmostEqualUlps(basePt.fX, fBounds.fLeft) ? SK_MinS32 : bestTIndex;
     }
     // intersect ray starting at basePt with edge
     SkIntersections intersections;
     // OPTIMIZE: use specialty function that intersects ray with curve,
     // returning t values only for curve (we don't care about t on ray)
-    int pts = (intersections.*CurveVertical[fVerb])(fPts, top, bottom, basePt.fX, false);
+    int pts = (intersections.*CurveVertical[SkPathOpsVerbToPoints(fVerb)])(fPts, top, bottom, basePt.fX, false);
     if (pts == 0 || (current && pts == 1)) {
         return bestTIndex;
     }
     if (current) {
         SkASSERT(pts > 1);
         int closestIdx = 0;
         double closest = fabs(intersections[0][0] - mid);
         for (int idx = 1; idx < pts; ++idx) {
             double test = fabs(intersections[0][idx] - mid);
             if (closest > test) {
                 closestIdx = idx;
                 closest = test;
             }
         }
         intersections.quickRemoveOne(closestIdx, --pts);
     }
     double bestT = -1;
     for (int index = 0; index < pts; ++index) {
         double foundT = intersections[0][index];
         if (approximately_less_than_zero(foundT)
                     || approximately_greater_than_one(foundT)) {
             continue;
         }
-        SkScalar testY = (*CurvePointAtT[fVerb])(fPts, foundT).fY;
+        SkScalar testY = (*CurvePointAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, foundT).fY;
         if (approximately_negative(testY - *bestY)
                 || approximately_negative(basePt.fY - testY)) {
             continue;
         }
         if (pts > 1 && fVerb == SkPath::kLine_Verb) {
             return SK_MinS32;  // if the intersection is edge on, wait for another one
         }
         if (fVerb > SkPath::kLine_Verb) {
-            SkScalar dx = (*CurveSlopeAtT[fVerb])(fPts, foundT).fX;
+            SkScalar dx = (*CurveSlopeAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, foundT).fX;
             if (approximately_zero(dx)) {
                 return SK_MinS32;  // hit vertical, wait for another one
             }
         }
         *bestY = testY;
         bestT = foundT;
     }
     if (bestT < 0) {
         return bestTIndex;
     }
@@ skipping 705 matching lines @@
 the left or the right of vertical. This determines if we need to add the span's
 sign or not. However, this isn't enough.
 If the supplied sign (winding) is zero, then we didn't hit another vertical span, so dx is needed.
 If there was a winding, then it may or may not need adjusting. If the span the winding was borrowed
 from has the same x direction as this span, the winding should change. If the dx is opposite, then
 the same winding is shared by both.
 */
 void SkOpSegment::initWinding(int start, int end, double tHit, int winding, SkScalar hitDx,
                               int oppWind, SkScalar hitOppDx) {
     SkASSERT(hitDx || !winding);
-    SkScalar dx = (*CurveSlopeAtT[fVerb])(fPts, tHit).fX;
+    SkScalar dx = (*CurveSlopeAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, tHit).fX;
     SkASSERT(dx);
     int windVal = windValue(SkMin32(start, end));
 #if DEBUG_WINDING_AT_T
     SkDebugf("%s oldWinding=%d hitDx=%c dx=%c windVal=%d", __FUNCTION__, winding,
             hitDx ? hitDx > 0 ? '+' : '-' : '0', dx > 0 ? '+' : '-', windVal);
 #endif
     if (!winding) {
         winding = dx < 0 ? windVal : -windVal;
     } else if (winding * dx < 0) {
         int sideWind = winding + (dx < 0 ? windVal : -windVal);
@@ skipping 322 matching lines @@
 #endif
     span.fOppSum = oppWinding;
     return &span;
 }
 
 // from http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-points-are-in-clockwise-order
 bool SkOpSegment::clockwise(int tStart, int tEnd) const {
     SkASSERT(fVerb != SkPath::kLine_Verb);
     SkPoint edge[4];
     subDivide(tStart, tEnd, edge);
-    double sum = (edge[0].fX - edge[fVerb].fX) * (edge[0].fY + edge[fVerb].fY);
+    double sum = (edge[0].fX - edge[SkPathOpsVerbToPoints(fVerb)].fX) * (edge[0].fY + edge[SkPathOpsVerbToPoints(fVerb)].fY);
     if (fVerb == SkPath::kCubic_Verb) {
         SkScalar lesser = SkTMin<SkScalar>(edge[0].fY, edge[3].fY);
         if (edge[1].fY < lesser && edge[2].fY < lesser) {
             SkDLine tangent1 = {{ {edge[0].fX, edge[0].fY}, {edge[1].fX, edge[1].fY} }};
             SkDLine tangent2 = {{ {edge[2].fX, edge[2].fY}, {edge[3].fX, edge[3].fY} }};
             if (SkIntersections::Test(tangent1, tangent2)) {
                 SkPoint topPt = cubic_top(fPts, fTs[tStart].fT, fTs[tEnd].fT);
                 sum += (topPt.fX - edge[0].fX) * (topPt.fY + edge[0].fY);
                 sum += (edge[3].fX - topPt.fX) * (edge[3].fY + topPt.fY);
                 return sum <= 0;
             }
         }
     }
-    for (int idx = 0; idx < fVerb; ++idx){
+    for (int idx = 0; idx < SkPathOpsVerbToPoints(fVerb); ++idx){
         sum += (edge[idx + 1].fX - edge[idx].fX) * (edge[idx + 1].fY + edge[idx].fY);
     }
     return sum <= 0;
 }
 
 bool SkOpSegment::monotonicInY(int tStart, int tEnd) const {
     if (fVerb == SkPath::kLine_Verb) {
         return false;
     }
     if (fVerb == SkPath::kQuad_Verb) {
@@ skipping 249 matching lines @@
         for (angleIndex = 0; angleIndex < angleCount; ++angleIndex) {
             const SkOpAngle& angle = angles[angleIndex];
             angle.segment()->markUnsortable(angle.start(), angle.end());
         }
     }
     return sortable;
 }
 
 void SkOpSegment::subDivide(int start, int end, SkPoint edge[4]) const {
     edge[0] = fTs[start].fPt;
-    edge[fVerb] = fTs[end].fPt;
+    edge[SkPathOpsVerbToPoints(fVerb)] = fTs[end].fPt;
     if (fVerb == SkPath::kQuad_Verb || fVerb == SkPath::kCubic_Verb) {
-        SkDPoint sub[2] = {{ edge[0].fX, edge[0].fY}, {edge[fVerb].fX, edge[fVerb].fY }};
+        SkDPoint sub[2] = {{ edge[0].fX, edge[0].fY}, {edge[SkPathOpsVerbToPoints(fVerb)].fX, edge[SkPathOpsVerbToPoints(fVerb)].fY }};
         if (fVerb == SkPath::kQuad_Verb) {
             edge[1] = SkDQuad::SubDivide(fPts, sub[0], sub[1], fTs[start].fT,
                     fTs[end].fT).asSkPoint();
         } else {
             SkDCubic::SubDivide(fPts, sub[0], sub[1], fTs[start].fT, fTs[end].fT, sub);
             edge[1] = sub[0].asSkPoint();
             edge[2] = sub[1].asSkPoint();
         }
     }
 }
 
 void SkOpSegment::subDivideBounds(int start, int end, SkPathOpsBounds* bounds) const {
     SkPoint edge[4];
     subDivide(start, end, edge);
-    (bounds->*SetCurveBounds[fVerb])(edge);
+    (bounds->*SetCurveBounds[SkPathOpsVerbToPoints(fVerb)])(edge);
 }
 
 bool SkOpSegment::tiny(const SkOpAngle* angle) const {
     int start = angle->start();
     int end = angle->end();
     const SkOpSpan& mSpan = fTs[SkMin32(start, end)];
     return mSpan.fTiny;
 }
 
 void SkOpSegment::TrackOutside(SkTDArray<double>* outsideTs, double end, double start) {
@@ skipping 70 matching lines @@
     if (approximately_zero(tHit - t(tIndex))) {  // if we hit the end of a span, disregard
         return SK_MinS32;
     }
     int winding = crossOpp ? oppSum(tIndex) : windSum(tIndex);
     SkASSERT(winding != SK_MinS32);
     int windVal = crossOpp ? oppValue(tIndex) : windValue(tIndex);
 #if DEBUG_WINDING_AT_T
     SkDebugf("%s oldWinding=%d windValue=%d", __FUNCTION__, winding, windVal);
 #endif
     // see if a + change in T results in a +/- change in X (compute x'(T))
-    *dx = (*CurveSlopeAtT[fVerb])(fPts, tHit).fX;
+    *dx = (*CurveSlopeAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, tHit).fX;
     if (fVerb > SkPath::kLine_Verb && approximately_zero(*dx)) {
         *dx = fPts[2].fX - fPts[1].fX - *dx;
     }
     if (*dx == 0) {
 #if DEBUG_WINDING_AT_T
         SkDebugf(" dx=0 winding=SK_MinS32\n");
 #endif
         return SK_MinS32;
     }
     if (winding * *dx > 0) {  // if same signs, result is negative
@@ skipping 117 matching lines @@
         SkASSERT(i < fTs.count() - 1);
 #if DEBUG_ACTIVE_SPANS_SHORT_FORM
         if (lastId == fID && lastT == fTs[i].fT) {
             continue;
         }
         lastId = fID;
         lastT = fTs[i].fT;
 #endif
         SkDebugf("%s id=%d", __FUNCTION__, fID);
         SkDebugf(" (%1.9g,%1.9g", fPts[0].fX, fPts[0].fY);
-        for (int vIndex = 1; vIndex <= fVerb; ++vIndex) {
+        for (int vIndex = 1; vIndex <= SkPathOpsVerbToPoints(fVerb); ++vIndex) {
             SkDebugf(" %1.9g,%1.9g", fPts[vIndex].fX, fPts[vIndex].fY);
         }
         const SkOpSpan* span = &fTs[i];
         SkDebugf(") t=%1.9g (%1.9g,%1.9g)", span->fT, xAtT(span), yAtT(span));
         int iEnd = i + 1;
         while (fTs[iEnd].fT < 1 && approximately_equal(fTs[i].fT, fTs[iEnd].fT)) {
             ++iEnd;
         }
         SkDebugf(" tEnd=%1.9g", fTs[iEnd].fT);
         const SkOpSegment* other = fTs[i].fOther;
         SkDebugf(" other=%d otherT=%1.9g otherIndex=%d windSum=",
                 other->fID, fTs[i].fOtherT, fTs[i].fOtherIndex);
         if (fTs[i].fWindSum == SK_MinS32) {
             SkDebugf("?");
         } else {
             SkDebugf("%d", fTs[i].fWindSum);
         }
         SkDebugf(" windValue=%d oppValue=%d\n", fTs[i].fWindValue, fTs[i].fOppValue);
     }
 }
 #endif
 
 
 #if DEBUG_MARK_DONE || DEBUG_UNSORTABLE
 void SkOpSegment::debugShowNewWinding(const char* fun, const SkOpSpan& span, int winding) {
     const SkPoint& pt = xyAtT(&span);
     SkDebugf("%s id=%d", fun, fID);
     SkDebugf(" (%1.9g,%1.9g", fPts[0].fX, fPts[0].fY);
-    for (int vIndex = 1; vIndex <= fVerb; ++vIndex) {
+    for (int vIndex = 1; vIndex <= SkPathOpsVerbToPoints(fVerb); ++vIndex) {
         SkDebugf(" %1.9g,%1.9g", fPts[vIndex].fX, fPts[vIndex].fY);
     }
     SkASSERT(&span == &span.fOther->fTs[span.fOtherIndex].fOther->
             fTs[span.fOther->fTs[span.fOtherIndex].fOtherIndex]);
     SkDebugf(") t=%1.9g [%d] (%1.9g,%1.9g) tEnd=%1.9g newWindSum=%d windSum=",
             span.fT, span.fOther->fTs[span.fOtherIndex].fOtherIndex, pt.fX, pt.fY,
             (&span)[1].fT, winding);
     if (span.fWindSum == SK_MinS32) {
         SkDebugf("?");
     } else {
         SkDebugf("%d", span.fWindSum);
     }
     SkDebugf(" windValue=%d\n", span.fWindValue);
 }
 
 void SkOpSegment::debugShowNewWinding(const char* fun, const SkOpSpan& span, int winding,
                                       int oppWinding) {
     const SkPoint& pt = xyAtT(&span);
     SkDebugf("%s id=%d", fun, fID);
     SkDebugf(" (%1.9g,%1.9g", fPts[0].fX, fPts[0].fY);
-    for (int vIndex = 1; vIndex <= fVerb; ++vIndex) {
+    for (int vIndex = 1; vIndex <= SkPathOpsVerbToPoints(fVerb); ++vIndex) {
         SkDebugf(" %1.9g,%1.9g", fPts[vIndex].fX, fPts[vIndex].fY);
     }
     SkASSERT(&span == &span.fOther->fTs[span.fOtherIndex].fOther->
             fTs[span.fOther->fTs[span.fOtherIndex].fOtherIndex]);
     SkDebugf(") t=%1.9g [%d] (%1.9g,%1.9g) tEnd=%1.9g newWindSum=%d newOppSum=%d oppSum=",
             span.fT, span.fOther->fTs[span.fOtherIndex].fOtherIndex, pt.fX, pt.fY,
             (&span)[1].fT, winding, oppWinding);
     if (span.fOppSum == SK_MinS32) {
         SkDebugf("?");
     } else {
@@ skipping 55 matching lines @@
                 if (oppoSign) {
                     oppLastSum = oppWindSum;
                     oppWindSum -= oppoSign;
                 }
             }
         }
         SkDebugf("%s [%d] %s", __FUNCTION__, index,
                 angle.unsortable() ? "*** UNSORTABLE *** " : "");
     #if COMPACT_DEBUG_SORT
         SkDebugf("id=%d %s start=%d (%1.9g,%,1.9g) end=%d (%1.9g,%,1.9g)",
-                segment.fID, kLVerbStr[segment.fVerb],
+                segment.fID, kLVerbStr[SkPathOpsVerbToPoints(segment.fVerb)],
                 start, segment.xAtT(&sSpan), segment.yAtT(&sSpan), end,
                 segment.xAtT(&eSpan), segment.yAtT(&eSpan));
     #else
         switch (segment.fVerb) {
             case SkPath::kLine_Verb:
                 SkDebugf(LINE_DEBUG_STR, LINE_DEBUG_DATA(segment.fPts));
                 break;
             case SkPath::kQuad_Verb:
                 SkDebugf(QUAD_DEBUG_STR, QUAD_DEBUG_DATA(segment.fPts));
                 break;
@@ skipping 69 matching lines @@
         sum += fTs[i].fWindValue;
         slots[fTs[i].fOther->fID - 1] = as_digit(fTs[i].fWindValue);
         sum += fTs[i].fOppValue;
         slots[slotCount + fTs[i].fOther->fID - 1] = as_digit(fTs[i].fOppValue);
     }
     SkDebugf("%s id=%2d %.*s | %.*s\n", __FUNCTION__, fID, slotCount, slots.begin(), slotCount,
             slots.begin() + slotCount);
     return sum;
 }
 #endif