void onDraw(SkCanvas* canvas) override { SkPath path; SkRandom rand; int scale = 300; for (int i = 0; i < 4; ++i) { // get the random values deterministically SkScalar randoms[12]; for (int index = 0; index < (int) SK_ARRAY_COUNT(randoms); ++index) { randoms[index] = rand.nextUScalar1(); } path.lineTo(randoms[0] * scale, randoms[1] * scale); path.quadTo(randoms[2] * scale, randoms[3] * scale, randoms[4] * scale, randoms[5] * scale); path.cubicTo(randoms[6] * scale, randoms[7] * scale, randoms[8] * scale, randoms[9] * scale, randoms[10] * scale, randoms[11] * scale); } path.setFillType(SkPath::kEvenOdd_FillType); path.offset(SkIntToScalar(20), SkIntToScalar(20)); test_hittest(canvas, path); canvas->translate(SkIntToScalar(scale), 0); path.setFillType(SkPath::kWinding_FillType); test_hittest(canvas, path); }
void onDrawContent(SkCanvas* canvas) override { test_huge_stroke(canvas); return; canvas->translate(SkIntToScalar(10), SkIntToScalar(10)); SkPaint paint; paint.setAntiAlias(true); if (true) { canvas->drawColor(SK_ColorBLACK); paint.setTextSize(24); paint.setColor(SK_ColorWHITE); canvas->translate(10, 30); static const SkBlurStyle gStyle[] = { kNormal_SkBlurStyle, kInner_SkBlurStyle, kOuter_SkBlurStyle, kSolid_SkBlurStyle, }; for (int x = 0; x < 5; x++) { SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(4)); for (int y = 0; y < 10; y++) { if (x) { paint.setMaskFilter(SkBlurMaskFilter::Make(gStyle[x - 1], sigma)); } canvas->drawString("Title Bar", x*SkIntToScalar(100), y*SkIntToScalar(30), paint); sigma *= 0.75f; } } return; } paint.setColor(SK_ColorBLUE); #if 1 SkPath p; float r = rand.nextUScalar1() + 0.5f; SkScalar x = 0, y = 0; p.moveTo(x, y); #if 0 p.cubicTo(x-75*r, y+75*r, x-40*r, y+125*r, x, y+85*r); p.cubicTo(x+40*r, y+125*r, x+75*r, y+75*r, x, y); #else p.cubicTo(x+75*r, y+75*r, x+40*r, y+125*r, x, y+85*r); p.cubicTo(x-40*r, y+125*r, x-75*r, y+75*r, x, y); #endif p.close(); fPath = p; fPath.offset(100, 0); #endif fPath.setFillType(SkPath::kWinding_FillType); drawSet(canvas, &paint); canvas->translate(0, fPath.getBounds().height() * 5 / 4); fPath.setFillType(SkPath::kEvenOdd_FillType); drawSet(canvas, &paint); }
static void PathOpsSimplifyFailTest(skiatest::Reporter* reporter) { for (int index = 0; index < (int) (13 * nonFinitePtsCount * finitePtsCount); ++index) { SkPath path; int i = (int) (index % nonFinitePtsCount); int f = (int) (index % finitePtsCount); int g = (int) ((f + 1) % finitePtsCount); switch (index % 13) { case 0: path.lineTo(nonFinitePts[i]); break; case 1: path.quadTo(nonFinitePts[i], nonFinitePts[i]); break; case 2: path.quadTo(nonFinitePts[i], finitePts[f]); break; case 3: path.quadTo(finitePts[f], nonFinitePts[i]); break; case 4: path.cubicTo(nonFinitePts[i], finitePts[f], finitePts[f]); break; case 5: path.cubicTo(finitePts[f], nonFinitePts[i], finitePts[f]); break; case 6: path.cubicTo(finitePts[f], finitePts[f], nonFinitePts[i]); break; case 7: path.cubicTo(nonFinitePts[i], nonFinitePts[i], finitePts[f]); break; case 8: path.cubicTo(nonFinitePts[i], finitePts[f], nonFinitePts[i]); break; case 9: path.cubicTo(finitePts[f], nonFinitePts[i], nonFinitePts[i]); break; case 10: path.cubicTo(nonFinitePts[i], nonFinitePts[i], nonFinitePts[i]); break; case 11: path.cubicTo(nonFinitePts[i], finitePts[f], finitePts[g]); break; case 12: path.moveTo(nonFinitePts[i]); break; } SkPath result; result.setFillType(SkPath::kWinding_FillType); bool success = Simplify(path, &result); REPORTER_ASSERT(reporter, !success); REPORTER_ASSERT(reporter, result.isEmpty()); REPORTER_ASSERT(reporter, result.getFillType() == SkPath::kWinding_FillType); reporter->bumpTestCount(); } if (sizeof(reporter) == 4) { return; } for (int index = 0; index < (int) (11 * finitePtsCount); ++index) { SkPath path; int f = (int) (index % finitePtsCount); int g = (int) ((f + 1) % finitePtsCount); switch (index % 11) { case 0: path.lineTo(finitePts[f]); break; case 1: path.quadTo(finitePts[f], finitePts[f]); break; case 2: path.quadTo(finitePts[f], finitePts[g]); break; case 3: path.quadTo(finitePts[g], finitePts[f]); break; case 4: path.cubicTo(finitePts[f], finitePts[f], finitePts[f]); break; case 5: path.cubicTo(finitePts[f], finitePts[f], finitePts[g]); break; case 6: path.cubicTo(finitePts[f], finitePts[g], finitePts[f]); break; case 7: path.cubicTo(finitePts[f], finitePts[g], finitePts[g]); break; case 8: path.cubicTo(finitePts[g], finitePts[f], finitePts[f]); break; case 9: path.cubicTo(finitePts[g], finitePts[f], finitePts[g]); break; case 10: path.moveTo(finitePts[f]); break; } SkPath result; result.setFillType(SkPath::kWinding_FillType); bool success = Simplify(path, &result); REPORTER_ASSERT(reporter, success); REPORTER_ASSERT(reporter, result.getFillType() != SkPath::kWinding_FillType); reporter->bumpTestCount(); } }
static inline SkPath path_to_sk (cairo_path_fixed_t *path, cairo_fill_rule_t fill_rule, cairo_matrix_t *mat = NULL) { SkPath skPath = path_to_sk (path, mat); if (fill_rule == CAIRO_FILL_RULE_EVEN_ODD) skPath.setFillType (SkPath::kEvenOdd_FillType); else skPath.setFillType (SkPath::kWinding_FillType); return skPath; }
void drawMask(SkCanvas* canvas, const SkRect& r) { SkPaint paint; paint.setAntiAlias(true); if (true) { SkBitmap mask; int w = SkScalarRoundToInt(r.width()); int h = SkScalarRoundToInt(r.height()); mask.allocN32Pixels(w, h); mask.eraseColor(SK_ColorTRANSPARENT); SkCanvas c(mask); SkRect bounds = r; bounds.offset(-bounds.fLeft, -bounds.fTop); c.drawOval(bounds, paint); paint.setBlendMode(SkBlendMode::kDstIn); canvas->drawBitmap(mask, r.fLeft, r.fTop, &paint); } else { SkPath p; p.addOval(r); p.setFillType(SkPath::kInverseWinding_FillType); paint.setBlendMode(SkBlendMode::kDstOut); canvas->drawPath(p, paint); } }
bool PlatformGraphicsContextSkia::clipPath(const Path& pathToClip, WindRule clipRule) { SkPath path = *pathToClip.platformPath(); path.setFillType(clipRule == RULE_EVENODD ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType); return mCanvas->clipPath(path); }
void drawMask(SkCanvas* canvas, const SkRect& r) { SkPaint paint; paint.setAntiAlias(true); if (true) { SkBitmap mask; int w = SkScalarRound(r.width()); int h = SkScalarRound(r.height()); mask.setConfig(SkBitmap::kARGB_8888_Config, w, h); mask.allocPixels(); mask.eraseColor(0); SkCanvas c(mask); SkRect bounds = r; bounds.offset(-bounds.fLeft, -bounds.fTop); c.drawOval(bounds, paint); paint.setXfermodeMode(SkXfermode::kDstIn_Mode); canvas->drawBitmap(mask, r.fLeft, r.fTop, &paint); } else { SkPath p; p.addOval(r); p.setFillType(SkPath::kInverseWinding_FillType); paint.setXfermodeMode(SkXfermode::kDstOut_Mode); canvas->drawPath(p, paint); } }
SkPath SubsetVerbs::getSubsetPath() const { SkPath result; result.setFillType(fPath.getFillType()); if (!fSelected.count()) { return result; } SkPath::RawIter iter(fPath); uint8_t verb; SkPoint pts[4]; int verbIndex = 0; bool addMoveTo = true; bool addLineTo = false; while ((verb = iter.next(pts)) != SkPath::kDone_Verb) { bool enabled = SkPath::kLine_Verb <= verb && verb <= SkPath::kCubic_Verb ? fSelected[verbIndex++] : false; if (enabled) { if (addMoveTo) { result.moveTo(pts[0]); addMoveTo = false; } else if (addLineTo) { result.lineTo(pts[0]); addLineTo = false; } } switch (verb) { case SkPath::kMove_Verb: break; case SkPath::kLine_Verb: if (enabled) { result.lineTo(pts[1]); } break; case SkPath::kQuad_Verb: if (enabled) { result.quadTo(pts[1], pts[2]); } break; case SkPath::kConic_Verb: if (enabled) { result.conicTo(pts[1], pts[2], iter.conicWeight()); } break; case SkPath::kCubic_Verb: if (enabled) { result.cubicTo(pts[1], pts[2], pts[3]); } break; case SkPath::kClose_Verb: result.close(); addMoveTo = true; addLineTo = false; continue; default: SkDEBUGFAIL("bad verb"); return result; } addLineTo = !enabled; } return result; }
bool testSimplify(SkPath& path, bool useXor, SkPath& out, PathOpsThreadState& state, const char* pathStr) { SkPath::FillType fillType = useXor ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType; path.setFillType(fillType); state.fReporter->bumpTestCount(); if (!Simplify(path, &out)) { SkDebugf("%s did not expect failure\n", __FUNCTION__); REPORTER_ASSERT(state.fReporter, 0); return false; } if (!state.fReporter->verbose()) { return true; } int result = comparePaths(state.fReporter, nullptr, path, out, *state.fBitmap); if (result) { SkAutoMutexAcquire autoM(simplifyDebugOut); char temp[8192]; sk_bzero(temp, sizeof(temp)); SkMemoryWStream stream(temp, sizeof(temp)); const char* pathPrefix = nullptr; const char* nameSuffix = nullptr; if (fillType == SkPath::kEvenOdd_FillType) { pathPrefix = " path.setFillType(SkPath::kEvenOdd_FillType);\n"; nameSuffix = "x"; } const char testFunction[] = "testSimplify(reporter, path);"; outputToStream(pathStr, pathPrefix, nameSuffix, testFunction, false, stream); SkDebugf("%s", temp); REPORTER_ASSERT(state.fReporter, 0); } state.fReporter->bumpTestCount(); return result == 0; }
static void fuzz763_1(skiatest::Reporter* reporter, const char* filename) { SkPath path; path.setFillType((SkPath::FillType) 0); path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 path.cubicTo(SkBits2Float(0xbcb63000), SkBits2Float(0xb6b6b6b7), SkBits2Float(0x38b6b6b6), SkBits2Float(0xafb63a5a), SkBits2Float(0xca000087), SkBits2Float(0xe93ae9e9)); // -0.0222397f, -5.44529e-06f, 8.71247e-05f, -3.31471e-10f, -2.09719e+06f, -1.41228e+25f path.quadTo(SkBits2Float(0xb6007fb6), SkBits2Float(0xb69fb6b6), SkBits2Float(0xe9e964b6), SkBits2Float(0xe9e9e9e9)); // -1.91478e-06f, -4.75984e-06f, -3.52694e+25f, -3.5348e+25f path.quadTo(SkBits2Float(0xb6b6b8b7), SkBits2Float(0xb60000b6), SkBits2Float(0xb6b6b6b6), SkBits2Float(0xe9e92064)); // -5.44553e-06f, -1.90739e-06f, -5.44529e-06f, -3.52291e+25f path.quadTo(SkBits2Float(0x000200e9), SkBits2Float(0xe9e9d100), SkBits2Float(0xe93ae9e9), SkBits2Float(0xe964b6e9)); // 1.83997e-40f, -3.53333e+25f, -1.41228e+25f, -1.72812e+25f path.quadTo(SkBits2Float(0x40b6e9e9), SkBits2Float(0xe9b60000), SkBits2Float(0x00b6b8e9), SkBits2Float(0xe9000001)); // 5.71605f, -2.75031e+25f, 1.67804e-38f, -9.67141e+24f path.quadTo(SkBits2Float(0xe9d3b6b2), SkBits2Float(0x40404540), SkBits2Float(0x803d4043), SkBits2Float(0xe9e9e9ff)); // -3.19933e+25f, 3.00423f, -5.62502e-39f, -3.53481e+25f path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0xe8b3b6b6), SkBits2Float(0xe90a0003), SkBits2Float(0x4040403c), SkBits2Float(0x803d4040), SkBits2Float(0xe9e80900)); // 0, -6.78939e+24f, -1.0427e+25f, 3.00392f, -5.62501e-39f, -3.50642e+25f path.quadTo(SkBits2Float(0xe9e910e9), SkBits2Float(0xe9e93ae9), SkBits2Float(0x0000b6b6), SkBits2Float(0xb6b6aab6)); // -3.52199e+25f, -3.52447e+25f, 6.55443e-41f, -5.4439e-06f path.moveTo(SkBits2Float(0xe9e92064), SkBits2Float(0xe9e9d106)); // -3.52291e+25f, -3.53334e+25f path.quadTo(SkBits2Float(0xe9e93ae9), SkBits2Float(0x0000abb6), SkBits2Float(0xb6b6bdb6), SkBits2Float(0xe92064b6)); // -3.52447e+25f, 6.15983e-41f, -5.44611e-06f, -1.2119e+25f path.quadTo(SkBits2Float(0x0000e9e9), SkBits2Float(0xb6b6b6e9), SkBits2Float(0x05ffff05), SkBits2Float(0xe9ea06e9)); // 8.39112e-41f, -5.44532e-06f, 2.40738e-35f, -3.53652e+25f path.quadTo(SkBits2Float(0xe93ae9e9), SkBits2Float(0x02007fe9), SkBits2Float(0xb8b7b600), SkBits2Float(0xe9e9b6b6)); // -1.41228e+25f, 9.44066e-38f, -8.76002e-05f, -3.53178e+25f path.quadTo(SkBits2Float(0xe9e9e9b6), SkBits2Float(0xedb6b6b6), SkBits2Float(0x5a38a1b6), SkBits2Float(0xe93ae9e9)); // -3.53479e+25f, -7.06839e+27f, 1.29923e+16f, -1.41228e+25f path.quadTo(SkBits2Float(0x0000b6b6), SkBits2Float(0xb6b6b6b6), SkBits2Float(0xe9e9e9b6), SkBits2Float(0xe9e9e954)); // 6.55443e-41f, -5.44529e-06f, -3.53479e+25f, -3.53477e+25f path.quadTo(SkBits2Float(0xb6e9e93a), SkBits2Float(0x375837ff), SkBits2Float(0xceb6b6b6), SkBits2Float(0x0039e94f)); // -6.97109e-06f, 1.28876e-05f, -1.53271e+09f, 5.31832e-39f path.quadTo(SkBits2Float(0xe9e9e9e9), SkBits2Float(0xe9e6e9e9), SkBits2Float(0xb6b641b6), SkBits2Float(0xede9e9e9)); // -3.5348e+25f, -3.48947e+25f, -5.43167e-06f, -9.0491e+27f path.moveTo(SkBits2Float(0xb6b6e9e9), SkBits2Float(0xb6b60000)); // -5.45125e-06f, -5.42402e-06f path.moveTo(SkBits2Float(0xe9b6b6b6), SkBits2Float(0xe9b6b8e9)); // -2.76109e+25f, -2.76122e+25f path.close(); path.moveTo(SkBits2Float(0xe9b6b6b6), SkBits2Float(0xe9b6b8e9)); // -2.76109e+25f, -2.76122e+25f path.quadTo(SkBits2Float(0xe93ae9e9), SkBits2Float(0xe964b6e9), SkBits2Float(0x0000203a), SkBits2Float(0xb6000000)); // -1.41228e+25f, -1.72812e+25f, 1.15607e-41f, -1.90735e-06f path.moveTo(SkBits2Float(0x64b6b6b6), SkBits2Float(0xe9e9e900)); // 2.69638e+22f, -3.53475e+25f path.quadTo(SkBits2Float(0xb6b6b6e9), SkBits2Float(0xb6b6b6b6), SkBits2Float(0xe9e9b6ce), SkBits2Float(0xe9e93ae9)); // -5.44532e-06f, -5.44529e-06f, -3.53179e+25f, -3.52447e+25f testSimplifyFuzz(reporter, path, filename); }
void operate(const SkPath& one, const SkPath& two, ShapeOp op, SkPath& result) { result.reset(); result.setFillType(SkPath::kEvenOdd_FillType); // turn path into list of segments SkTArray<Op::Contour> contours; // FIXME: add self-intersecting cubics' T values to segment Op::EdgeBuilder builder(one, contours); const int aXorMask = builder.xorMask(); builder.addOperand(two); const int bXorMask = builder.xorMask(); builder.finish(); SkTDArray<Op::Contour*> contourList; makeContourList(contours, contourList); Op::Contour** currentPtr = contourList.begin(); if (!currentPtr) { return; } Op::Contour** listEnd = contourList.end(); // find all intersections between segments do { Op::Contour** nextPtr = currentPtr; Op::Contour* current = *currentPtr++; Op::Contour* next; do { next = *nextPtr++; } while (addIntersectTs(current, next) && nextPtr != listEnd); } while (currentPtr != listEnd); // eat through coincident edges coincidenceCheck(contourList); fixOtherTIndex(contourList); // construct closed contours Op::PathWrapper wrapper(result); bridgeOp(contourList, op, aXorMask, bXorMask, wrapper); }
bool testSimplifyx(SkPath& path, bool useXor, SkPath& out, State4& state, const char* pathStr) { SkPath::FillType fillType = useXor ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType; path.setFillType(fillType); if (gShowPath) { showPath(path); } simplifyx(path, out); if (!gComparePaths) { return true; } int result = comparePaths(path, out, state.bitmap); if (result && gPathStrAssert) { SkDebugf("addTest %s\n", state.filename); char temp[8192]; bzero(temp, sizeof(temp)); SkMemoryWStream stream(temp, sizeof(temp)); const char* pathPrefix = NULL; const char* nameSuffix = NULL; if (fillType == SkPath::kEvenOdd_FillType) { pathPrefix = " path.setFillType(SkPath::kEvenOdd_FillType);\n"; nameSuffix = "x"; } const char testFunction[] = "testSimplifyx(path);"; outputToStream(state, pathStr, pathPrefix, nameSuffix, testFunction, stream); SkDebugf(temp); SkASSERT(0); } return result == 0; }
/* Two invariants are tested: How does an empty/degenerate path draw? * - if the path is drawn inverse, it should draw everywhere * - if the path is drawn non-inverse, it should draw nowhere * * Things to iterate on: * - path (empty, degenerate line/quad/cubic w/ and w/o close * - paint style * - path filltype * - path stroke variants (e.g. caps, joins, width) */ static void test_emptydrawing(skiatest::Reporter* reporter) { static void (*gMakeProc[])(SkPath*) = { make_empty, make_M, make_MM, make_MZM, make_L, make_Q, make_C }; static SkPath::FillType gFills[] = { SkPath::kWinding_FillType, SkPath::kEvenOdd_FillType, SkPath::kInverseWinding_FillType, SkPath::kInverseEvenOdd_FillType }; for (int doClose = 0; doClose < 2; ++doClose) { for (size_t i = 0; i < SK_ARRAY_COUNT(gMakeProc); ++i) { SkPath path; gMakeProc[i](&path); if (doClose) { path.close(); } for (size_t fill = 0; fill < SK_ARRAY_COUNT(gFills); ++fill) { path.setFillType(gFills[fill]); bool shouldDraw = path.isInverseFillType(); iter_paint(reporter, path, shouldDraw); } } } }
void draw_fill(SkCanvas* canvas, const SkRect& rect, SkScalar width) { if (rect.isEmpty()) { return; } SkPaint paint; paint.setColor(0x1f1f0f0f); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(width); SkPath path; SkScalar maxSide = SkTMax(rect.width(), rect.height()) / 2; SkPoint center = { rect.fLeft + maxSide, rect.fTop + maxSide }; path.addCircle(center.fX, center.fY, maxSide); canvas->drawPath(path, paint); paint.setStyle(SkPaint::kFill_Style); path.reset(); path.addCircle(center.fX, center.fY, maxSide - width / 2); paint.setColor(0x3f0f1f3f); canvas->drawPath(path, paint); path.reset(); path.setFillType(SkPath::kEvenOdd_FillType); path.addCircle(center.fX, center.fY, maxSide + width / 2); SkRect outside = SkRect::MakeXYWH(center.fX - maxSide - width, center.fY - maxSide - width, (maxSide + width) * 2, (maxSide + width) * 2); path.addRect(outside); canvas->drawPath(path, paint); }
/** * Draw a single path element of the clip stack into the accumulation bitmap */ void GrSWMaskHelper::draw(const SkPath& clientPath, SkRegion::Op op, GrPathFill fill, bool antiAlias) { SkPaint paint; SkPath tmpPath; const SkPath* pathToDraw = &clientPath; if (kHairLine_PathFill == fill) { paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(SK_Scalar1); } else { paint.setStyle(SkPaint::kFill_Style); SkPath::FillType skfill = gr_fill_to_sk_fill(fill); if (skfill != pathToDraw->getFillType()) { tmpPath = *pathToDraw; tmpPath.setFillType(skfill); pathToDraw = &tmpPath; } } SkXfermode* mode = SkXfermode::Create(op_to_mode(op)); paint.setXfermode(mode); paint.setAntiAlias(antiAlias); paint.setColor(SK_ColorWHITE); fDraw.drawPath(*pathToDraw, paint); SkSafeUnref(mode); }
static void failOne(skiatest::Reporter* reporter, int index) { SkPath path; int i = (int) (index % nonFinitePtsCount); int f = (int) (index % finitePtsCount); int g = (int) ((f + 1) % finitePtsCount); switch (index % 13) { case 0: path.lineTo(nonFinitePts[i]); break; case 1: path.quadTo(nonFinitePts[i], nonFinitePts[i]); break; case 2: path.quadTo(nonFinitePts[i], finitePts[f]); break; case 3: path.quadTo(finitePts[f], nonFinitePts[i]); break; case 4: path.cubicTo(nonFinitePts[i], finitePts[f], finitePts[f]); break; case 5: path.cubicTo(finitePts[f], nonFinitePts[i], finitePts[f]); break; case 6: path.cubicTo(finitePts[f], finitePts[f], nonFinitePts[i]); break; case 7: path.cubicTo(nonFinitePts[i], nonFinitePts[i], finitePts[f]); break; case 8: path.cubicTo(nonFinitePts[i], finitePts[f], nonFinitePts[i]); break; case 9: path.cubicTo(finitePts[f], nonFinitePts[i], nonFinitePts[i]); break; case 10: path.cubicTo(nonFinitePts[i], nonFinitePts[i], nonFinitePts[i]); break; case 11: path.cubicTo(nonFinitePts[i], finitePts[f], finitePts[g]); break; case 12: path.moveTo(nonFinitePts[i]); break; } SkPath result; result.setFillType(SkPath::kWinding_FillType); bool success = Simplify(path, &result); REPORTER_ASSERT(reporter, !success); REPORTER_ASSERT(reporter, result.isEmpty()); REPORTER_ASSERT(reporter, result.getFillType() == SkPath::kWinding_FillType); reporter->bumpTestCount(); }
static void fuzz763_2s(skiatest::Reporter* reporter, const char* filename) { SkPath path; path.setFillType((SkPath::FillType) 0); path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 path.cubicTo(SkBits2Float(0x76773011), SkBits2Float(0x5d66fe78), SkBits2Float(0xbbeeff66), SkBits2Float(0x637677a2), SkBits2Float(0x205266fe), SkBits2Float(0xec296fdf)); // 1.25339e+33f, 1.0403e+18f, -0.00729363f, 4.54652e+21f, 1.78218e-19f, -8.19347e+26f path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 path.close(); path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 path.quadTo(SkBits2Float(0xec4eecec), SkBits2Float(0x6e6f10ec), SkBits2Float(0xb6b6ecf7), SkBits2Float(0xb6b6b6b6)); // -1.00063e+27f, 1.84968e+28f, -5.45161e-06f, -5.44529e-06f path.moveTo(SkBits2Float(0x002032b8), SkBits2Float(0xecfeb6b6)); // 2.95693e-39f, -2.46344e+27f path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f path.cubicTo(SkBits2Float(0x1616ece4), SkBits2Float(0xdf020018), SkBits2Float(0x77772965), SkBits2Float(0x1009db73), SkBits2Float(0x80ececec), SkBits2Float(0xf7ffffff)); // 1.21917e-25f, -9.36751e+18f, 5.01303e+33f, 2.71875e-29f, -2.17582e-38f, -1.03846e+34f path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f path.close(); path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f path.conicTo(SkBits2Float(0xec0700ec), SkBits2Float(0xecececec), SkBits2Float(0xececccec), SkBits2Float(0x772965ec), SkBits2Float(0x77777377)); // -6.52837e+26f, -2.2914e+27f, -2.29019e+27f, 3.4358e+33f, 5.0189e+33f path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f path.close(); path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f path.quadTo(SkBits2Float(0x29ec02ec), SkBits2Float(0x1009ecec), SkBits2Float(0x80ececec), SkBits2Float(0xf7ffffff)); // 1.0481e-13f, 2.7201e-29f, -2.17582e-38f, -1.03846e+34f path.lineTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f path.close(); path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f path.conicTo(SkBits2Float(0xff003aff), SkBits2Float(0xdbec2300), SkBits2Float(0xecececec), SkBits2Float(0x6fdf6052), SkBits2Float(0x41ecec29)); // -1.70448e+38f, -1.32933e+17f, -2.2914e+27f, 1.38263e+29f, 29.6153f path.lineTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f path.close(); path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f path.quadTo(SkBits2Float(0xecf76e6f), SkBits2Float(0xeccfddec), SkBits2Float(0xecececcc), SkBits2Float(0x66000066)); // -2.39301e+27f, -2.01037e+27f, -2.2914e+27f, 1.51118e+23f path.lineTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f path.close(); path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f path.cubicTo(SkBits2Float(0x772965df), SkBits2Float(0x77777377), SkBits2Float(0x77777876), SkBits2Float(0x665266fe), SkBits2Float(0xecececdf), SkBits2Float(0x0285806e)); // 3.4358e+33f, 5.0189e+33f, 5.0193e+33f, 2.48399e+23f, -2.2914e+27f, 1.96163e-37f path.lineTo(SkBits2Float(0xecececeb), SkBits2Float(0xecec0700)); // -2.2914e+27f, -2.28272e+27f path.lineTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f path.close(); path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f path.lineTo(SkBits2Float(0x65ecfaec), SkBits2Float(0xde777729)); // 1.39888e+23f, -4.45794e+18f path.conicTo(SkBits2Float(0x74777777), SkBits2Float(0x66fe7876), SkBits2Float(0xecdf6660), SkBits2Float(0x726eecec), SkBits2Float(0x29d610ec)); // 7.84253e+31f, 6.00852e+23f, -2.16059e+27f, 4.73241e+30f, 9.50644e-14f path.lineTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f path.close(); path.moveTo(SkBits2Float(0xd0ecec10), SkBits2Float(0x6e6eecdb)); // -3.17991e+10f, 1.84859e+28f path.quadTo(SkBits2Float(0x003affec), SkBits2Float(0xec2300ef), SkBits2Float(0xecececdb), SkBits2Float(0xcfececec)); // 5.41827e-39f, -7.88237e+26f, -2.2914e+27f, -7.9499e+09f path.lineTo(SkBits2Float(0xd0ecec10), SkBits2Float(0x6e6eecdb)); // -3.17991e+10f, 1.84859e+28f path.close(); path.moveTo(SkBits2Float(0xd0ecec10), SkBits2Float(0x6e6eecdb)); // -3.17991e+10f, 1.84859e+28f path.quadTo(SkBits2Float(0xecccec80), SkBits2Float(0xfa66ecec), SkBits2Float(0x66fa0000), SkBits2Float(0x772965df)); // -1.9819e+27f, -2.99758e+35f, 5.90296e+23f, 3.4358e+33f path.moveTo(SkBits2Float(0x77777790), SkBits2Float(0x00807677)); // 5.01923e+33f, 1.17974e-38f path.close(); path.moveTo(SkBits2Float(0x77777790), SkBits2Float(0x00807677)); // 5.01923e+33f, 1.17974e-38f path.cubicTo(SkBits2Float(0xecececec), SkBits2Float(0xfe66eaec), SkBits2Float(0xecdf1452), SkBits2Float(0x806eecec), SkBits2Float(0x10ececec), SkBits2Float(0xec000000)); // -2.2914e+27f, -7.67356e+37f, -2.15749e+27f, -1.01869e-38f, 9.34506e-29f, -6.1897e+26f path.lineTo(SkBits2Float(0x77777790), SkBits2Float(0x00807677)); // 5.01923e+33f, 1.17974e-38f path.close(); path.moveTo(SkBits2Float(0x77777790), SkBits2Float(0x00807677)); // 5.01923e+33f, 1.17974e-38f path.cubicTo(SkBits2Float(0x52668062), SkBits2Float(0x2965df66), SkBits2Float(0x77777377), SkBits2Float(0x76777773), SkBits2Float(0x1697fe78), SkBits2Float(0xeebfff00)); // 2.47499e+11f, 5.1042e-14f, 5.0189e+33f, 1.2548e+33f, 2.4556e-25f, -2.971e+28f path.lineTo(SkBits2Float(0x77777790), SkBits2Float(0x00807677)); // 5.01923e+33f, 1.17974e-38f path.close(); testSimplifyFuzz(reporter, path, filename); }
SkRect draw(SkCanvas* canvas, const SkPaint& paint) override { SkPath path; path.addCircle(15, 15, 10); path.addOval(SkRect::MakeXYWH(2, 2, 22, 37)); path.setFillType(SkPath::kEvenOdd_FillType); canvas->drawPath(path, paint); return path.getBounds(); }
SkPath SubsetContours::getSubsetPath() const { SkPath result; result.setFillType(fPath.getFillType()); if (!fSelected.count()) { return result; } SkPath::RawIter iter(fPath); uint8_t verb; SkPoint pts[4]; int contourCount = 0; bool enabled = fSelected[0]; bool addMoveTo = true; while ((verb = iter.next(pts)) != SkPath::kDone_Verb) { if (enabled && addMoveTo) { result.moveTo(pts[0]); addMoveTo = false; } switch (verb) { case SkPath::kMove_Verb: break; case SkPath::kLine_Verb: if (enabled) { result.lineTo(pts[1]); } break; case SkPath::kQuad_Verb: if (enabled) { result.quadTo(pts[1], pts[2]); } break; case SkPath::kConic_Verb: if (enabled) { result.conicTo(pts[1], pts[2], iter.conicWeight()); } break; case SkPath::kCubic_Verb: if (enabled) { result.cubicTo(pts[1], pts[2], pts[3]); } break; case SkPath::kClose_Verb: if (enabled) { result.close(); } if (++contourCount >= fSelected.count()) { break; } enabled = fSelected[contourCount]; addMoveTo = true; continue; default: SkDEBUGFAIL("bad verb"); return result; } } return result; }
void GraphicsContext::clipPath(WindRule clipRule) { if (paintingDisabled()) return; SkPath path = platformContext()->currentPathInLocalCoordinates(); path.setFillType(clipRule == RULE_EVENODD ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType); platformContext()->canvas()->clipPath(path); }
SkPath SkSVGPoly::onAsPath(const SkSVGRenderContext& ctx) const { SkPath path = fPath; // clip-rule can be inherited and needs to be applied at clip time. path.setFillType(ctx.presentationContext().fInherited.fClipRule.get()->asFillType()); this->mapToParent(&path); return path; }
// Two pictures with an inverse clip path on the second one static void invpath_clip(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) { canvas->drawPicture(pictures[0]); // Create a hexagon centered on the middle of the hex grid SkPath hex = make_hex_path((kNumHexX / 2.0f) * kHexSide, kNumHexY * kHexSide * kRoot3Over2); hex.setFillType(SkPath::kInverseEvenOdd_FillType); canvas->clipPath(hex); canvas->drawPicture(pictures[1]); }
static void fuzz_x3(skiatest::Reporter* reporter, const char* filename) { SkPath path; path.setFillType(SkPath::kWinding_FillType); path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0 path.cubicTo(SkBits2Float(0x92743420), SkBits2Float(0x74747474), SkBits2Float(0x0f747c74), SkBits2Float(0xff538565), SkBits2Float(0x74744374), SkBits2Float(0x20437474)); // -7.70571e-28f, 7.74708e+31f, 1.20541e-29f, -2.8116e+38f, 7.74102e+31f, 1.65557e-19f path.conicTo(SkBits2Float(0x7474926d), SkBits2Float(0x7c747474), SkBits2Float(0x00170f74), SkBits2Float(0x3a7410d7), SkBits2Float(0x3a3a3a3a)); // 7.7508e+31f, 5.07713e+36f, 2.11776e-39f, 0.000931037f, 0.000710401f path.quadTo(SkBits2Float(0x203a3a3a), SkBits2Float(0x7459f43a), SkBits2Float(0x74747474), SkBits2Float(0x2043ad6e)); // 1.57741e-19f, 6.90724e+31f, 7.74708e+31f, 1.65745e-19f path.conicTo(SkBits2Float(0x7474b374), SkBits2Float(0x74747474), SkBits2Float(0x0f747c74), SkBits2Float(0xff537065), SkBits2Float(0x74744374)); // 7.75488e+31f, 7.74708e+31f, 1.20541e-29f, -2.81051e+38f, 7.74102e+31f path.cubicTo(SkBits2Float(0x3a3a3a3a), SkBits2Float(0x3a2c103a), SkBits2Float(0x7474263a), SkBits2Float(0x74976507), SkBits2Float(0x000000ff), SkBits2Float(0x00000000)); // 0.000710401f, 0.00065637f, 7.7374e+31f, 9.59578e+31f, 3.57331e-43f, 0 testSimplifyFuzz(reporter, path, filename); }
void SkBaseDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) { SkPath path; path.addRRect(outer); path.addRRect(inner); path.setFillType(SkPath::kEvenOdd_FillType); const SkMatrix* preMatrix = nullptr; const bool pathIsMutable = true; this->drawPath(draw, path, paint, preMatrix, pathIsMutable); }
/** * Called on a background thread. Here we can only modify fBackPaths. */ void runAnimationTask(double t, double dt, int w, int h) override { const float tsec = static_cast<float>(t); this->INHERITED::runAnimationTask(t, 0.5 * dt, w, h); for (int i = 0; i < kNumPaths; ++i) { const Glyph& glyph = fGlyphs[i]; const SkMatrix& backMatrix = fBackMatrices[i]; const Sk2f matrix[3] = { Sk2f(backMatrix.getScaleX(), backMatrix.getSkewY()), Sk2f(backMatrix.getSkewX(), backMatrix.getScaleY()), Sk2f(backMatrix.getTranslateX(), backMatrix.getTranslateY()) }; SkPath* backpath = &fBackPaths[i]; backpath->reset(); backpath->setFillType(SkPath::kEvenOdd_FillType); SkPath::RawIter iter(glyph.fPath); SkPath::Verb verb; SkPoint pts[4]; while ((verb = iter.next(pts)) != SkPath::kDone_Verb) { switch (verb) { case SkPath::kMove_Verb: { SkPoint pt = fWaves.apply(tsec, matrix, pts[0]); backpath->moveTo(pt.x(), pt.y()); break; } case SkPath::kLine_Verb: { SkPoint endpt = fWaves.apply(tsec, matrix, pts[1]); backpath->lineTo(endpt.x(), endpt.y()); break; } case SkPath::kQuad_Verb: { SkPoint controlPt = fWaves.apply(tsec, matrix, pts[1]); SkPoint endpt = fWaves.apply(tsec, matrix, pts[2]); backpath->quadTo(controlPt.x(), controlPt.y(), endpt.x(), endpt.y()); break; } case SkPath::kClose_Verb: { backpath->close(); break; } case SkPath::kCubic_Verb: case SkPath::kConic_Verb: case SkPath::kDone_Verb: SK_ABORT("Unexpected path verb"); break; } } } }
void GraphicsContext::clipPath(WindRule clipRule) { if (paintingDisabled()) return; SkPath path = platformContext()->currentPathInLocalCoordinates(); if (!isPathSkiaSafe(getCTM(), path)) return; path.setFillType(clipRule == RULE_EVENODD ? SkPath::kEvenOdd_FillType : SkPath::kWinding_FillType); platformContext()->clipPathAntiAliased(path); }
static bool innerPathOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b, const SkPathOp shapeOp, const char* testName, bool threaded) { #if DEBUG_SHOW_TEST_NAME if (testName == NULL) { SkDebugf("\n"); showPathData(a); showOp(shapeOp); showPathData(b); } else { SkPathOpsDebug::ShowPath(a, b, shapeOp, testName); } #endif SkPath out; if (!Op(a, b, shapeOp, &out) ) { SkDebugf("%s did not expect failure\n", __FUNCTION__); REPORTER_ASSERT(reporter, 0); return false; } if (threaded && !reporter->verbose()) { return true; } SkPath pathOut, scaledPathOut; SkRegion rgnA, rgnB, openClip, rgnOut; openClip.setRect(-16000, -16000, 16000, 16000); rgnA.setPath(a, openClip); rgnB.setPath(b, openClip); rgnOut.op(rgnA, rgnB, (SkRegion::Op) shapeOp); rgnOut.getBoundaryPath(&pathOut); SkMatrix scale; scaleMatrix(a, b, scale); SkRegion scaledRgnA, scaledRgnB, scaledRgnOut; SkPath scaledA, scaledB; scaledA.addPath(a, scale); scaledA.setFillType(a.getFillType()); scaledB.addPath(b, scale); scaledB.setFillType(b.getFillType()); scaledRgnA.setPath(scaledA, openClip); scaledRgnB.setPath(scaledB, openClip); scaledRgnOut.op(scaledRgnA, scaledRgnB, (SkRegion::Op) shapeOp); scaledRgnOut.getBoundaryPath(&scaledPathOut); SkBitmap bitmap; SkPath scaledOut; scaledOut.addPath(out, scale); scaledOut.setFillType(out.getFillType()); int result = comparePaths(reporter, pathOut, scaledPathOut, out, scaledOut, bitmap, a, b, shapeOp, scale); if (result && gPathStrAssert) { REPORTER_ASSERT(reporter, 0); } reporter->bumpTestCount(); return result == 0; }
DEF_TEST(SkOpBuilderFuzz665, reporter) { SkPath path; path.setFillType(SkPath::kEvenOdd_FillType); path.moveTo(SkBits2Float(0xcc4264a7), SkBits2Float(0x4bb12e50)); // -5.0959e+07f, 2.32235e+07f path.lineTo(SkBits2Float(0xcc4264b0), SkBits2Float(0x4bb12e48)); // -5.0959e+07f, 2.32234e+07f path.lineTo(SkBits2Float(0xcc4264a7), SkBits2Float(0x4bb12e50)); // -5.0959e+07f, 2.32235e+07f path.close(); SkPath path1(path); path.reset(); path.setFillType(SkPath::kWinding_FillType); path.moveTo(SkBits2Float(0x43213333), SkBits2Float(0x43080000)); // 161.2f, 136 path.lineTo(SkBits2Float(0x43038000), SkBits2Float(0x43080000)); // 131.5f, 136 path.cubicTo(SkBits2Float(0x43038000), SkBits2Float(0x42f00000), SkBits2Float(0x42f16666), SkBits2Float(0x42d53333), SkBits2Float(0x42d3cccd), SkBits2Float(0x42cd6666)); // 131.5f, 120, 120.7f, 106.6f, 105.9f, 102.7f path.lineTo(SkBits2Float(0x42e33333), SkBits2Float(0x42940000)); // 113.6f, 74 SkPath path2(path); SkOpBuilder builder; builder.add(path1, kUnion_SkPathOp); builder.add(path2, kUnion_SkPathOp); SkPath result; builder.resolve(&result); }
AAClipRegionBench(void* param) : INHERITED(param) { SkPath path; // test conversion of a complex clip to a aaclip path.addCircle(0, 0, SkIntToScalar(200)); path.addCircle(0, 0, SkIntToScalar(180)); // evenodd means we've constructed basically a stroked circle path.setFillType(SkPath::kEvenOdd_FillType); SkIRect bounds; path.getBounds().roundOut(&bounds); fRegion.setPath(path, SkRegion(bounds)); }
static bool innerPathOp(skiatest::Reporter* reporter, const SkPath& a, const SkPath& b, const SkPathOp shapeOp, const char* testName, ExpectSuccess expectSuccess, SkipAssert skipAssert, ExpectMatch expectMatch) { #if 0 && DEBUG_SHOW_TEST_NAME showName(a, b, shapeOp); #endif SkPath out; if (!OpDebug(a, b, shapeOp, &out SkDEBUGPARAMS(SkipAssert::kYes == skipAssert) SkDEBUGPARAMS(testName))) { if (ExpectSuccess::kYes == expectSuccess) { SkDebugf("%s %s did not expect failure\n", __FUNCTION__, testName); REPORTER_ASSERT(reporter, 0); } return false; } else { if (ExpectSuccess::kNo == expectSuccess) { SkDebugf("%s %s unexpected success\n", __FUNCTION__, testName); REPORTER_ASSERT(reporter, 0); } } if (!reporter->verbose()) { return true; } SkPath pathOut, scaledPathOut; SkRegion rgnA, rgnB, openClip, rgnOut; openClip.setRect(-16000, -16000, 16000, 16000); rgnA.setPath(a, openClip); rgnB.setPath(b, openClip); rgnOut.op(rgnA, rgnB, (SkRegion::Op) shapeOp); rgnOut.getBoundaryPath(&pathOut); SkMatrix scale; scaleMatrix(a, b, scale); SkRegion scaledRgnA, scaledRgnB, scaledRgnOut; SkPath scaledA, scaledB; scaledA.addPath(a, scale); scaledA.setFillType(a.getFillType()); scaledB.addPath(b, scale); scaledB.setFillType(b.getFillType()); scaledRgnA.setPath(scaledA, openClip); scaledRgnB.setPath(scaledB, openClip); scaledRgnOut.op(scaledRgnA, scaledRgnB, (SkRegion::Op) shapeOp); scaledRgnOut.getBoundaryPath(&scaledPathOut); SkBitmap bitmap; SkPath scaledOut; scaledOut.addPath(out, scale); scaledOut.setFillType(out.getFillType()); int result = comparePaths(reporter, testName, pathOut, scaledPathOut, out, scaledOut, bitmap, a, b, shapeOp, scale, ExpectMatch::kYes == expectMatch); reporter->bumpTestCount(); return result == 0; }