Skip to content

GitLab

T
tangled
Commit 7b441021 authored by hbono@chromium.org's avatar hbono@chromium.org
Browse files
Options

Reverting 14712 on behalf of glen. 

TBR=glen
Review URL: http://codereview.chromium.org/100097

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@14713 0039d316-1c4b-4281-b951-d872f2087c98
parent a0669d01
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 467 additions and 1116 deletions
skia/ext/image_operations.cc
View file @ 7b441021
......@@ -15,8 +15,6 @@
#include "base/stack_container.h"
#include "SkBitmap.h"
#include "skia/ext/convolver.h"
#include "skia/include/SkColorPriv.h"
#include "skia/ext/skia_utils.h"
namespace skia {
......@@ -265,7 +263,7 @@ SkBitmap ImageOperations::Resize(const SkBitmap& source,
"The supplied subset does not fall within the destination image.";
// If the size of source or destination is 0, i.e. 0x0, 0xN or Nx0, just
// return empty.
// return empty
if (source.width() < 1 || source.height() < 1 ||
dest_width < 1 || dest_height < 1)
return SkBitmap();
......@@ -317,10 +315,11 @@ SkBitmap ImageOperations::CreateBlendedBitmap(const SkBitmap& first,
// Optimize for case where we won't need to blend anything.
static const double alpha_min = 1.0 / 255;
static const double alpha_max = 254.0 / 255;
if (alpha < alpha_min)
if (alpha < alpha_min) {
return first;
else if (alpha > alpha_max)
} else if (alpha > alpha_max) {
return second;
}
SkAutoLockPixels lock_first(first);
SkAutoLockPixels lock_second(second);
......@@ -362,206 +361,5 @@ SkBitmap ImageOperations::CreateBlendedBitmap(const SkBitmap& first,
return blended;
}
// static
SkBitmap ImageOperations::CreateMaskedBitmap(const SkBitmap& rgb,
const SkBitmap& alpha) {
DCHECK(rgb.width() == alpha.width());
DCHECK(rgb.height() == alpha.height());
DCHECK(rgb.bytesPerPixel() == alpha.bytesPerPixel());
DCHECK(rgb.config() == SkBitmap::kARGB_8888_Config);
DCHECK(alpha.config() == SkBitmap::kARGB_8888_Config);
SkBitmap masked;
masked.setConfig(SkBitmap::kARGB_8888_Config, rgb.width(), rgb.height(), 0);
masked.allocPixels();
masked.eraseARGB(0, 0, 0, 0);
SkAutoLockPixels lock_rgb(rgb);
SkAutoLockPixels lock_alpha(alpha);
SkAutoLockPixels lock_masked(masked);
for (int y = 0; y < rgb.height(); y++) {
uint32* rgb_row = rgb.getAddr32(0, y);
uint32* alpha_row = alpha.getAddr32(0, y);
uint32* dst_row = masked.getAddr32(0, y);
for (int x = 0; x < rgb.width(); x++) {
uint32 alpha_pixel = alpha_row[x];
uint32 rgb_pixel = rgb_row[x];
int alpha = SkColorGetA(alpha_pixel);
dst_row[x] = SkColorSetARGB(alpha,
SkAlphaMul(SkColorGetR(rgb_pixel), alpha),
SkAlphaMul(SkColorGetG(rgb_pixel), alpha),
SkAlphaMul(SkColorGetB(rgb_pixel), alpha));
}
}
return masked;
}
SkBitmap ImageOperations::CreateBlurredBitmap(const SkBitmap& bitmap,
int blur_amount ) {
DCHECK(bitmap.config() == SkBitmap::kARGB_8888_Config);
// Blur factor (1 divided by how many pixels the blur takes place over).
double v = 1.0 / pow(static_cast<double>(blur_amount * 2 + 1), 2);
SkBitmap blurred;
blurred.setConfig(SkBitmap::kARGB_8888_Config, bitmap.width(),
bitmap.height(), 0);
blurred.allocPixels();
blurred.eraseARGB(0, 0, 0, 0);
SkAutoLockPixels lock_bitmap(bitmap);
SkAutoLockPixels lock_blurred(blurred);
// Loop through every pixel in the image.
for (int y = 0; y < bitmap.height(); y++) { // Skip top and bottom edges.
uint32* dst_row = blurred.getAddr32(0, y);
for (int x = 0; x < bitmap.width(); x++) { // Skip left and right edges.
// Sums for this pixel.
double a = 0;
double r = 0;
double g = 0;
double b = 0;
for (int ky = -blur_amount; ky <= blur_amount; ky++) {
for (int kx = -blur_amount; kx <= blur_amount; kx++) {
// Calculate the adjacent pixel for this kernel point. Blurs
// are wrapped.
int bx = (x + kx) % bitmap.width();
while (bx < 0)
bx += bitmap.width();
int by = (y + ky) % bitmap.height();
while (by < 0)
by += bitmap.height();
uint32 src_pixel = bitmap.getAddr32(0, by)[bx];
a += v * static_cast<double>(SkColorGetA(src_pixel));
r += v * static_cast<double>(SkColorGetR(src_pixel));
g += v * static_cast<double>(SkColorGetG(src_pixel));
b += v * static_cast<double>(SkColorGetB(src_pixel));
}
}
dst_row[x] = SkColorSetARGB(
static_cast<int>(a),
static_cast<int>(r),
static_cast<int>(g),
static_cast<int>(b));
}
}
return blurred;
}
// static
SkBitmap ImageOperations::CreateHSLShiftedBitmap(const SkBitmap& bitmap,
float hsl_shift[3]) {
DCHECK(bitmap.config() == SkBitmap::kARGB_8888_Config);
SkBitmap shifted;
shifted.setConfig(SkBitmap::kARGB_8888_Config, bitmap.width(),
bitmap.height(), 0);
shifted.allocPixels();
shifted.eraseARGB(0, 0, 0, 0);
shifted.setIsOpaque(false);
SkAutoLockPixels lock_bitmap(bitmap);
SkAutoLockPixels lock_shifted(shifted);
// Loop through the pixels of the original bitmap.
for (int y = 0; y < bitmap.height(); y++) {
SkColor* pixels = bitmap.getAddr32(0, y);
SkColor* tinted_pixels = shifted.getAddr32(0, y);
for (int x = 0; x < bitmap.width(); x++) {
// Convert the color of this pixel to HSL.
SkPMColor color = pixels[x];
int alpha = SkColorGetA(color);
if (alpha != 255) {
// We have to normalize the colors as they're pre-multiplied.
double r = SkColorGetR(color) / static_cast<double>(alpha);
double g = SkColorGetG(color) / static_cast<double>(alpha);
double b = SkColorGetB(color) / static_cast<double>(alpha);
color = SkColorSetARGB(255,
static_cast<int>(r * 255.0),
static_cast<int>(g * 255.0),
static_cast<int>(b * 255.0));
}
float pixel_hsl[3];
SkColorToHSL(color, pixel_hsl);
// Replace the hue with the tint's hue.
if (hsl_shift[0] >= 0)
pixel_hsl[0] = hsl_shift[0];
// Change the saturation.
if (hsl_shift[1] >= 0) {
if (hsl_shift[1] <= 0.5) {
pixel_hsl[1] *= hsl_shift[1] * 2.0;
} else {
pixel_hsl[1] = pixel_hsl[1] + (1.0 - pixel_hsl[1]) *
((hsl_shift[1] - 0.5) * 2.0);
}
}
// Change the lightness.
if (hsl_shift[2] >= 0) {
if (hsl_shift[2] <= 0.5) {
pixel_hsl[2] *= hsl_shift[2] * 2.0;
} else {
pixel_hsl[2] = pixel_hsl[2] + (1.0 - pixel_hsl[2]) *
((hsl_shift[2] - 0.5) * 2.0);
}
}
// Convert back to RGB.
tinted_pixels[x] = HSLToSKColor(alpha, pixel_hsl);
}
}
return shifted;
}
// static
SkBitmap ImageOperations::CreateTiledBitmap(const SkBitmap& source,
int src_x, int src_y,
int dst_w, int dst_h) {
DCHECK(source.getConfig() == SkBitmap::kARGB_8888_Config);
SkBitmap cropped;
cropped.setConfig(SkBitmap::kARGB_8888_Config, dst_w, dst_h, 0);
cropped.allocPixels();
cropped.eraseARGB(0, 0, 0, 0);
SkAutoLockPixels lock_source(source);
SkAutoLockPixels lock_cropped(cropped);
// Loop through the pixels of the original bitmap.
for (int y = 0; y < dst_h; y++) {
int y_pix = (src_y + y) % source.height();
while (y_pix < 0)
y_pix += source.height();
uint32* source_row = source.getAddr32(0, y_pix);
uint32* dst_row = cropped.getAddr32(0, y);
for (int x = 0; x < dst_w; x++) {
int x_pix = (src_x + x) % source.width();
while (x_pix < 0)
x_pix += source.width();
dst_row[x] = source_row[x_pix];
}
}
return cropped;
}
} // namespace skia
skia/ext/image_operations.h
View file @ 7b441021
......@@ -7,7 +7,6 @@
#include "base/basictypes.h"
#include "base/gfx/rect.h"
#include "SkColor.h"
class SkBitmap;
......@@ -47,47 +46,13 @@ class ImageOperations {
ResizeMethod method,
int dest_width, int dest_height);
// Create a bitmap that is a blend of two others. The alpha argument
// specifies the opacity of the second bitmap. The provided bitmaps must
// use have the kARGB_8888_Config config and be of equal dimensions.
static SkBitmap CreateBlendedBitmap(const SkBitmap& first,
const SkBitmap& second,
double alpha);
// Create a bitmap that is the original bitmap masked out by the mask defined
// in the alpha bitmap. The images must use the kARGB_8888_Config config and
// be of equal dimensions.
static SkBitmap CreateMaskedBitmap(const SkBitmap& first,
const SkBitmap& alpha);
// Blur a bitmap using an average-blur algorithm over the rectangle defined
// by |blur_amount|. The blur will wrap around image edges.
static SkBitmap CreateBlurredBitmap(const SkBitmap& bitmap, int blur_amount);
// Shift a bitmap's HSL values. The shift values are in the range of 0-1,
// with the option to specify -1 for 'no change'. The shift values are
// defined as:
// hsl_shift[0] (hue): The absolute hue value for the image - 0 and 1 map
// to 0 and 360 on the hue color wheel (red).
// hsl_shift[1] (saturation): A saturation shift for the image, with the
// following key values:
// 0 = remove all color.
// 0.5 = leave unchanged.
// 1 = fully saturate the image.
// hsl_shift[2] (lightness): A lightness shift for the image, with the
// following key values:
// 0 = remove all lightness (make all pixels black).
// 0.5 = leave unchanged.
// 1 = full lightness (make all pixels white).
static SkBitmap CreateHSLShiftedBitmap(const SkBitmap& bitmap,
float hsl_shift[3]);
// Create a bitmap that is cropped from another bitmap. This is special
// because it tiles the original bitmap, so your coordinates can extend
// outside the bounds of the original image.
static SkBitmap CreateTiledBitmap(const SkBitmap& bitmap,
int src_x, int src_y,
int dst_w, int dst_h);
private:
ImageOperations(); // Class for scoping only.
};
......
skia/ext/image_operations_unittest.cc
View file @ 7b441021
......@@ -5,7 +5,6 @@
#include <stdlib.h>
#include "skia/ext/image_operations.h"
#include "skia/include/SkColorPriv.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "SkBitmap.h"
......@@ -146,256 +145,3 @@ TEST(ImageOperations, ResampleToSame) {
}
}
}
// Blend two bitmaps together at 50% alpha and verify that the result
// is the middle-blend of the two.
TEST(ImageOperations, CreateBlendedBitmap) {
int src_w = 16, src_h = 16;
SkBitmap src_a;
src_a.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
src_a.allocPixels();
SkBitmap src_b;
src_b.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
src_b.allocPixels();
for (int y = 0, i = 0; y < src_h; y++) {
for (int x = 0; x < src_w; x++) {
*src_a.getAddr32(x, y) = SkColorSetARGB(255, 0, i * 2 % 255, i % 255);
*src_b.getAddr32(x, y) =
SkColorSetARGB((255 - i) % 255, i % 255, i * 4 % 255, 0);
i++;
}
}
// Shift to red.
SkBitmap blended = skia::ImageOperations::CreateBlendedBitmap(
src_a, src_b, 0.5);
SkAutoLockPixels srca_lock(src_a);
SkAutoLockPixels srcb_lock(src_b);
SkAutoLockPixels blended_lock(blended);
for (int y = 0; y < src_h; y++) {
for (int x = 0; x < src_w; x++) {
int i = y * src_w + x;
EXPECT_EQ((255 + ((255 - i) % 255)) / 2,
SkColorGetA(*blended.getAddr32(x, y)));
EXPECT_EQ(i % 255 / 2,
SkColorGetR(*blended.getAddr32(x, y)));
EXPECT_EQ(((i * 2) % 255 + (i * 4) % 255) / 2,
SkColorGetG(*blended.getAddr32(x, y)));
EXPECT_EQ(i % 255 / 2,
SkColorGetB(*blended.getAddr32(x, y)));
}
}
}
// Test our masking functions.
TEST(ImageOperations, CreateMaskedBitmap) {
int src_w = 16, src_h = 16;
SkBitmap src;
FillDataToBitmap(src_w, src_h, &src);
// Generate alpha mask
SkBitmap alpha;
alpha.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
alpha.allocPixels();
unsigned char* src_data =
reinterpret_cast<unsigned char*>(alpha.getAddr32(0, 0));
for (int i = 0; i < src_w * src_h; i++) {
src_data[i * 4] = SkColorSetARGB(i + 128 % 255,
i + 128 % 255,
i + 64 % 255,
i + 0 % 255);
}
SkBitmap masked = skia::ImageOperations::CreateMaskedBitmap(src, alpha);
SkAutoLockPixels src_lock(src);
SkAutoLockPixels masked_lock(masked);
for (int y = 0; y < src_h; y++) {
for (int x = 0; x < src_w; x++) {
// Test that the alpha is equal.
SkColor src_pixel = *src.getAddr32(x, y);
SkColor alpha_pixel = *alpha.getAddr32(x, y);
SkColor masked_pixel = *masked.getAddr32(x, y);
// Test that the alpha is equal.
int alpha = (alpha_pixel & 0xff000000) >> SK_A32_SHIFT;
EXPECT_EQ(alpha, (masked_pixel & 0xff000000) >> SK_A32_SHIFT);
// Test that the colors are right - SkBitmaps have premultiplied alpha,
// so we can't just do a direct comparison.
EXPECT_EQ(SkColorGetR(masked_pixel),
SkAlphaMul(SkColorGetR(src_pixel), alpha));
}
}
}
// Testing blur without reimplementing the blur algorithm here is tough,
// so we just check to see if the pixels have moved in the direction we
// think they should move in (and also checking the wrapping behavior).
// This will allow us to tweak the blur algorithm to suit speed/visual
// needs without breaking the fundamentals.
TEST(ImageOperations, CreateBlurredBitmap) {
int src_w = 4, src_h = 4;
SkBitmap src;
src.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
src.allocPixels();
for (int y = 0, i = 0; y < src_h; y++) {
for (int x = 0; x < src_w; x++) {
int r = (y == 0) ? 255 : 0; // Make the top row red.
int g = (i % 2 == 0) ? 255 : 0; // Make green alternate in each pixel.
int b = (y == src_h - 1) ? 255 : 0; // Make the bottom row blue.
*src.getAddr32(x, y) = SkColorSetARGB(255, r, g, b);
i++;
}
}
// Perform a small blur (enough to shove the values in the direction we
// need - more would just be an unneccessary unit test slowdown).
SkBitmap blurred = skia::ImageOperations::CreateBlurredBitmap(src, 2);
SkAutoLockPixels src_lock(src);
SkAutoLockPixels blurred_lock(blurred);
for (int y = 0, i = 0; y < src_w; y++) {
for (int x = 0; x < src_h; x++) {
SkColor src_pixel = *src.getAddr32(x, y);
SkColor blurred_pixel = *blurred.getAddr32(x, y);
if (y == 0) {
// We expect our red to have decreased, but our blue to have
// increased (from the wrapping from the bottom line).
EXPECT_TRUE(SkColorGetR(blurred_pixel) < SkColorGetR(src_pixel));
EXPECT_TRUE(SkColorGetB(blurred_pixel) > SkColorGetB(src_pixel));
} else if (y == src_h - 1) {
// Now for the opposite.
EXPECT_TRUE(SkColorGetB(blurred_pixel) < SkColorGetB(src_pixel));
EXPECT_TRUE(SkColorGetR(blurred_pixel) > SkColorGetR(src_pixel));
}
// Expect the green channel to have moved towards the center (but
// not past it).
if (i % 2 == 0) {
EXPECT_LT(SkColorGetG(blurred_pixel), SkColorGetG(src_pixel));
EXPECT_GE(SkColorGetG(blurred_pixel), static_cast<uint32>(128));
} else {
EXPECT_GT(SkColorGetG(blurred_pixel), SkColorGetG(src_pixel));
EXPECT_LE(SkColorGetG(blurred_pixel), static_cast<uint32>(128));
}
i++;
}
}
}
// Make sure that when shifting a bitmap without any shift parameters,
// the end result is close enough to the original (rounding errors
// notwithstanding).
TEST(ImageOperations, CreateHSLShiftedBitmapToSame) {
int src_w = 4, src_h = 4;
SkBitmap src;
src.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
src.allocPixels();
for (int y = 0, i = 0; y < src_h; y++) {
for (int x = 0; x < src_w; x++) {
*src.getAddr32(x, y) = SkColorSetARGB(i + 128 % 255,
i + 128 % 255, i + 64 % 255, i + 0 % 255);
i++;
}
}
float hsl[3] = { -1, -1, -1 };
SkBitmap shifted = skia::ImageOperations::CreateHSLShiftedBitmap(src, hsl);
SkAutoLockPixels src_lock(src);
SkAutoLockPixels shifted_lock(shifted);
for (int y = 0; y < src_w; y++) {
for (int x = 0; x < src_h; x++) {
SkColor src_pixel = *src.getAddr32(x, y);
SkColor shifted_pixel = *shifted.getAddr32(x, y);
EXPECT_TRUE(ColorsClose(src_pixel, shifted_pixel));
}
}
}
// Shift a blue bitmap to red.
TEST(ImageOperations, CreateHSLShiftedBitmapHueOnly) {
int src_w = 16, src_h = 16;
SkBitmap src;
src.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
src.allocPixels();
for (int y = 0, i = 0; y < src_h; y++) {
for (int x = 0; x < src_w; x++) {
*src.getAddr32(x, y) = SkColorSetARGB(255, 0, 0, i % 255);
i++;
}
}
// Shift to red.
float hsl[3] = { 0, -1, -1 };
SkBitmap shifted = skia::ImageOperations::CreateHSLShiftedBitmap(src, hsl);
SkAutoLockPixels src_lock(src);
SkAutoLockPixels shifted_lock(shifted);
for (int y = 0, i = 0; y < src_h; y++) {
for (int x = 0; x < src_w; x++) {
EXPECT_TRUE(ColorsClose(*shifted.getAddr32(x, y),
SkColorSetARGB(255, i % 255, 0, 0)));
i++;
}
}
}
// Test our cropping.
TEST(ImageOperations, CreateCroppedBitmap) {
int src_w = 16, src_h = 16;
SkBitmap src;
FillDataToBitmap(src_w, src_h, &src);
SkBitmap cropped = skia::ImageOperations::CreateTiledBitmap(src, 4, 4,
8, 8);
ASSERT_EQ(8, cropped.width());
ASSERT_EQ(8, cropped.height());
SkAutoLockPixels src_lock(src);
SkAutoLockPixels cropped_lock(cropped);
for (int y = 4; y < 12; y++) {
for (int x = 4; x < 12; x++) {
EXPECT_EQ(*src.getAddr32(x, y),
*cropped.getAddr32(x - 4, y - 4));
}
}
}
// Test whether our cropping correctly wraps across image boundaries.
TEST(ImageOperations, CreateCroppedBitmapWrapping) {
int src_w = 16, src_h = 16;
SkBitmap src;
FillDataToBitmap(src_w, src_h, &src);
SkBitmap cropped = skia::ImageOperations::CreateTiledBitmap(
src, src_w / 2, src_h / 2, src_w, src_h);
ASSERT_EQ(src_w, cropped.width());
ASSERT_EQ(src_h, cropped.height());
SkAutoLockPixels src_lock(src);
SkAutoLockPixels cropped_lock(cropped);
for (int y = 0; y < src_h; y++) {
for (int x = 0; x < src_w; x++) {
EXPECT_EQ(*src.getAddr32(x, y),
*cropped.getAddr32((x + src_w / 2) % src_w,
(y + src_h / 2) % src_h));
}
}
}
skia/ext/skia_utils.cc
View file @ 7b441021
......@@ -3,7 +3,6 @@
// found in the LICENSE file.
#include "skia/ext/skia_utils.h"
#include "skia/include/SkColorPriv.h"
#include "SkGradientShader.h"
......@@ -22,104 +21,5 @@ SkShader* CreateGradientShader(int start_point,
grad_points, grad_colors, NULL, 2, SkShader::kRepeat_TileMode);
}
// Helper function for HSLToSKColor.
static inline double calcHue(double temp1, double temp2, double hueVal) {
if (hueVal < 0.0)
hueVal++;
else if (hueVal > 1.0)
hueVal--;
if (hueVal * 6.0 < 1.0)
return temp1 + (temp2 - temp1) * hueVal * 6.0;
if (hueVal * 2.0 < 1.0)
return temp2;
if (hueVal * 3.0 < 2.0)
return temp1 + (temp2 - temp1) * (2.0 / 3.0 - hueVal) * 6.0;
return temp1;
}
SkPMColor HSLToSKColor(U8CPU alpha, float hsl[3]) {
double hue = SkScalarToDouble(hsl[0]);
double saturation = SkScalarToDouble(hsl[1]);
double lightness = SkScalarToDouble(hsl[2]);
double scaleFactor = 256.0;
// If there's no color, we don't care about hue and can do everything based
// on brightness.
if (!saturation) {
U8CPU lightness;
if (hsl[2] < 0)
lightness = 0;
else if (hsl[2] >= SK_Scalar1)
lightness = 255;
else
lightness = SkScalarToFixed(hsl[2]) >> 8;
unsigned greyValue = SkAlphaMul(lightness, alpha);
return SkColorSetARGB(alpha, greyValue, greyValue, greyValue);
}
double temp2 = (lightness < 0.5) ?
lightness * (1.0 + saturation) :
lightness + saturation - (lightness * saturation);
double temp1 = 2.0 * lightness - temp2;
double rh = calcHue(temp1, temp2, hue + 1.0 / 3.0);
double gh = calcHue(temp1, temp2, hue);
double bh = calcHue(temp1, temp2, hue - 1.0 / 3.0);
return SkColorSetARGB(alpha,
SkAlphaMul(static_cast<int>(rh * scaleFactor), alpha),
SkAlphaMul(static_cast<int>(gh * scaleFactor), alpha),
SkAlphaMul(static_cast<int>(bh * scaleFactor), alpha));
}
void SkColorToHSL(SkPMColor c, float hsl[3]) {
double r = SkColorGetR(c) / 255.0;
double g = SkColorGetG(c) / 255.0;
double b = SkColorGetB(c) / 255.0;
double h, s, l;
double vmax = r > g ? r : g;
vmax = vmax > b ? vmax : b;
double vmin = r < g ? r : g;
vmin = vmin < b ? vmin : b;
double delta = vmax - vmin;
l = (vmax + vmin) / 2;
if (delta == 0) {
h = 0;
s = 0;
} else {
if (l < 0.5)
s = delta / (vmax + vmin);
else
s = delta / (2 - vmax - vmin);
double dr = (((vmax - r) / 6.0) + (delta / 2.0)) / delta;
double dg = (((vmax - g) / 6.0) + (delta / 2.0)) / delta;
double db = (((vmax - b) / 6.0) + (delta / 2.0)) / delta;
if (r == vmax)
h = db - dg;
else if (g == vmax)
h = (1.0 / 3.0) + dr - db;
else if (b == vmax)
h = (2.0 / 3.0) + dg - dr;
if (h < 0) h += 1;
if (h > 1) h -= 1;
}
hsl[0] = h;
hsl[1] = s;
hsl[2] = l;
}
} // namespace skia
skia/ext/skia_utils.h
View file @ 7b441021
......@@ -21,12 +21,6 @@ SkShader* CreateGradientShader(int start_point,
SkColor start_color,
SkColor end_color);
// Convert a premultiplied SkColor to a HSL value.
void SkColorToHSL(SkPMColor c, float hsl[3]);
// Convert a HSL color to a premultiplied SkColor.
SkPMColor HSLToSKColor(U8CPU alpha, float hsl[3]);
} // namespace skia
#endif // SKIA_EXT_SKIA_UTILS_H_
......
skia/ext/skia_utils_unittest.cc deleted 100644 → 0
View file @ a0669d01
// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stdlib.h>
#include "skia/ext/skia_utils.h"
#include "skia/include/SkColorPriv.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "SkBitmap.h"
TEST(SkiaUtils, SkColorToHSLRed) {
SkColor red = SkColorSetARGB(255, 255, 0, 0);
SkScalar hsl[3];
skia::SkColorToHSL(red, hsl);
EXPECT_EQ(hsl[0], 0);
EXPECT_EQ(hsl[1], 1);
EXPECT_EQ(hsl[2], 0.5);
}
TEST(SkiaUtils, SkColorToHSLGrey) {
SkColor red = SkColorSetARGB(255, 128, 128, 128);
SkScalar hsl[3];
skia::SkColorToHSL(red, hsl);
EXPECT_EQ(hsl[0], 0);
EXPECT_EQ(hsl[1], 0);
EXPECT_EQ(static_cast<int>(hsl[2] * 100),
static_cast<int>(0.5 * 100)); // Accurate to two decimal places.
}
TEST(SkiaUtils, HSLToSkColorWithAlpha) {
// Premultiplied alpha - this is full red.
SkColor red = SkColorSetARGB(128, 128, 0, 0);
SkScalar hsl[3] = {
SkDoubleToScalar(0),
SkDoubleToScalar(1),
SkDoubleToScalar(0.5),
};
SkColor result = skia::HSLToSKColor(128, hsl);
EXPECT_EQ(SkColorGetA(red), SkColorGetA(result));
EXPECT_EQ(SkColorGetR(red), SkColorGetR(result));
EXPECT_EQ(SkColorGetG(red), SkColorGetG(result));
EXPECT_EQ(SkColorGetB(red), SkColorGetB(result));
}
webkit/tools/test_shell/test_shell.gyp
View file @ 7b441021
......@@ -302,7 +302,6 @@
'sources': [
'../../../skia/ext/convolver_unittest.cc',
'../../../skia/ext/image_operations_unittest.cc',
'../../../skia/ext/skia_utils_unittest.cc'
'../../../skia/ext/platform_canvas_unittest.cc',
'../../../skia/ext/vector_canvas_unittest.cc',
'../../glue/bookmarklet_unittest.cc',
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment