colorfilterimagefilter.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkTileMode.h"
#include "include/effects/SkColorMatrix.h"
#include "include/effects/SkGradientShader.h"
#include "include/effects/SkImageFilters.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTDArray.h"
#include "tools/DecodeUtils.h"
#include "tools/Resources.h"
#include <string.h>
#include <utility>

Go to the source code of this file.

Macros
#define	FILTER_WIDTH   SkIntToScalar(30)
#define	FILTER_HEIGHT   SkIntToScalar(30)
#define	MARGIN   SkIntToScalar(10)

Functions
static sk_sp< SkColorFilter >	cf_make_brightness (float brightness)
static sk_sp< SkColorFilter >	cf_make_grayscale ()
static sk_sp< SkColorFilter >	cf_make_colorize (SkColor color)
static void	sk_gm_get_colorfilters (TArray< sk_sp< SkColorFilter > > *array)
static sk_sp< SkShader >	sh_make_lineargradient0 ()
static sk_sp< SkShader >	sh_make_lineargradient1 ()
static sk_sp< SkShader >	sh_make_image ()
static void	sk_gm_get_shaders (TArray< sk_sp< SkShader > > *array)
static sk_sp< SkImageFilter >	make_blur (float amount, sk_sp< SkImageFilter > input)
static sk_sp< SkImageFilter >	make_brightness (float amount, sk_sp< SkImageFilter > input)
static sk_sp< SkImageFilter >	make_grayscale (sk_sp< SkImageFilter > input)
static sk_sp< SkImageFilter >	make_mode_blue (sk_sp< SkImageFilter > input)
static void	draw_clipped_rect (SkCanvas *canvas, const SkRect &r, const SkPaint &paint, float outset=0.0f)
	DEF_SIMPLE_GM (colorfilterimagefilter, canvas, 400, 100)
	DEF_SIMPLE_GM (colorfilterimagefilter_layer, canvas, 32, 32)
	DEF_SIMPLE_GM (colorfiltershader, canvas, 610, 610)

Macro Definition Documentation

FILTER_HEIGHT

#define FILTER_HEIGHT   SkIntToScalar(30)

Definition at line 36 of file colorfilterimagefilter.cpp.

FILTER_WIDTH

#define FILTER_WIDTH   SkIntToScalar(30)

Definition at line 35 of file colorfilterimagefilter.cpp.

MARGIN

#define MARGIN   SkIntToScalar(10)

Definition at line 37 of file colorfilterimagefilter.cpp.

Function Documentation

cf_make_brightness()

static sk_sp< SkColorFilter > cf_make_brightness ( float  brightness )

static

Definition at line 39 of file colorfilterimagefilter.cpp.

                                                                 {
    float matrix[20] = {
        1, 0, 0, 0, brightness,
        0, 1, 0, 0, brightness,
        0, 0, 1, 0, brightness,
        0, 0, 0, 1, 0 };
    return SkColorFilters::Matrix(matrix);
}

cf_make_colorize()

static sk_sp< SkColorFilter > cf_make_colorize ( SkColor  color )

static

Definition at line 58 of file colorfilterimagefilter.cpp.

                                                            {
    return SkColorFilters::Blend(color, SkBlendMode::kSrc);
}

cf_make_grayscale()

static sk_sp< SkColorFilter > cf_make_grayscale ( )

static

Definition at line 48 of file colorfilterimagefilter.cpp.

                                                {
    float matrix[20];
    memset(matrix, 0, 20 * sizeof(float));
    matrix[0] = matrix[5] = matrix[10] = 0.2126f;
    matrix[1] = matrix[6] = matrix[11] = 0.7152f;
    matrix[2] = matrix[7] = matrix[12] = 0.0722f;
    matrix[18] = 1.0f;
    return SkColorFilters::Matrix(matrix);
}

DEF_SIMPLE_GM() [1/3]

DEF_SIMPLE_GM	(	colorfilterimagefilter	,
		canvas	,
		400	,
		100
	)

