| /* |
| * Copyright 2011 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "SkBlurMask.h" |
| #include "SkBlurMaskFilter.h" |
| #include "SkBlurDrawLooper.h" |
| #include "SkBlurPriv.h" |
| #include "SkCanvas.h" |
| #include "SkColorFilter.h" |
| #include "SkColorPriv.h" |
| #include "SkEmbossMaskFilter.h" |
| #include "SkLayerDrawLooper.h" |
| #include "SkMaskFilterBase.h" |
| #include "SkMath.h" |
| #include "SkPaint.h" |
| #include "SkPath.h" |
| #include "SkPerlinNoiseShader.h" |
| #include "SkSurface.h" |
| #include "Test.h" |
| |
| #if SK_SUPPORT_GPU |
| #include "GrContextFactory.h" |
| #include "SkGpuDevice.h" |
| #endif |
| |
| #define WRITE_CSV 0 |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| #define ILLEGAL_MODE ((SkXfermode::Mode)-1) |
| |
| static const int outset = 100; |
| static const SkColor bgColor = SK_ColorWHITE; |
| static const int strokeWidth = 4; |
| |
| static void create(SkBitmap* bm, const SkIRect& bound) { |
| bm->allocN32Pixels(bound.width(), bound.height()); |
| } |
| |
| static void drawBG(SkCanvas* canvas) { |
| canvas->drawColor(bgColor); |
| } |
| |
| |
| struct BlurTest { |
| void (*addPath)(SkPath*); |
| int viewLen; |
| SkIRect views[9]; |
| }; |
| |
| //Path Draw Procs |
| //Beware that paths themselves my draw differently depending on the clip. |
| static void draw50x50Rect(SkPath* path) { |
| path->addRect(0, 0, SkIntToScalar(50), SkIntToScalar(50)); |
| } |
| |
| //Tests |
| static BlurTest tests[] = { |
| { draw50x50Rect, 3, { |
| //inner half of blur |
| { 0, 0, 50, 50 }, |
| //blur, but no path. |
| { 50 + strokeWidth/2, 50 + strokeWidth/2, 100, 100 }, |
| //just an edge |
| { 40, strokeWidth, 60, 50 - strokeWidth }, |
| }}, |
| }; |
| |
| /** Assumes that the ref draw was completely inside ref canvas -- |
| implies that everything outside is "bgColor". |
| Checks that all overlap is the same and that all non-overlap on the |
| ref is "bgColor". |
| */ |
| static bool compare(const SkBitmap& ref, const SkIRect& iref, |
| const SkBitmap& test, const SkIRect& itest) |
| { |
| const int xOff = itest.fLeft - iref.fLeft; |
| const int yOff = itest.fTop - iref.fTop; |
| |
| for (int y = 0; y < test.height(); ++y) { |
| for (int x = 0; x < test.width(); ++x) { |
| SkColor testColor = test.getColor(x, y); |
| int refX = x + xOff; |
| int refY = y + yOff; |
| SkColor refColor; |
| if (refX >= 0 && refX < ref.width() && |
| refY >= 0 && refY < ref.height()) |
| { |
| refColor = ref.getColor(refX, refY); |
| } else { |
| refColor = bgColor; |
| } |
| if (refColor != testColor) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| DEF_TEST(BlurDrawing, reporter) { |
| SkPaint paint; |
| paint.setColor(SK_ColorGRAY); |
| paint.setStyle(SkPaint::kStroke_Style); |
| paint.setStrokeWidth(SkIntToScalar(strokeWidth)); |
| |
| SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5)); |
| for (int style = 0; style <= kLastEnum_SkBlurStyle; ++style) { |
| SkBlurStyle blurStyle = static_cast<SkBlurStyle>(style); |
| |
| const uint32_t flagPermutations = SkBlurMaskFilter::kAll_BlurFlag; |
| for (uint32_t flags = 0; flags < flagPermutations; ++flags) { |
| paint.setMaskFilter(SkBlurMaskFilter::Make(blurStyle, sigma, flags)); |
| |
| for (size_t test = 0; test < SK_ARRAY_COUNT(tests); ++test) { |
| SkPath path; |
| tests[test].addPath(&path); |
| SkPath strokedPath; |
| paint.getFillPath(path, &strokedPath); |
| SkRect refBound = strokedPath.getBounds(); |
| SkIRect iref; |
| refBound.roundOut(&iref); |
| iref.inset(-outset, -outset); |
| SkBitmap refBitmap; |
| create(&refBitmap, iref); |
| |
| SkCanvas refCanvas(refBitmap); |
| refCanvas.translate(SkIntToScalar(-iref.fLeft), |
| SkIntToScalar(-iref.fTop)); |
| drawBG(&refCanvas); |
| refCanvas.drawPath(path, paint); |
| |
| for (int view = 0; view < tests[test].viewLen; ++view) { |
| SkIRect itest = tests[test].views[view]; |
| SkBitmap testBitmap; |
| create(&testBitmap, itest); |
| |
| SkCanvas testCanvas(testBitmap); |
| testCanvas.translate(SkIntToScalar(-itest.fLeft), |
| SkIntToScalar(-itest.fTop)); |
| drawBG(&testCanvas); |
| testCanvas.drawPath(path, paint); |
| |
| REPORTER_ASSERT(reporter, |
| compare(refBitmap, iref, testBitmap, itest)); |
| } |
| } |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| // Use SkBlurMask::BlurGroundTruth to blur a 'width' x 'height' solid |
| // white rect. Return the right half of the middle row in 'result'. |
| static void ground_truth_2d(int width, int height, |
| SkScalar sigma, |
| int* result, int resultCount) { |
| SkMask src, dst; |
| |
| src.fBounds.set(0, 0, width, height); |
| src.fFormat = SkMask::kA8_Format; |
| src.fRowBytes = src.fBounds.width(); |
| src.fImage = SkMask::AllocImage(src.computeTotalImageSize()); |
| |
| memset(src.fImage, 0xff, src.computeTotalImageSize()); |
| |
| if (!SkBlurMask::BlurGroundTruth(sigma, &dst, src, kNormal_SkBlurStyle)) { |
| return; |
| } |
| |
| int midX = dst.fBounds.centerX(); |
| int midY = dst.fBounds.centerY(); |
| uint8_t* bytes = dst.getAddr8(midX, midY); |
| int i; |
| for (i = 0; i < dst.fBounds.width()-(midX-dst.fBounds.fLeft); ++i) { |
| if (i < resultCount) { |
| result[i] = bytes[i]; |
| } |
| } |
| for ( ; i < resultCount; ++i) { |
| result[i] = 0; |
| } |
| |
| SkMask::FreeImage(src.fImage); |
| SkMask::FreeImage(dst.fImage); |
| } |
| |
| // Implement a step function that is 255 between min and max; 0 elsewhere. |
| static int step(int x, SkScalar min, SkScalar max) { |
| if (min < x && x < max) { |
| return 255; |
| } |
| return 0; |
| } |
| |
| // Implement a Gaussian function with 0 mean and std.dev. of 'sigma'. |
| static float gaussian(int x, SkScalar sigma) { |
| float k = SK_Scalar1/(sigma * sqrtf(2.0f*SK_ScalarPI)); |
| float exponent = -(x * x) / (2 * sigma * sigma); |
| return k * expf(exponent); |
| } |
| |
| // Perform a brute force convolution of a step function with a Gaussian. |
| // Return the right half in 'result' |
| static void brute_force_1d(SkScalar stepMin, SkScalar stepMax, |
| SkScalar gaussianSigma, |
| int* result, int resultCount) { |
| |
| int gaussianRange = SkScalarCeilToInt(10 * gaussianSigma); |
| |
| for (int i = 0; i < resultCount; ++i) { |
| SkScalar sum = 0.0f; |
| for (int j = -gaussianRange; j < gaussianRange; ++j) { |
| sum += gaussian(j, gaussianSigma) * step(i-j, stepMin, stepMax); |
| } |
| |
| result[i] = SkClampMax(SkClampPos(int(sum + 0.5f)), 255); |
| } |
| } |
| |
| static void blur_path(SkCanvas* canvas, const SkPath& path, |
| SkScalar gaussianSigma) { |
| |
| SkScalar midX = path.getBounds().centerX(); |
| SkScalar midY = path.getBounds().centerY(); |
| |
| canvas->translate(-midX, -midY); |
| |
| SkPaint blurPaint; |
| blurPaint.setColor(SK_ColorWHITE); |
| blurPaint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, gaussianSigma, |
| SkBlurMaskFilter::kHighQuality_BlurFlag)); |
| |
| canvas->drawColor(SK_ColorBLACK); |
| canvas->drawPath(path, blurPaint); |
| } |
| |
| // Readback the blurred draw results from the canvas |
| static void readback(const SkBitmap& src, int* result, int resultCount) { |
| SkBitmap readback; |
| readback.allocN32Pixels(resultCount, 30); |
| SkPixmap pm; |
| readback.peekPixels(&pm); |
| src.readPixels(pm, 0, 0); |
| |
| const SkPMColor* pixels = pm.addr32(0, 15); |
| |
| for (int i = 0; i < resultCount; ++i) { |
| result[i] = SkColorGetR(pixels[i]); |
| } |
| } |
| |
| // Draw a blurred version of the provided path. |
| // Return the right half of the middle row in 'result'. |
| static void cpu_blur_path(const SkPath& path, SkScalar gaussianSigma, |
| int* result, int resultCount) { |
| |
| SkBitmap bitmap; |
| bitmap.allocN32Pixels(resultCount, 30); |
| SkCanvas canvas(bitmap); |
| |
| blur_path(&canvas, path, gaussianSigma); |
| readback(bitmap, result, resultCount); |
| } |
| |
| #if WRITE_CSV |
| static void write_as_csv(const char* label, SkScalar scale, int* data, int count) { |
| SkDebugf("%s_%.2f,", label, scale); |
| for (int i = 0; i < count-1; ++i) { |
| SkDebugf("%d,", data[i]); |
| } |
| SkDebugf("%d\n", data[count-1]); |
| } |
| #endif |
| |
| static bool match(int* first, int* second, int count, int tol) { |
| int delta; |
| for (int i = 0; i < count; ++i) { |
| delta = first[i] - second[i]; |
| if (delta > tol || delta < -tol) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| // Test out the normal blur style with a wide range of sigmas |
| DEF_TEST(BlurSigmaRange, reporter) { |
| static const int kSize = 100; |
| |
| // The geometry is offset a smidge to trigger: |
| // https://code.google.com/p/chromium/issues/detail?id=282418 |
| SkPath rectPath; |
| rectPath.addRect(0.3f, 0.3f, 100.3f, 100.3f); |
| |
| SkPoint polyPts[] = { |
| { 0.3f, 0.3f }, |
| { 100.3f, 0.3f }, |
| { 100.3f, 100.3f }, |
| { 0.3f, 100.3f }, |
| { 2.3f, 50.3f } // a little divet to throw off the rect special case |
| }; |
| SkPath polyPath; |
| polyPath.addPoly(polyPts, SK_ARRAY_COUNT(polyPts), true); |
| |
| int rectSpecialCaseResult[kSize]; |
| int generalCaseResult[kSize]; |
| int groundTruthResult[kSize]; |
| int bruteForce1DResult[kSize]; |
| |
| SkScalar sigma = 10.0f; |
| |
| for (int i = 0; i < 4; ++i, sigma /= 10) { |
| |
| cpu_blur_path(rectPath, sigma, rectSpecialCaseResult, kSize); |
| cpu_blur_path(polyPath, sigma, generalCaseResult, kSize); |
| |
| ground_truth_2d(100, 100, sigma, groundTruthResult, kSize); |
| brute_force_1d(-50.0f, 50.0f, sigma, bruteForce1DResult, kSize); |
| |
| REPORTER_ASSERT(reporter, match(rectSpecialCaseResult, bruteForce1DResult, kSize, 5)); |
| REPORTER_ASSERT(reporter, match(generalCaseResult, bruteForce1DResult, kSize, 15)); |
| REPORTER_ASSERT(reporter, match(groundTruthResult, bruteForce1DResult, kSize, 1)); |
| |
| #if WRITE_CSV |
| write_as_csv("RectSpecialCase", sigma, rectSpecialCaseResult, kSize); |
| write_as_csv("GeneralCase", sigma, generalCaseResult, kSize); |
| #if SK_SUPPORT_GPU |
| write_as_csv("GPU", sigma, gpuResult, kSize); |
| #endif |
| write_as_csv("GroundTruth2D", sigma, groundTruthResult, kSize); |
| write_as_csv("BruteForce1D", sigma, bruteForce1DResult, kSize); |
| #endif |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |
| |
| static SkBlurQuality blurMaskFilterFlags_as_quality(uint32_t blurMaskFilterFlags) { |
| return (blurMaskFilterFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ? |
| kHigh_SkBlurQuality : kLow_SkBlurQuality; |
| } |
| |
| static void test_blurDrawLooper(skiatest::Reporter* reporter, SkScalar sigma, |
| SkBlurStyle style, uint32_t blurMaskFilterFlags) { |
| if (kNormal_SkBlurStyle != style) { |
| return; // blurdrawlooper only supports normal |
| } |
| |
| const SkColor color = 0xFF335577; |
| const SkScalar dx = 10; |
| const SkScalar dy = -5; |
| sk_sp<SkDrawLooper> lp(SkBlurDrawLooper::Make(color, sigma, dx, dy)); |
| const bool expectSuccess = sigma > 0; |
| |
| if (nullptr == lp) { |
| REPORTER_ASSERT(reporter, sigma <= 0); |
| } else { |
| SkDrawLooper::BlurShadowRec rec; |
| bool success = lp->asABlurShadow(&rec); |
| REPORTER_ASSERT(reporter, success == expectSuccess); |
| if (success) { |
| REPORTER_ASSERT(reporter, rec.fSigma == sigma); |
| REPORTER_ASSERT(reporter, rec.fOffset.x() == dx); |
| REPORTER_ASSERT(reporter, rec.fOffset.y() == dy); |
| REPORTER_ASSERT(reporter, rec.fColor == color); |
| REPORTER_ASSERT(reporter, rec.fStyle == style); |
| REPORTER_ASSERT(reporter, rec.fQuality == kLow_SkBlurQuality); |
| } |
| } |
| } |
| |
| static void test_looper(skiatest::Reporter* reporter, sk_sp<SkDrawLooper> lp, SkScalar sigma, |
| SkBlurStyle style, SkBlurQuality quality, bool expectSuccess) { |
| SkDrawLooper::BlurShadowRec rec; |
| bool success = lp->asABlurShadow(&rec); |
| REPORTER_ASSERT(reporter, success == expectSuccess); |
| if (success != expectSuccess) { |
| lp->asABlurShadow(&rec); |
| } |
| if (success) { |
| REPORTER_ASSERT(reporter, rec.fSigma == sigma); |
| REPORTER_ASSERT(reporter, rec.fStyle == style); |
| REPORTER_ASSERT(reporter, rec.fQuality == quality); |
| } |
| } |
| |
| static void make_noop_layer(SkLayerDrawLooper::Builder* builder) { |
| SkLayerDrawLooper::LayerInfo info; |
| |
| info.fPaintBits = 0; |
| info.fColorMode = SkBlendMode::kDst; |
| builder->addLayer(info); |
| } |
| |
| static void make_blur_layer(SkLayerDrawLooper::Builder* builder, sk_sp<SkMaskFilter> mf) { |
| SkLayerDrawLooper::LayerInfo info; |
| |
| info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit; |
| info.fColorMode = SkBlendMode::kSrc; |
| SkPaint* paint = builder->addLayer(info); |
| paint->setMaskFilter(std::move(mf)); |
| } |
| |
| static void test_layerDrawLooper(skiatest::Reporter* reporter, sk_sp<SkMaskFilter> mf, |
| SkScalar sigma, SkBlurStyle style, SkBlurQuality quality, |
| bool expectSuccess) { |
| |
| SkLayerDrawLooper::LayerInfo info; |
| SkLayerDrawLooper::Builder builder; |
| |
| // 1 layer is too few |
| make_noop_layer(&builder); |
| test_looper(reporter, builder.detach(), sigma, style, quality, false); |
| |
| // 2 layers is good, but need blur |
| make_noop_layer(&builder); |
| make_noop_layer(&builder); |
| test_looper(reporter, builder.detach(), sigma, style, quality, false); |
| |
| // 2 layers is just right |
| make_noop_layer(&builder); |
| make_blur_layer(&builder, mf); |
| test_looper(reporter, builder.detach(), sigma, style, quality, expectSuccess); |
| |
| // 3 layers is too many |
| make_noop_layer(&builder); |
| make_blur_layer(&builder, mf); |
| make_noop_layer(&builder); |
| test_looper(reporter, builder.detach(), sigma, style, quality, false); |
| } |
| |
| DEF_TEST(BlurAsABlur, reporter) { |
| const SkBlurStyle styles[] = { |
| kNormal_SkBlurStyle, kSolid_SkBlurStyle, kOuter_SkBlurStyle, kInner_SkBlurStyle |
| }; |
| const SkScalar sigmas[] = { |
| // values <= 0 should not success for a blur |
| -1, 0, 0.5f, 2 |
| }; |
| |
| // Test asABlur for SkBlurMaskFilter |
| // |
| for (size_t i = 0; i < SK_ARRAY_COUNT(styles); ++i) { |
| const SkBlurStyle style = styles[i]; |
| for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) { |
| const SkScalar sigma = sigmas[j]; |
| for (int flags = 0; flags <= SkBlurMaskFilter::kAll_BlurFlag; ++flags) { |
| const SkBlurQuality quality = blurMaskFilterFlags_as_quality(flags); |
| |
| sk_sp<SkMaskFilter> mf(SkBlurMaskFilter::Make(style, sigma, flags)); |
| if (nullptr == mf.get()) { |
| REPORTER_ASSERT(reporter, sigma <= 0); |
| } else { |
| REPORTER_ASSERT(reporter, sigma > 0); |
| SkMaskFilterBase::BlurRec rec; |
| bool success = as_MFB(mf)->asABlur(&rec); |
| if (flags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) { |
| REPORTER_ASSERT(reporter, !success); |
| } else { |
| REPORTER_ASSERT(reporter, success); |
| REPORTER_ASSERT(reporter, rec.fSigma == sigma); |
| REPORTER_ASSERT(reporter, rec.fStyle == style); |
| REPORTER_ASSERT(reporter, rec.fQuality == quality); |
| } |
| test_layerDrawLooper(reporter, std::move(mf), sigma, style, quality, success); |
| } |
| test_blurDrawLooper(reporter, sigma, style, flags); |
| } |
| } |
| } |
| |
| // Test asABlur for SkEmbossMaskFilter -- should never succeed |
| // |
| { |
| SkEmbossMaskFilter::Light light = { |
| { 1, 1, 1 }, 0, 127, 127 |
| }; |
| for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) { |
| const SkScalar sigma = sigmas[j]; |
| auto mf(SkEmbossMaskFilter::Make(sigma, light)); |
| if (mf) { |
| SkMaskFilterBase::BlurRec rec; |
| bool success = as_MFB(mf)->asABlur(&rec); |
| REPORTER_ASSERT(reporter, !success); |
| } |
| } |
| } |
| } |
| |
| #if SK_SUPPORT_GPU |
| |
| // This exercises the problem discovered in crbug.com/570232. The return value from |
| // SkBlurMask::BoxBlur wasn't being checked in SkBlurMaskFilter.cpp::GrRRectBlurEffect::Create |
| DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SmallBoxBlurBug, reporter, ctxInfo) { |
| |
| SkImageInfo info = SkImageInfo::MakeN32Premul(128, 128); |
| auto surface(SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kNo, info)); |
| SkCanvas* canvas = surface->getCanvas(); |
| |
| SkRect r = SkRect::MakeXYWH(10, 10, 100, 100); |
| SkRRect rr = SkRRect::MakeRectXY(r, 10, 10); |
| |
| SkPaint p; |
| p.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 0.01f)); |
| |
| canvas->drawRRect(rr, p); |
| } |
| |
| #endif |
| |
| |
| DEF_TEST(BlurredRRectNinePatchComputation, reporter) { |
| const SkRect r = SkRect::MakeXYWH(10, 10, 100, 100); |
| static const SkScalar kBlurRad = 3.0f; |
| |
| bool ninePatchable; |
| SkRRect rrectToDraw; |
| SkISize size; |
| SkScalar rectXs[kSkBlurRRectMaxDivisions], |
| rectYs[kSkBlurRRectMaxDivisions]; |
| SkScalar texXs[kSkBlurRRectMaxDivisions], |
| texYs[kSkBlurRRectMaxDivisions]; |
| int numX, numY; |
| uint32_t skipMask; |
| |
| // not nine-patchable |
| { |
| SkVector radii[4] = { { 100, 100 }, { 0, 0 }, { 100, 100 }, { 0, 0 } }; |
| |
| SkRRect rr; |
| rr.setRectRadii(r, radii); |
| |
| ninePatchable = SkComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(), |
| kBlurRad, kBlurRad, |
| &rrectToDraw, &size, |
| rectXs, rectYs, texXs, texYs, |
| &numX, &numY, &skipMask); |
| REPORTER_ASSERT(reporter, !ninePatchable); |
| } |
| |
| // simple circular |
| { |
| static const SkScalar kCornerRad = 10.0f; |
| SkRRect rr; |
| rr.setRectXY(r, kCornerRad, kCornerRad); |
| |
| ninePatchable = SkComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(), |
| kBlurRad, kBlurRad, |
| &rrectToDraw, &size, |
| rectXs, rectYs, texXs, texYs, |
| &numX, &numY, &skipMask); |
| |
| static const SkScalar kAns = 12.0f * kBlurRad + 2.0f * kCornerRad + 1.0f; |
| REPORTER_ASSERT(reporter, ninePatchable); |
| REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kAns)); |
| REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kAns)); |
| REPORTER_ASSERT(reporter, 4 == numX && 4 == numY); |
| REPORTER_ASSERT(reporter, !skipMask); |
| } |
| |
| // simple elliptical |
| { |
| static const SkScalar kXCornerRad = 2.0f; |
| static const SkScalar kYCornerRad = 10.0f; |
| SkRRect rr; |
| rr.setRectXY(r, kXCornerRad, kYCornerRad); |
| |
| ninePatchable = SkComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(), |
| kBlurRad, kBlurRad, |
| &rrectToDraw, &size, |
| rectXs, rectYs, texXs, texYs, |
| &numX, &numY, &skipMask); |
| |
| static const SkScalar kXAns = 12.0f * kBlurRad + 2.0f * kXCornerRad + 1.0f; |
| static const SkScalar kYAns = 12.0f * kBlurRad + 2.0f * kYCornerRad + 1.0f; |
| |
| REPORTER_ASSERT(reporter, ninePatchable); |
| REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kXAns)); |
| REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kYAns)); |
| REPORTER_ASSERT(reporter, 4 == numX && 4 == numY); |
| REPORTER_ASSERT(reporter, !skipMask); |
| } |
| |
| // test-out occlusion |
| { |
| static const SkScalar kCornerRad = 10.0f; |
| SkRRect rr; |
| rr.setRectXY(r, kCornerRad, kCornerRad); |
| |
| // The rectXs & rectYs should be { 1, 29, 91, 119 }. Add two more points around each. |
| SkScalar testLocs[] = { |
| -18.0f, -9.0f, |
| 1.0f, |
| 9.0f, 18.0f, |
| 29.0f, |
| 39.0f, 49.0f, |
| 91.0f, |
| 109.0f, 118.0f, |
| 119.0f, |
| 139.0f, 149.0f |
| }; |
| |
| for (int minY = 0; minY < (int)SK_ARRAY_COUNT(testLocs); ++minY) { |
| for (int maxY = minY+1; maxY < (int)SK_ARRAY_COUNT(testLocs); ++maxY) { |
| for (int minX = 0; minX < (int)SK_ARRAY_COUNT(testLocs); ++minX) { |
| for (int maxX = minX+1; maxX < (int)SK_ARRAY_COUNT(testLocs); ++maxX) { |
| SkRect occluder = SkRect::MakeLTRB(testLocs[minX], testLocs[minY], |
| testLocs[maxX], testLocs[maxY]); |
| if (occluder.isEmpty()) { |
| continue; |
| } |
| |
| ninePatchable = SkComputeBlurredRRectParams(rr, rr, occluder, |
| kBlurRad, kBlurRad, |
| &rrectToDraw, &size, |
| rectXs, rectYs, texXs, texYs, |
| &numX, &numY, &skipMask); |
| |
| static const SkScalar kAns = 12.0f * kBlurRad + 2.0f * kCornerRad + 1.0f; |
| REPORTER_ASSERT(reporter, ninePatchable); |
| REPORTER_ASSERT(reporter, |
| SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kAns)); |
| REPORTER_ASSERT(reporter, |
| SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kAns)); |
| |
| int checkBit = 0x1; |
| for (int y = 0; y < numY-1; ++y) { |
| for (int x = 0; x < numX-1; ++x) { |
| SkRect cell = SkRect::MakeLTRB(rectXs[x], rectYs[y], |
| rectXs[x+1], rectYs[y+1]); |
| REPORTER_ASSERT(reporter, |
| SkToBool(skipMask & checkBit) == |
| (cell.isEmpty() || occluder.contains(cell))); |
| |
| REPORTER_ASSERT(reporter, texXs[x] >= 0 && |
| texXs[x] <= size.fWidth); |
| REPORTER_ASSERT(reporter, texYs[y] >= 0 && |
| texXs[y] <= size.fHeight); |
| |
| checkBit <<= 1; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| } |
| |
| } |
| |
| // https://crbugs.com/787712 |
| DEF_TEST(EmbossPerlinCrash, reporter) { |
| SkPaint p; |
| |
| static constexpr SkEmbossMaskFilter::Light light = { |
| { 1, 1, 1 }, 0, 127, 127 |
| }; |
| p.setMaskFilter(SkEmbossMaskFilter::Make(1, light)); |
| p.setShader(SkPerlinNoiseShader::MakeFractalNoise(1.0f, 1.0f, 2, 0.0f)); |
| |
| sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(100, 100); |
| surface->getCanvas()->drawPaint(p); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////// |
| #include "SkSurface.h" |
| #include "sk_pixel_iter.h" |
| |
| DEF_TEST(BlurZeroSigma, reporter) { |
| auto surf = SkSurface::MakeRasterN32Premul(20, 20); |
| SkPaint paint; |
| paint.setAntiAlias(true); |
| |
| const SkIRect ir = { 5, 5, 15, 15 }; |
| const SkRect r = SkRect::Make(ir); |
| |
| const SkScalar sigmas[] = { 0, SkBits2Float(1) }; |
| // if sigma is zero (or nearly so), we need to draw correctly (unblurred) and not crash |
| // or assert. |
| for (auto sigma : sigmas) { |
| paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, sigma)); |
| surf->getCanvas()->drawRect(r, paint); |
| |
| sk_tool_utils::PixelIter iter(surf.get()); |
| SkIPoint loc; |
| while (const SkPMColor* p = (const SkPMColor*)iter.next(&loc)) { |
| if (ir.contains(loc.fX, loc.fY)) { |
| // inside the rect we draw (opaque black) |
| REPORTER_ASSERT(reporter, *p == SkPackARGB32(0xFF, 0, 0, 0)); |
| } else { |
| // outside the rect we didn't draw at all, no blurred edges |
| REPORTER_ASSERT(reporter, *p == 0); |
| } |
| } |
| } |
| } |
| |