Visualize perspective scaling in filter bounds sample

Bug: skia:9074
Change-Id: Icdac64276e0a403950fd990a619d523b0ee784de
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/326942
Reviewed-by: Jim Van Verth <[email protected]>
Commit-Queue: Michael Ludwig <[email protected]>

Author: lhkbob

samplecode/SampleFilterBounds.cpp

@@ -15,10 +15,12 @@
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
 #include "include/effects/SkDashPathEffect.h"
+#include "include/effects/SkGradientShader.h"
 #include "include/effects/SkImageFilters.h"
 
 #include "src/core/SkImageFilterTypes.h"
 #include "src/core/SkImageFilter_Base.h"
+#include "src/core/SkMatrixPriv.h"
 
 #include "tools/ToolUtils.h"
 
@@ -58,6 +60,17 @@ static float print_info(SkCanvas* canvas,
     return y;
 }
 
+static void print_label(SkCanvas* canvas, float x, float y, float value) {
+    SkFont font(nullptr, 12);
+    SkPaint text;
+    text.setAntiAlias(true);
+
+    SkString label;
+    label.printf("%.3f", value);
+
+    canvas->drawString(label, x, y + kLineHeight / 2.f, font, text);
+}
+
 static SkPaint line_paint(SkColor color, bool dashed = false) {
     SkPaint paint;
     paint.setColor(color);
@@ -84,6 +97,71 @@ static SkPath create_axis_path(const SkRect& rect, float axisSpace) {
     return localSpace;
 }
 
+static const SkColor4f kScaleGradientColors[] =
+                { { 0.05f, 0.0f, 6.f,  1.f },   // Severe downscaling, s < 1/8, log(s) < -3
+                  { 0.6f,  0.6f, 0.8f, 0.6f },  // Okay downscaling,   s < 1/2, log(s) < -1
+                  { 1.f,   1.f,  1.f,  0.2f },  // No scaling,         s = 1,   log(s) = 0
+                  { 0.95f, 0.6f, 0.5f, 0.6f },  // Okay upscaling,     s > 2,   log(s) > 1
+                  { 0.8f,  0.1f, 0.f,  1.f } }; // Severe upscaling,   s > 8,   log(s) > 3
+static const SkScalar kLogScaleFactors[] = { -3.f, -1.f, 0.f, 1.f, 3.f };
+static const SkScalar kGradientStops[] = { 0.f, 0.33333f, 0.5f, 0.66667f, 1.f };
+static const int kStopCount = (int) SK_ARRAY_COUNT(kScaleGradientColors);
+
+static void draw_scale_key(SkCanvas* canvas, float y) {
+    SkRect key = SkRect::MakeXYWH(15.f, y + 30.f, 15.f, 100.f);
+    SkPoint pts[] = {{key.centerX(), key.fTop}, {key.centerX(), key.fBottom}};
+    sk_sp<SkShader> gradient = SkGradientShader::MakeLinear(
+            pts, kScaleGradientColors, nullptr, kGradientStops, kStopCount, SkTileMode::kClamp,
+            SkGradientShader::kInterpolateColorsInPremul_Flag, nullptr);
+    SkPaint keyPaint;
+    keyPaint.setShader(gradient);
+    canvas->drawRect(key, keyPaint);
+    for (int i = 0; i < kStopCount; ++i) {
+        print_label(canvas, key.fRight + 5.f, key.fTop + kGradientStops[i] * key.height(),
+                    SkScalarPow(2.f, kLogScaleFactors[i]));
+    }
+}
+
+static void draw_scale_factors(SkCanvas* canvas, const skif::Mapping& mapping, const SkRect& rect) {
+    SkPoint testPoints[5];
+    testPoints[0] = {rect.centerX(), rect.centerY()};
+    rect.toQuad(testPoints + 1);
+    for (int i = 0; i < 5; ++i) {
+        float scale = SkMatrixPriv::DifferentialScale(
+                mapping.deviceMatrix(),
+                SkPoint(mapping.paramToLayer(skif::ParameterSpace<SkPoint>(testPoints[i]))));
+        SkColor4f color = {0.f, 0.f, 0.f, 1.f};
+
+        if (SkScalarIsFinite(scale)) {
+            float logScale = SkScalarLog2(scale);
+            for (int j = 0; j <= kStopCount; ++j) {
+                if (j == kStopCount) {
+                    color = kScaleGradientColors[j - 1];
+                    break;
+                } else if (kLogScaleFactors[j] >= logScale) {
+                    if (j == 0) {
+                        color = kScaleGradientColors[0];
+                    } else {
+                        SkScalar t = (logScale - kLogScaleFactors[j - 1]) /
+                                    (kLogScaleFactors[j] - kLogScaleFactors[j - 1]);
+
+                        SkColor4f a = kScaleGradientColors[j - 1] * (1.f - t);
+                        SkColor4f b = kScaleGradientColors[j] * t;
+                        color = {a.fR + b.fR, a.fG + b.fG, a.fB + b.fB, a.fA + b.fA};
+                    }
+                    break;
+                }
+            }
+        }
+
+        SkPaint p;
+        p.setAntiAlias(true);
+        p.setColor4f(color, nullptr);
+        canvas->drawRect(SkRect::MakeLTRB(testPoints[i].fX - 4.f, testPoints[i].fY - 4.f,
+                                          testPoints[i].fX + 4.f, testPoints[i].fY + 4.f), p);
+    }
+}
+
 class FilterBoundsSample : public Sample {
 public:
     FilterBoundsSample() {}
@@ -114,6 +192,9 @@ class FilterBoundsSample : public Sample {
         // Add axis lines, to show perspective distortion
         canvas->drawPath(create_axis_path(localContentRect, 10.f), line_paint(SK_ColorGRAY));
 
+        // Visualize scale factors at the four corners and center of the local rect
+        draw_scale_factors(canvas, mapping, localContentRect);
+
         // The device content rect, e.g. the clip bounds if 'localContentRect' were used as a clip
         // before the draw or saveLayer, representing what the filter must cover if it affects
         // transparent black or doesn't have a local content hint.
@@ -146,10 +227,13 @@ class FilterBoundsSample : public Sample {
         canvas->drawRect(SkRect::Make(SkIRect(hintedOutputBounds)), line_paint(SK_ColorBLUE));
 
         canvas->resetMatrix();
-        print_info(canvas, SkIRect(mapping.paramToLayer(contentBounds).roundOut()),
+        float y = print_info(canvas, SkIRect(mapping.paramToLayer(contentBounds).roundOut()),
                            devContentRect.roundOut(),
                            SkIRect(hintedOutputBounds),
                            SkIRect(unhintedLayerBounds));
+
+        // Draw color key for layer visualization
+        draw_scale_key(canvas, y);
     }
 
     SkString name() override { return SkString("FilterBounds"); }

src/core/SkMatrix.cpp

@@ -720,25 +720,27 @@ static inline SkScalar dcross_dscale(double a, double b,
     return SkDoubleToScalar(dcross(a, b, c, d) * scale);
 }
 
-static double sk_inv_determinant(const float mat[9], int isPerspective) {
-    double det;
-
+static double sk_determinant(const float mat[9], int isPerspective) {
     if (isPerspective) {
-        det = mat[SkMatrix::kMScaleX] *
-              dcross(mat[SkMatrix::kMScaleY], mat[SkMatrix::kMPersp2],
-                     mat[SkMatrix::kMTransY], mat[SkMatrix::kMPersp1])
-              +
-              mat[SkMatrix::kMSkewX]  *
-              dcross(mat[SkMatrix::kMTransY], mat[SkMatrix::kMPersp0],
-                     mat[SkMatrix::kMSkewY],  mat[SkMatrix::kMPersp2])
-              +
-              mat[SkMatrix::kMTransX] *
-              dcross(mat[SkMatrix::kMSkewY],  mat[SkMatrix::kMPersp1],
-                     mat[SkMatrix::kMScaleY], mat[SkMatrix::kMPersp0]);
+        return mat[SkMatrix::kMScaleX] *
+                    dcross(mat[SkMatrix::kMScaleY], mat[SkMatrix::kMPersp2],
+                           mat[SkMatrix::kMTransY], mat[SkMatrix::kMPersp1])
+                    +
+                    mat[SkMatrix::kMSkewX]  *
+                    dcross(mat[SkMatrix::kMTransY], mat[SkMatrix::kMPersp0],
+                           mat[SkMatrix::kMSkewY],  mat[SkMatrix::kMPersp2])
+                    +
+                    mat[SkMatrix::kMTransX] *
+                    dcross(mat[SkMatrix::kMSkewY],  mat[SkMatrix::kMPersp1],
+                           mat[SkMatrix::kMScaleY], mat[SkMatrix::kMPersp0]);
     } else {
-        det = dcross(mat[SkMatrix::kMScaleX], mat[SkMatrix::kMScaleY],
-                     mat[SkMatrix::kMSkewX], mat[SkMatrix::kMSkewY]);
+        return dcross(mat[SkMatrix::kMScaleX], mat[SkMatrix::kMScaleY],
+                      mat[SkMatrix::kMSkewX], mat[SkMatrix::kMSkewY]);
     }
+}
+
+static double sk_inv_determinant(const float mat[9], int isPerspective) {
+    double det = sk_determinant(mat, isPerspective);
 
     // Since the determinant is on the order of the cube of the matrix members,
     // compare to the cube of the default nearly-zero constant (although an
@@ -1855,3 +1857,38 @@ SkFilterQuality SkMatrixPriv::AdjustHighQualityFilterLevel(const SkMatrix& matri
 
     return kHigh_SkFilterQuality;
 }
+
+SkScalar SkMatrixPriv::DifferentialScale(const SkMatrix& m, const SkPoint& p) {
+    //              [m00 m01 m02]                                 [f(u,v)]
+    // Assuming M = [m10 m11 m12], define the projected p'(u,v) = [g(u,v)] where
+    //              [m20 m12 m22]
+    //                                                        [x]     [u]
+    // f(u,v) = x(u,v) / w(u,v), g(u,v) = y(u,v) / w(u,v) and [y] = M*[v]
+    //                                                        [w]     [1]
+    //
+    // Then the differential scale factor between p = (u,v) and p' is |det J|,
+    // where J is the Jacobian for p': [df/du dg/du]
+    //                                 [df/dv dg/dv]
+    // and df/du = (w*dx/du - x*dw/du)/w^2,   dg/du = (w*dy/du - y*dw/du)/w^2
+    //     df/dv = (w*dx/dv - x*dw/dv)/w^2,   dg/dv = (w*dy/dv - y*dw/dv)/w^2
+    //
+    // From here, |det J| can be rewritten as |det J'/w^3|, where
+    //      [x     y     w    ]   [x   y   w  ]
+    // J' = [dx/du dy/du dw/du] = [m00 m10 m20]
+    //      [dx/dv dy/dv dw/dv]   [m01 m11 m21]
+    SkPoint3 xyw;
+    m.mapHomogeneousPoints(&xyw, &p, 1);
+
+    if (xyw.fZ < SK_ScalarNearlyZero) {
+        // Reaching the discontinuity of xy/w and where the point would clip to w >= 0
+        return SK_ScalarInfinity;
+    }
+    SkMatrix jacobian = SkMatrix::MakeAll(xyw.fX, xyw.fY, xyw.fZ,
+                                          m.getScaleX(), m.getSkewY(), m.getPerspX(),
+                                          m.getSkewX(), m.getScaleY(), m.getPerspY());
+
+    SkScalar denom = 1.f / xyw.fZ; // 1/w
+    denom = denom * denom * denom; // 1/w^3
+
+    return SkScalarAbs(SkDoubleToScalar(sk_determinant(jacobian.fMat, true)) * denom);
+}

src/core/SkMatrixPriv.h

@@ -171,6 +171,15 @@ class SkMatrixPriv {
                m.rc(3,3) == 1;
 
     }
+
+    // Returns the differential area scale factor for a local point 'p' that will be transformed
+    // by 'm' (which may have perspective). If 'm' does not have perspective, this scale factor is
+    // constant regardless of 'p'; when it does have perspective, it is specific to that point.
+    //
+    // This can be crudely thought of as "device pixel area" / "local pixel area" at 'p'.
+    //
+    // Returns positive infinity if the transformed homogeneous point has w <= 0.
+    static SkScalar DifferentialScale(const SkMatrix& m, const SkPoint& p);
 };
 
 #endif