Definition at line 132 of file colorfilterimagefilter.cpp.

                                                       {
        SkRect r = SkRect::MakeWH(FILTER_WIDTH, FILTER_HEIGHT);
        SkPaint paint;
        paint.setColor(SK_ColorRED);
        canvas->save();
        for (float brightness = -1.0f; brightness <= 1.0f; brightness += 0.2f) {
            sk_sp<SkImageFilter> dim(make_brightness(-brightness, nullptr));
            sk_sp<SkImageFilter> bright(make_brightness(brightness, std::move(dim)));
            paint.setImageFilter(std::move(bright));
            draw_clipped_rect(canvas, r, paint);
            canvas->translate(FILTER_WIDTH + MARGIN, 0);
        }
        canvas->restore();
        canvas->translate(0, FILTER_HEIGHT + MARGIN);
        {
            sk_sp<SkImageFilter> brightness(make_brightness(0.9f, nullptr));
            sk_sp<SkImageFilter> grayscale(make_grayscale(std::move(brightness)));
            paint.setImageFilter(std::move(grayscale));
            draw_clipped_rect(canvas, r, paint);
            canvas->translate(FILTER_WIDTH + MARGIN, 0);
        }
        {
            sk_sp<SkImageFilter> grayscale(make_grayscale(nullptr));
            sk_sp<SkImageFilter> brightness(make_brightness(0.9f, std::move(grayscale)));
            paint.setImageFilter(std::move(brightness));
            draw_clipped_rect(canvas, r, paint);
            canvas->translate(FILTER_WIDTH + MARGIN, 0);
        }
        {
            sk_sp<SkImageFilter> blue(make_mode_blue(nullptr));
            sk_sp<SkImageFilter> brightness(make_brightness(1.0f, std::move(blue)));
            paint.setImageFilter(std::move(brightness));
            draw_clipped_rect(canvas, r, paint);
            canvas->translate(FILTER_WIDTH + MARGIN, 0);
        }
        {
            sk_sp<SkImageFilter> brightness(make_brightness(1.0f, nullptr));
            sk_sp<SkImageFilter> blue(make_mode_blue(std::move(brightness)));
            paint.setImageFilter(std::move(blue));
            draw_clipped_rect(canvas, r, paint);
            canvas->translate(FILTER_WIDTH + MARGIN, 0);
        }
        {
            sk_sp<SkImageFilter> blur(make_blur(3.0f, nullptr));
            sk_sp<SkImageFilter> brightness(make_brightness(0.5f, std::move(blur)));
            paint.setImageFilter(std::move(brightness));
            draw_clipped_rect(canvas, r, paint, 3);
            canvas->translate(FILTER_WIDTH + MARGIN, 0);
        }
        {
            sk_sp<SkImageFilter> blue(make_mode_blue(nullptr));
            paint.setImageFilter(std::move(blue));
            draw_clipped_rect(canvas, r, paint, 5);
            canvas->translate(FILTER_WIDTH + MARGIN, 0);
        }
}

DEF_SIMPLE_GM() [2/3]

DEF_SIMPLE_GM	(	colorfilterimagefilter_layer	,
		canvas	,
		32	,
		32
	)

Definition at line 189 of file colorfilterimagefilter.cpp.

                                                            {
    SkAutoCanvasRestore autoCanvasRestore(canvas, false);
    SkColorMatrix cm;
    cm.setSaturation(0.0f);
    sk_sp<SkColorFilter> cf(SkColorFilters::Matrix(cm));
    SkPaint p;
    p.setImageFilter(SkImageFilters::ColorFilter(std::move(cf), nullptr));
    canvas->saveLayer(nullptr, &p);
    canvas->clear(SK_ColorRED);
}

DEF_SIMPLE_GM() [3/3]

DEF_SIMPLE_GM	(	colorfiltershader	,
		canvas	,
		610	,
		610
	)

Definition at line 201 of file colorfilterimagefilter.cpp.

                                                   {
    TArray<sk_sp<SkColorFilter>> filters;
    sk_gm_get_colorfilters(&filters);
 
    TArray<sk_sp<SkShader>> shaders;
    sk_gm_get_shaders(&shaders);
 
    const SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
    shaders.push_back(SkGradientShader::MakeTwoPointConical(
                              {0, 0}, 50, {0, 0}, 150, colors, nullptr, 2, SkTileMode::kClamp));
 
    SkPaint paint;
    SkRect r = SkRect::MakeWH(120, 120);
 
    canvas->translate(20, 20);
    for (int y = 0; y < SkToInt(shaders.size()); ++y) {
        SkShader* shader = shaders[y].get();
 
        canvas->save();
        for (int x = -1; x < filters.size(); ++x) {
            sk_sp<SkColorFilter> filter = x >= 0 ? filters[x] : nullptr;
 
            paint.setShader(shader->makeWithColorFilter(filter));
            canvas->drawRect(r, paint);
            canvas->translate(150, 0);
        }
        canvas->restore();
        canvas->translate(0, 150);
    }
}

