FilterBoundsSlide.cpp File Reference

#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkFont.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathEffect.h"
#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 "src/core/SkRectPriv.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/FontToolUtils.h"
#include "tools/viewer/Slide.h"

Go to the source code of this file.

Classes
class	FilterBoundsSample

Functions
static float	print_size (SkCanvas *canvas, const char *prefix, std::optional< SkIRect > rect, float x, float y, const SkFont &font, const SkPaint &paint)
static float	print_info (SkCanvas *canvas, const skif::LayerSpace< SkIRect > &layerContentBounds, const skif::DeviceSpace< SkIRect > &outputBounds, std::optional< skif::DeviceSpace< SkIRect > > hintedOutputBounds, const skif::LayerSpace< SkIRect > &unhintedLayerBounds)
static void	print_label (SkCanvas *canvas, float x, float y, float value)
static SkPaint	line_paint (SkColor color, bool dashed=false)
static SkPath	create_axis_path (const SkRect &rect, float axisSpace)
static void	draw_scale_key (SkCanvas *canvas, float y)
static void	draw_scale_factors (SkCanvas *canvas, const skif::Mapping &mapping, const SkRect &rect)

Variables
static constexpr float	kLineHeight = 16.f
static constexpr float	kLineInset = 8.f
static const SkColor4f	kScaleGradientColors []
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) std::size(kScaleGradientColors)

Function Documentation

create_axis_path()

static SkPath create_axis_path ( const SkRect &  rect, float  axisSpace  )

static

Definition at line 98 of file FilterBoundsSlide.cpp.

                                                                    {
    SkPath localSpace;
    for (float y = rect.fTop + axisSpace; y <= rect.fBottom; y += axisSpace) {
        localSpace.moveTo(rect.fLeft, y);
        localSpace.lineTo(rect.fRight, y);
    }
    for (float x = rect.fLeft + axisSpace; x <= rect.fRight; x += axisSpace) {
        localSpace.moveTo(x, rect.fTop);
        localSpace.lineTo(x, rect.fBottom);
    }
    return localSpace;
}

draw_scale_factors()

static void draw_scale_factors ( SkCanvas *  canvas, const skif::Mapping &  mapping, const SkRect &  rect  )

static

Definition at line 136 of file FilterBoundsSlide.cpp.

                                                                                                 {
    SkPoint testPoints[5];
    testPoints[0] = {rect.centerX(), rect.centerY()};
    rect.toQuad(testPoints + 1);
    for (int i = 0; i < 5; ++i) {
        float scale = SkMatrixPriv::DifferentialAreaScale(
                mapping.layerToDevice(),
                SkPoint(mapping.paramToLayer(skif::ParameterSpace<SkPoint>(testPoints[i]))));
        SkColor4f color = {0.f, 0.f, 0.f, 1.f};
 
        if (SkIsFinite(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);
    }
}

draw_scale_key()

static void draw_scale_key ( SkCanvas *  canvas, float  y  )

static

Definition at line 121 of file FilterBoundsSlide.cpp.

                                                      {
    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]));
    }
}

line_paint()

static SkPaint line_paint ( SkColor  color, bool  dashed = false  )

static

Definition at line 85 of file FilterBoundsSlide.cpp.

                                                              {
    SkPaint paint;
    paint.setColor(color);
    paint.setStrokeWidth(0.f);
    paint.setStyle(SkPaint::kStroke_Style);
    paint.setAntiAlias(true);
    if (dashed) {
        SkScalar dash[2] = {10.f, 10.f};
        paint.setPathEffect(SkDashPathEffect::Make(dash, 2, 0.f));
    }
    return paint;
}

print_info()

static float print_info ( SkCanvas *  canvas, const skif::LayerSpace< SkIRect > &  layerContentBounds, const skif::DeviceSpace< SkIRect > &  outputBounds, std::optional< skif::DeviceSpace< SkIRect > >  hintedOutputBounds, const skif::LayerSpace< SkIRect > &  unhintedLayerBounds  )

static

Definition at line 46 of file FilterBoundsSlide.cpp.

                                                                            {
    SkFont font(ToolUtils::DefaultTypeface(), 12);
    SkPaint text;
    text.setAntiAlias(true);
 
    float y = kLineHeight;
 
    text.setColor(SK_ColorRED);
    y = print_size(canvas, "Content (in layer)", SkIRect(layerContentBounds),
                   kLineInset, y, font, text);
    text.setColor(SK_ColorDKGRAY);
    y = print_size(canvas, "Target (in device)", SkIRect(outputBounds),
                   kLineInset, y, font, text);
    text.setColor(SK_ColorBLUE);
    y = print_size(canvas, "Output (w/ hint)",
                   hintedOutputBounds ? SkIRect(*hintedOutputBounds) : std::optional<SkIRect>{},
                   kLineInset, y, font, text);
    text.setColor(SK_ColorGREEN);
    y = print_size(canvas, "Input (w/ no hint)", SkIRect(unhintedLayerBounds),
                   kLineInset, y, font, text);
 
    return y;
}

print_label()

static void print_label ( SkCanvas *  canvas, float  x, float  y, float  value  )

static

Definition at line 74 of file FilterBoundsSlide.cpp.

                                                                         {
    SkFont font(ToolUtils::DefaultTypeface(), 12);
    SkPaint text;
    text.setAntiAlias(true);
 
    SkString label;
    label.printf("%.3f", value);
 
    canvas->drawString(label, x, y + kLineHeight / 2.f, font, text);
}

print_size()

static float print_size ( SkCanvas *  canvas, const char *  prefix, std::optional< SkIRect >  rect, float  x, float  y, const SkFont &  font, const SkPaint &  paint  )

static

Definition at line 31 of file FilterBoundsSlide.cpp.

                                                                                    {
    canvas->drawString(prefix, x, y, font, paint);
    y += kLineHeight;
    SkString sz;
    if (rect) {
        sz.appendf("%d x %d", rect->width(), rect->height());
    } else {
        sz.appendf("infinite");
    }
    canvas->drawString(sz, x, y, font, paint);
    return y + kLineHeight;
}

Variable Documentation

kGradientStops

const SkScalar kGradientStops[] = { 0.f, 0.33333f, 0.5f, 0.66667f, 1.f }

static

Definition at line 118 of file FilterBoundsSlide.cpp.

{ 0.f, 0.33333f, 0.5f, 0.66667f, 1.f };

kLineHeight

constexpr float kLineHeight = 16.f

staticconstexpr

Definition at line 28 of file FilterBoundsSlide.cpp.

kLineInset

constexpr float kLineInset = 8.f

staticconstexpr

Definition at line 29 of file FilterBoundsSlide.cpp.

kLogScaleFactors

const SkScalar kLogScaleFactors[] = { -3.f, -1.f, 0.f, 1.f, 3.f }

static

Definition at line 117 of file FilterBoundsSlide.cpp.

{ -3.f, -1.f, 0.f, 1.f, 3.f };

kScaleGradientColors

const SkColor4f kScaleGradientColors[]

static

Initial value:

=
                { { 0.05f, 0.0f, 6.f,  1.f },   
                  { 0.6f,  0.6f, 0.8f, 0.6f },  
                  { 1.f,   1.f,  1.f,  0.2f },  
                  { 0.95f, 0.6f, 0.5f, 0.6f },  
                  { 0.8f,  0.1f, 0.f,  1.f } }

Definition at line 111 of file FilterBoundsSlide.cpp.

                { { 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

kStopCount

const int kStopCount = (int) std::size(kScaleGradientColors)

static

Definition at line 119 of file FilterBoundsSlide.cpp.