path ops -- handle non-finite numbers

src/pathops/SkOpEdgeBuilder.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 "SkOpEdgeBuilder.h"
 #include "SkReduceOrder.h"
 
 void SkOpEdgeBuilder::init() {
@@ skipping 10 matching lines @@
 
 void SkOpEdgeBuilder::addOperand(const SkPath& path) {
     SkASSERT(fPathVerbs.count() > 0 && fPathVerbs.end()[-1] == SkPath::kDone_Verb);
     fPathVerbs.pop();
     fPath = &path;
     fXorMask[1] = (fPath->getFillType() & 1) ? kEvenOdd_PathOpsMask
             : kWinding_PathOpsMask;
     preFetch();
 }
 
-void SkOpEdgeBuilder::finish() {
-    walk();
+bool SkOpEdgeBuilder::finish() {
+    if (!walk()) {
+        return false;
+    }
     complete();
     if (fCurrentContour && !fCurrentContour->segments().count()) {
         fContours.pop_back();
     }
     // correct pointers in contours since fReducePts may have moved as it grew
     int cIndex = 0;
     int extraCount = fExtra.count();
     SkASSERT(extraCount == 0 || fExtra[0] == -1);
     int eIndex = 0;
     int rIndex = 0;
     while (++eIndex < extraCount) {
         int offset = fExtra[eIndex];
         if (offset < 0) {
             ++cIndex;
             continue;
         }
         fCurrentContour = &fContours[cIndex];
         rIndex += fCurrentContour->updateSegment(offset - 1,
                 &fReducePts[rIndex]);
     }
     fExtra.reset();  // we're done with this
+    return true;
 }
 
 // Note that copying the points here avoids copying the resulting path later.
 // To allow Op() to take one of the input paths as an output parameter, either the source data
 // must be copied (as implemented below) or the result must be copied.
 // OPTIMIZATION: This copies both sets of input points every time. If the input data was read
 // directly, the output path would only need to be copied if it was also one of the input paths.
 int SkOpEdgeBuilder::preFetch() {
     SkPath::RawIter iter(*fPath);
     SkPoint pts[4];
     SkPath::Verb verb;
     do {
         verb = iter.next(pts);
         *fPathVerbs.append() = verb;
         if (verb == SkPath::kMove_Verb) {
             *fPathPts.append() = pts[0];
         } else if (verb >= SkPath::kLine_Verb && verb <= SkPath::kCubic_Verb) {
             fPathPts.append(verb, &pts[1]);
         }
     } while (verb != SkPath::kDone_Verb);
     return fPathVerbs.count() - 1;
 }
 
-void SkOpEdgeBuilder::walk() {
+static bool is_finite_point(const SkPoint& pt) {
+    // repeat logic in SkRect::isFinite()
+    float accum = 0;
+    accum *= pt.fX;
+    accum *= pt.fY;
+
+    // accum is either NaN or it is finite (zero).
+    SkASSERT(0 == accum || !(accum == accum));
+
+    // value==value will be true iff value is not NaN
+    // TODO: is it faster to say !accum or accum==accum?
+    return accum == accum;
+}
+
+static bool is_finite_line(const SkPoint pts[2]) {
+    // repeat logic in SkRect::isFinite()
+    float accum = 0;
+    accum *= pts[0].fX;
+    accum *= pts[0].fY;
+    accum *= pts[1].fX;
+    accum *= pts[1].fY;
+
+    // accum is either NaN or it is finite (zero).
+    SkASSERT(0 == accum || !(accum == accum));
+
+    // value==value will be true iff value is not NaN
+    // TODO: is it faster to say !accum or accum==accum?
+    return accum == accum;
+}
+
+static bool is_finite_quad(const SkPoint pts[3]) {
+    // repeat logic in SkRect::isFinite()
+    float accum = 0;
+    accum *= pts[0].fX;
+    accum *= pts[0].fY;
+    accum *= pts[1].fX;
+    accum *= pts[1].fY;
+    accum *= pts[2].fX;
+    accum *= pts[2].fY;
+
+    // accum is either NaN or it is finite (zero).
+    SkASSERT(0 == accum || !(accum == accum));
+
+    // value==value will be true iff value is not NaN
+    // TODO: is it faster to say !accum or accum==accum?
+    return accum == accum;
+}
+
+bool SkOpEdgeBuilder::close() {
+    if (fFinalCurveStart && fFinalCurveEnd && *fFinalCurveStart != *fFinalCurveEnd) {
+        *fReducePts.append() = *fFinalCurveStart;
+        *fReducePts.append() = *fFinalCurveEnd;
+        const SkPoint* lineStart = fReducePts.end() - 2;
+        *fExtra.append() = fCurrentContour->addLine(lineStart);
+    }
+    complete();
+    return true;
+}
+
+bool SkOpEdgeBuilder::walk() {
     SkPath::Verb reducedVerb;
     uint8_t* verbPtr = fPathVerbs.begin();
     uint8_t* endOfFirstHalf = &verbPtr[fSecondHalf];
     const SkPoint* pointsPtr = fPathPts.begin();
-    const SkPoint* finalCurveStart = NULL;
-    const SkPoint* finalCurveEnd = NULL;
     SkPath::Verb verb;
+    fFinalCurveStart = NULL;
+    fFinalCurveEnd = NULL;
     while ((verb = (SkPath::Verb) *verbPtr) != SkPath::kDone_Verb) {
         if (verbPtr == endOfFirstHalf) {
             fOperand = true;
         }
         verbPtr++;
         switch (verb) {
             case SkPath::kMove_Verb:
-                complete();
+                if (fCurrentContour) {
+                    if (fAllowOpenContours) {
+                        complete();
+                    } else if (!close()) {
+                        return false;
+                    }
+                }
                 if (!fCurrentContour) {
                     fCurrentContour = fContours.push_back_n(1);
                     fCurrentContour->setOperand(fOperand);
                     fCurrentContour->setXor(fXorMask[fOperand] == kEvenOdd_PathOpsMask);
                     *fExtra.append() = -1;  // start new contour
                 }
-                finalCurveEnd = pointsPtr++;
+                if (!is_finite_point(pointsPtr[0])) {

[reed1, 2013/04/26 17:49:14]

Would it be faster to just ask for the path's bounds at the very beginning,
since that can be cached, and should report if the path was finite?

[caryclark, 2013/04/26 19:47:30]

Yes indeed. Done and uploaded.

On 2013/04/26 17:49:14, reed1 wrote:

+                    return false;
+                }
+                fFinalCurveEnd = pointsPtr++;
                 continue;
-            case SkPath::kLine_Verb:
+            case SkPath::kLine_Verb: {
+                const SkPoint& lineEnd = pointsPtr[0];
+                if (!is_finite_point(lineEnd)) {
+                    return false;
+                }
+                const SkPoint& lineStart = pointsPtr[-1];
                 // skip degenerate points
-                if (pointsPtr[-1].fX != pointsPtr[0].fX || pointsPtr[-1].fY != pointsPtr[0].fY) {
-                    fCurrentContour->addLine(&pointsPtr[-1]);
+                if (lineStart.fX != lineEnd.fX || lineStart.fY != lineEnd.fY) {
+                    fCurrentContour->addLine(&lineStart);
                 }
-                break;
-            case SkPath::kQuad_Verb:
-                reducedVerb = SkReduceOrder::Quad(&pointsPtr[-1], &fReducePts);
+                } break;
+            case SkPath::kQuad_Verb: {
+                if (!is_finite_line(pointsPtr)) {
+                    return false;
+                }
+                const SkPoint* quadStart = &pointsPtr[-1];
+                reducedVerb = SkReduceOrder::Quad(quadStart, &fReducePts);
                 if (reducedVerb == 0) {
                     break;  // skip degenerate points
                 }
                 if (reducedVerb == 1) {
-                    *fExtra.append() =
-                            fCurrentContour->addLine(fReducePts.end() - 2);
+                    const SkPoint* lineStart = fReducePts.end() - 2;
+                   *fExtra.append() = fCurrentContour->addLine(lineStart);
                     break;
                 }
-                fCurrentContour->addQuad(&pointsPtr[-1]);
-                break;
-            case SkPath::kCubic_Verb:
-                reducedVerb = SkReduceOrder::Cubic(&pointsPtr[-1], &fReducePts);
+                fCurrentContour->addQuad(quadStart);
+                } break;
+            case SkPath::kCubic_Verb: {
+                if (!is_finite_quad(pointsPtr)) {
+                    return false;
+                }
+                const SkPoint* cubicStart = &pointsPtr[-1];
+                reducedVerb = SkReduceOrder::Cubic(cubicStart, &fReducePts);
                 if (reducedVerb == 0) {
                     break;  // skip degenerate points
                 }
                 if (reducedVerb == 1) {
-                    *fExtra.append() = fCurrentContour->addLine(fReducePts.end() - 2);
+                    const SkPoint* lineStart = fReducePts.end() - 2;
+                    *fExtra.append() = fCurrentContour->addLine(lineStart);
                     break;
                 }
                 if (reducedVerb == 2) {
-                    *fExtra.append() = fCurrentContour->addQuad(fReducePts.end() - 3);
+                    const SkPoint* quadStart = fReducePts.end() - 3;
+                    *fExtra.append() = fCurrentContour->addQuad(quadStart);
                     break;
                 }
-                fCurrentContour->addCubic(&pointsPtr[-1]);
-                break;
+                fCurrentContour->addCubic(cubicStart);
+                } break;
             case SkPath::kClose_Verb:
                 SkASSERT(fCurrentContour);
-                if (finalCurveStart && finalCurveEnd
-                        && *finalCurveStart != *finalCurveEnd) {
-                    *fReducePts.append() = *finalCurveStart;
-                    *fReducePts.append() = *finalCurveEnd;
-                    *fExtra.append() = fCurrentContour->addLine(fReducePts.end() - 2);
+                if (!close()) {
+                    return false;
                 }
-                complete();
                 continue;
             default:
                 SkDEBUGFAIL("bad verb");
-                return;
+                return false;
         }
-        finalCurveStart = &pointsPtr[verb - 1];
+        fFinalCurveStart = &pointsPtr[verb - 1];
         pointsPtr += verb;
         SkASSERT(fCurrentContour);
     }
+   if (fCurrentContour && !fAllowOpenContours && !close()) {
+       return false;
+   }
+   return true;
 }