draw_clipped_rect()

static void draw_clipped_rect ( SkCanvas *  canvas, const SkRect &  r, const SkPaint &  paint, float  outset = 0.0f  )

static

Definition at line 120 of file colorfilterimagefilter.cpp.

                                                   {
    canvas->save();
    SkRect clip(r);
    clip.outset(outset, outset);
    canvas->clipRect(clip);
    canvas->drawRect(r, paint);
    canvas->restore();
}

make_blur()

static sk_sp< SkImageFilter > make_blur ( float  amount, sk_sp< SkImageFilter >  input  )

static

Definition at line 104 of file colorfilterimagefilter.cpp.

                                                                                {
    return SkImageFilters::Blur(amount, amount, std::move(input));
}

make_brightness()

static sk_sp< SkImageFilter > make_brightness ( float  amount, sk_sp< SkImageFilter >  input  )

static

Definition at line 108 of file colorfilterimagefilter.cpp.

                                                                                      {
    return SkImageFilters::ColorFilter(cf_make_brightness(amount), std::move(input));
}

make_grayscale()

static sk_sp< SkImageFilter > make_grayscale ( sk_sp< SkImageFilter >  input )

static

Definition at line 112 of file colorfilterimagefilter.cpp.

                                                                       {
    return SkImageFilters::ColorFilter(cf_make_grayscale(), std::move(input));
}

make_mode_blue()

static sk_sp< SkImageFilter > make_mode_blue ( sk_sp< SkImageFilter >  input )

static

Definition at line 116 of file colorfilterimagefilter.cpp.

                                                                       {
    return SkImageFilters::ColorFilter(cf_make_colorize(SK_ColorBLUE), std::move(input));
}

sh_make_image()

static sk_sp< SkShader > sh_make_image ( )

static

Definition at line 82 of file colorfilterimagefilter.cpp.

                                       {
    sk_sp<SkImage> image(ToolUtils::GetResourceAsImage("images/mandrill_128.png"));
    if (!image) {
        return nullptr;
    }
    return image->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, SkSamplingOptions());
}

sh_make_lineargradient0()

static sk_sp< SkShader > sh_make_lineargradient0 ( )

static

Definition at line 70 of file colorfilterimagefilter.cpp.

                                                 {
    const SkPoint pts[] = { { 0, 0 }, { 100, 100 } };
    const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
    return SkGradientShader::MakeLinear(pts, colors, nullptr, 3, SkTileMode::kRepeat);
}

sh_make_lineargradient1()

static sk_sp< SkShader > sh_make_lineargradient1 ( )

static

Definition at line 76 of file colorfilterimagefilter.cpp.

                                                 {
    const SkPoint pts[] = { { 0, 0 }, { 100, 100 } };
    const SkColor colors[] = { SK_ColorRED, 0x0000FF00, SK_ColorBLUE };
    return SkGradientShader::MakeLinear(pts, colors, nullptr, 3, SkTileMode::kRepeat);
}

sk_gm_get_colorfilters()

static void sk_gm_get_colorfilters ( TArray< sk_sp< SkColorFilter > > *  array )

static

Definition at line 62 of file colorfilterimagefilter.cpp.

                                                                        {
    array->push_back(cf_make_brightness(0.5f));
    array->push_back(cf_make_grayscale());
    array->push_back(cf_make_colorize(SK_ColorBLUE));
}

sk_gm_get_shaders()

static void sk_gm_get_shaders ( TArray< sk_sp< SkShader > > *  array )

static

Definition at line 90 of file colorfilterimagefilter.cpp.

                                                              {
    if (auto shader = sh_make_lineargradient0()) {
        array->push_back(std::move(shader));
    }
    if (auto shader = sh_make_lineargradient1()) {
        array->push_back(std::move(shader));
    }
    if (auto shader = sh_make_image()) {
        array->push_back(std::move(shader));
    }
}