path ops work in progress

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 192 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(),
-                (*angles[0].spans())[angles[0].start()].fT);
+        const SkOpSegment* aSeg = angles[0].segment();
+        const SkPoint& angle0Pt = aSeg->xyAtT(angles[0].start());
         SkPoint newPt = (*CurvePointAtT[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 945 matching lines @@
         }
         const SkOpAngle* nextAngle = sorted[nextIndex];
         nextSegment = nextAngle->segment();
         int maxWinding, sumWinding, oppMaxWinding, oppSumWinding;
         bool activeAngle = nextSegment->activeOp(xorMiMask, xorSuMask, nextAngle->start(),
                 nextAngle->end(), op, &sumMiWinding, &sumSuWinding,
                 &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding);
         if (activeAngle) {
             ++activeCount;
             if (!foundAngle || (foundDone && activeCount & 1)) {
-                if (nextSegment->tiny(nextAngle)) {
+                if (nextSegment->isTiny(nextAngle)) {
                     *unsortable = true;
                     return NULL;
                 }
                 foundAngle = nextAngle;
-                foundDone = nextSegment->done(nextAngle) && !nextSegment->tiny(nextAngle);
+                foundDone = nextSegment->done(nextAngle) && !nextSegment->isTiny(nextAngle);
             }
         }
         if (nextSegment->done()) {
             continue;
         }
         if (nextSegment->windSum(nextAngle) != SK_MinS32) {
             continue;
         }
         SkOpSpan* last = nextSegment->markAngle(maxWinding, sumWinding, oppMaxWinding,
                 oppSumWinding, activeAngle, nextAngle);
@@ skipping 91 matching lines @@
             nextIndex = 0;
         }
         const SkOpAngle* nextAngle = sorted[nextIndex];
         nextSegment = nextAngle->segment();
         int maxWinding;
         bool activeAngle = nextSegment->activeWinding(nextAngle->start(), nextAngle->end(),
                 &maxWinding, &sumWinding);
         if (activeAngle) {
             ++activeCount;
             if (!foundAngle || (foundDone && activeCount & 1)) {
-                if (nextSegment->tiny(nextAngle)) {
+                if (nextSegment->isTiny(nextAngle)) {
                     *unsortable = true;
                     return NULL;
                 }
                 foundAngle = nextAngle;
                 foundDone = nextSegment->done(nextAngle);
             }
         }
         if (nextSegment->done()) {
             continue;
         }
@@ skipping 101 matching lines @@
     int activeCount = 0;
     do {
         SkASSERT(nextIndex != firstIndex);
         if (nextIndex == angleCount) {
             nextIndex = 0;
         }
         const SkOpAngle* nextAngle = sorted[nextIndex];
         nextSegment = nextAngle->segment();
         ++activeCount;
         if (!foundAngle || (foundDone && activeCount & 1)) {
-            if (nextSegment->tiny(nextAngle)) {
+            if (nextSegment->isTiny(nextAngle)) {
                 *unsortable = true;
                 return NULL;
             }
             foundAngle = nextAngle;
             foundDone = nextSegment->done(nextAngle);
         }
         if (nextSegment->done()) {
             continue;
         }
     } while (++nextIndex != lastIndex);
@@ skipping 942 matching lines @@
             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::subDivide(int start, int end, SkDCubic* result) const {
+    (*result)[0].set(fTs[start].fPt);
+    (*result)[fVerb].set(fTs[end].fPt);
+    if (fVerb == SkPath::kQuad_Verb) {
+        (*result)[1] = SkDQuad::SubDivide(fPts, (*result)[0], (*result)[2], fTs[start].fT,
+                fTs[end].fT);
+    } else if (fVerb == SkPath::kCubic_Verb) {
+        SkDCubic::SubDivide(fPts, (*result)[0], (*result)[3], fTs[start].fT, fTs[end].fT,
+                &(*result)[1]);
+    }
+}
+
 void SkOpSegment::subDivideBounds(int start, int end, SkPathOpsBounds* bounds) const {
     SkPoint edge[4];
     subDivide(start, end, edge);
     (bounds->*SetCurveBounds[fVerb])(edge);
 }
 
-bool SkOpSegment::tiny(const SkOpAngle* angle) const {
+bool SkOpSegment::isTiny(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) {
     int outCount = outsideTs->count();
     if (outCount == 0 || !approximately_negative(end - (*outsideTs)[outCount - 2])) {
         *outsideTs->append() = end;
@@ skipping 329 matching lines @@
                 lastSum = windSum;
                 windSum -= segment.spanSign(&angle);
                 if (oppoSign) {
                     oppLastSum = oppWindSum;
                     oppWindSum -= oppoSign;
                 }
             }
         }
         SkDebugf("%s [%d] %s", __FUNCTION__, index,
                 angle.unsortable() ? "*** UNSORTABLE *** " : "");
-    #if COMPACT_DEBUG_SORT
+    #if DEBUG_SORT_COMPACT
         SkDebugf("id=%d %s start=%d (%1.9g,%,1.9g) end=%d (%1.9g,%,1.9g)",
                 segment.fID, kLVerbStr[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:
@@ skipping 71 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