| #Topic Color |
| #Alias Color_Reference ## |
| |
| #File |
| Types, consts, functions, and macros for colors. |
| ## |
| |
| #Subtopic Overview |
| #Populate |
| ## |
| |
| #Subtopic Define |
| #Populate |
| ## |
| |
| Color constants can be helpful to write code, documenting the meaning of values |
| the represent transparency and color values. The use of Color constants is not |
| required. |
| |
| #Subtopic Constant |
| #Populate |
| ## |
| |
| #Subtopic Function |
| #Populate |
| ## |
| |
| #Subtopic Typedef |
| #Populate |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Subtopic Alpha |
| |
| Alpha represents the transparency of Color. Color with Alpha of zero is fully |
| transparent. Color with Alpha of 255 is fully opaque. Some, but not all pixel |
| formats contain Alpha. Pixels with Alpha may store it as unsigned integers or |
| floating point values. Unsigned integer Alpha ranges from zero, fully |
| transparent, to all bits set, fully opaque. Floating point Alpha ranges from |
| zero, fully transparent, to one, fully opaque. |
| |
| #Alias Alpha |
| #Substitute alpha |
| ## |
| |
| #Typedef uint8_t SkAlpha |
| #Line # defines Alpha as eight bits ## |
| |
| #Code |
| typedef uint8_t SkAlpha; |
| ## |
| |
| 8-bit type for an alpha value. 255 is 100% opaque, zero is 100% transparent. |
| |
| #Typedef ## |
| |
| #Subtopic ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Typedef uint32_t SkColor |
| #Line # defines Color as 32 bits ## |
| |
| #Code |
| typedef uint32_t SkColor; |
| ## |
| |
| 32-bit ARGB Color value, Unpremultiplied. Color components are always in |
| a known order. This is different from SkPMColor, which has its bytes in a configuration |
| dependent order, to match the format of kBGRA_8888_SkColorType bitmaps. SkColor |
| is the type used to specify colors in SkPaint and in gradients. |
| |
| Color that is Premultiplied has the same component values as Color |
| that is Unpremultiplied if Alpha is 255, fully opaque, although may have the |
| component values in a different order. |
| |
| #SeeAlso SkPMColor |
| |
| #Typedef ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static constexpr inline SkColor SkColorSetARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) |
| #In Function |
| #Line # returns Color_Alpha and RGB combined ## |
| |
| Returns Color value from 8-bit component values. Asserts if SK_DEBUG is defined |
| if a, r, g, or b exceed 255. Since Color is Unpremultiplied, a may be smaller |
| than the largest of r, g, and b. |
| |
| #Param a amount of Alpha, from fully transparent (0) to fully opaque (255) ## |
| #Param r amount of red, from no red (0) to full red (255) ## |
| #Param g amount of green, from no green (0) to full green (255) ## |
| #Param b amount of blue, from no blue (0) to full blue (255) ## |
| |
| #Return color and alpha, Unpremultiplied ## |
| |
| #Example |
| canvas->drawColor(SK_ColorRED); |
| canvas->clipRect(SkRect::MakeWH(150, 150)); |
| canvas->drawColor(SkColorSetARGB(0x80, 0x00, 0xFF, 0x00)); |
| canvas->clipRect(SkRect::MakeWH(75, 75)); |
| canvas->drawColor(SkColorSetARGB(0x80, 0x00, 0x00, 0xFF)); |
| ## |
| |
| #SeeAlso SkColorSetRGB SkPaint::setARGB SkPaint::setColor SkColorSetA |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Define SkColorSetRGB |
| #Line # returns opaque Color ## |
| |
| #Code |
| ###$ |
| #define SkColorSetRGB(r, g, b) SkColorSetARGB(0xFF, r, g, b) |
| $$$# |
| ## |
| |
| Returns Color value from 8-bit component values, with Alpha set |
| fully opaque to 255. |
| |
| #Param r amount of red, from no red (0) to full red (255) ## |
| #Param g amount of green, from no green (0) to full green (255) ## |
| #Param b amount of blue, from no blue (0) to full blue (255) ## |
| |
| #Return color with opaque alpha ## |
| |
| #Example |
| canvas->drawColor(SK_ColorRED); |
| canvas->clipRect(SkRect::MakeWH(150, 150)); |
| canvas->drawColor(SkColorSetRGB(0x00, 0xFF, 0x00)); |
| canvas->clipRect(SkRect::MakeWH(75, 75)); |
| canvas->drawColor(SkColorSetRGB(0x00, 0x00, 0xFF)); |
| ## |
| |
| #SeeAlso SkColorSetARGB |
| |
| #Define ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Define SkColorGetA |
| #Line # returns Alpha component ## |
| |
| #Code |
| ###$ |
| #define SkColorGetA(color) (((color) >> 24) & 0xFF) |
| $$$# |
| ## |
| |
| Returns Alpha byte from Color value. |
| |
| #Param color SkColor, a 32-bit unsigned int, in 0xAARRGGBB format ## |
| |
| #Example |
| SkPaint paint;
|
| paint.setAntiAlias(true);
|
| paint.setColor(SK_ColorRED);
|
| for (int alpha = 255; alpha >= 0; alpha -= 17) {
|
| paint.setAlpha(alpha);
|
| canvas->drawRect({5, 5, 100, 20}, paint);
|
| SkAlpha alphaInPaint = SkColorGetA(paint.getColor());
|
| canvas->drawString(std::to_string(alphaInPaint).c_str(), 110, 18, paint);
|
| canvas->translate(0, 15);
|
| }
|
| ## |
| |
| #SeeAlso SkPaint::getAlpha |
| |
| #Define ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Define SkColorGetR |
| #Line # returns red component ## |
| |
| #Code |
| ###$ |
| #define SkColorGetR(color) (((color) >> 16) & 0xFF) |
| $$$# |
| ## |
| |
| Returns red component of Color, from zero to 255. |
| |
| #Param color SkColor, a 32-bit unsigned int, in 0xAARRGGBB format ## |
| #Return red byte ## |
| |
| #Example |
| #Image 3 |
| canvas->drawBitmap(source, 0, 0);
|
| SkPaint bgPaint;
|
| bgPaint.setColor(0xafffffff);
|
| canvas->drawRect({20, 50, 80, 70}, bgPaint);
|
| uint8_t red = SkColorGetR(source.getColor(226, 128));
|
| canvas->drawString(std::to_string(red).c_str(), 40, 65, SkPaint());
|
| canvas->drawLine(80, 70, 226, 128, SkPaint());
|
| ## |
| |
| #SeeAlso SkColorGetG SkColorGetB |
| |
| #Define ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Define SkColorGetG |
| #Line # returns green component ## |
| |
| #Code |
| ###$ |
| #define SkColorGetG(color) (((color) >> 8) & 0xFF) |
| $$$# |
| ## |
| |
| Returns green component of Color, from zero to 255. |
| |
| #Param color SkColor, a 32-bit unsigned int, in 0xAARRGGBB format ## |
| #Return green byte ## |
| |
| #Example |
| #Image 3 |
| canvas->drawBitmap(source, 0, 0);
|
| SkPaint bgPaint;
|
| bgPaint.setColor(0xafffffff);
|
| canvas->drawRect({20, 50, 80, 70}, bgPaint);
|
| uint8_t green = SkColorGetG(source.getColor(57, 192));
|
| canvas->drawString(std::to_string(green).c_str(), 40, 65, SkPaint());
|
| canvas->drawLine(80, 70, 57, 192, SkPaint()); |
| ## |
| |
| #SeeAlso SkColorGetR SkColorGetB |
| |
| #Define ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Define SkColorGetB |
| #Line # returns blue component ## |
| |
| #Code |
| ###$ |
| #define SkColorGetB(color) (((color) >> 0) & 0xFF) |
| $$$# |
| ## |
| |
| Returns blue component of Color, from zero to 255. |
| |
| #Param color SkColor, a 32-bit unsigned int, in 0xAARRGGBB format ## |
| #Return blue byte ## |
| |
| #Example |
| #Image 3 |
| canvas->drawBitmap(source, 0, 0);
|
| SkPaint bgPaint;
|
| bgPaint.setColor(0xafffffff);
|
| canvas->drawRect({20, 50, 80, 70}, bgPaint);
|
| uint8_t blue = SkColorGetB(source.getColor(168, 170));
|
| canvas->drawString(std::to_string(blue).c_str(), 40, 65, SkPaint());
|
| canvas->drawLine(80, 70, 168, 170, SkPaint()); |
| ## |
| |
| #SeeAlso SkColorGetR SkColorGetG |
| |
| #Define ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static constexpr inline SkColor SkColorSetA(SkColor c, U8CPU a) |
| #In Function |
| #Line # returns Color with transparency ## |
| |
| Returns Unpremultiplied Color with red, blue, and green set from c; and alpha set |
| from a. Alpha component of c is ignored and is replaced by a in result. |
| |
| #Param c packed RGB, eight bits per component ## |
| #Param a Alpha: transparent at zero, fully opaque at 255 ## |
| |
| #Return Color with transparency ## |
| |
| #Example |
| #Image 3 |
| canvas->drawBitmap(source, 0, 0);
|
| for (int y = 0; y < 256; y += 16) {
|
| for (int x = 0; x < 256; x += 16) {
|
| SkColor color = source.getColor(x + 8, y + 8);
|
| SkPaint paint;
|
| paint.setColor(SkColorSetA(color, x + y));
|
| canvas->drawRect(SkRect::MakeXYWH(x, y, 16, 16), paint);
|
| }
|
| }
|
| ## |
| |
| #SeeAlso SkColorSetARGB |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Subtopic Alpha_Constants |
| #In Constant |
| #Line # constants for Alpha ## |
| |
| #Code |
| constexpr SkAlpha SK_AlphaTRANSPARENT = 0x00; |
| constexpr SkAlpha SK_AlphaOPAQUE = 0xFF; |
| ## |
| |
| Alpha constants are conveniences to represent fully transparent and fully |
| opaque colors and masks. Their use is not required. |
| |
| #Const SK_AlphaTRANSPARENT 0x00 |
| #Line # fully transparent SkAlpha ## |
| #Details Transparent |
| Represents fully transparent SkAlpha value. SkAlpha ranges from zero, |
| fully transparent; to 255, fully opaque. |
| ## |
| #Const SK_AlphaOPAQUE 0xFF |
| #Line # fully opaque SkAlpha ## |
| #Details Opaque |
| Represents fully opaque SkAlpha value. SkAlpha ranges from zero, |
| fully transparent; to 255, fully opaque. |
| ## |
| |
| #Subtopic Transparent |
| |
| #Example |
| #Image 1 |
| #Height 128 |
| #Description |
| Color the parts of the bitmap red if they mostly contain transparent pixels. |
| ## |
| std::vector<int32_t> srcPixels; |
| srcPixels.resize(source.height() * source.rowBytes()); |
| SkPixmap pixmap(SkImageInfo::MakeN32Premul(source.width(), source.height()), |
| &srcPixels.front(), source.rowBytes()); |
| source.readPixels(pixmap, 0, 0); |
| for (int y = 0; y < 16; ++y) { |
| for (int x = 0; x < 16; ++x) { |
| int32_t* blockStart = &srcPixels.front() + y * source.width() * 16 + x * 16; |
| size_t transparentCount = 0; |
| for (int fillY = 0; fillY < source.height() / 16; ++fillY) { |
| for (int fillX = 0; fillX < source.width() / 16; ++fillX) { |
| const SkColor color = SkUnPreMultiply::PMColorToColor(blockStart[fillX]); |
| transparentCount += SkColorGetA(color) == SK_AlphaTRANSPARENT; |
| } |
| blockStart += source.width(); |
| } |
| if (transparentCount > 200) { |
| blockStart = &srcPixels.front() + y * source.width() * 16 + x * 16; |
| for (int fillY = 0; fillY < source.height() / 16; ++fillY) { |
| for (int fillX = 0; fillX < source.width() / 16; ++fillX) { |
| blockStart[fillX] = SK_ColorRED; |
| } |
| blockStart += source.width(); |
| } |
| } |
| } |
| } |
| SkBitmap bitmap; |
| bitmap.installPixels(pixmap); |
| canvas->drawBitmap(bitmap, 0, 0); |
| ## |
| |
| #SeeAlso SkAlpha SK_ColorTRANSPARENT SK_AlphaOPAQUE |
| |
| #Subtopic Transparent ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Subtopic Opaque |
| |
| #Example |
| #Image 1 |
| #Height 128 |
| std::vector<int32_t> srcPixels; |
| srcPixels.resize(source.height() * source.rowBytes()); |
| SkPixmap pixmap(SkImageInfo::MakeN32Premul(source.width(), source.height()), |
| &srcPixels.front(), source.rowBytes()); |
| source.readPixels(pixmap, 0, 0); |
| for (int y = 0; y < source.height(); ++y) { |
| for (int x = 0; x < source.width(); ++x) { |
| SkPMColor pixel = srcPixels[y * source.width() + x]; |
| const SkColor color = SkUnPreMultiply::PMColorToColor(pixel); |
| if (SkColorGetA(color) == SK_AlphaOPAQUE) { |
| srcPixels[y * source.width() + x] = SK_ColorGREEN; |
| } |
| } |
| } |
| SkBitmap bitmap; |
| bitmap.installPixels(pixmap); |
| canvas->drawBitmap(bitmap, 0, 0); |
| ## |
| |
| #SeeAlso SkAlpha SK_AlphaTRANSPARENT |
| |
| #Subtopic Opaque ## |
| #Subtopic Alpha_Constants ## |
| |
| #Subtopic Color_Constants |
| #In Constant |
| #Line # constants for Color ## |
| |
| # ------------------------------------------------------------------------------ |
| #Code |
| constexpr SkColor SK_ColorTRANSPARENT = SkColorSetARGB(0x00, 0x00, 0x00, 0x00); |
| constexpr SkColor SK_ColorBLACK = SkColorSetARGB(0xFF, 0x00, 0x00, 0x00); |
| constexpr SkColor SK_ColorDKGRAY = SkColorSetARGB(0xFF, 0x44, 0x44, 0x44); |
| constexpr SkColor SK_ColorGRAY = SkColorSetARGB(0xFF, 0x88, 0x88, 0x88); |
| constexpr SkColor SK_ColorLTGRAY = SkColorSetARGB(0xFF, 0xCC, 0xCC, 0xCC); |
| constexpr SkColor SK_ColorWHITE = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF); |
| constexpr SkColor SK_ColorRED = SkColorSetARGB(0xFF, 0xFF, 0x00, 0x00); |
| constexpr SkColor SK_ColorGREEN = SkColorSetARGB(0xFF, 0x00, 0xFF, 0x00); |
| constexpr SkColor SK_ColorBLUE = SkColorSetARGB(0xFF, 0x00, 0x00, 0xFF); |
| constexpr SkColor SK_ColorYELLOW = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0x00); |
| constexpr SkColor SK_ColorCYAN = SkColorSetARGB(0xFF, 0x00, 0xFF, 0xFF); |
| constexpr SkColor SK_ColorMAGENTA = SkColorSetARGB(0xFF, 0xFF, 0x00, 0xFF); |
| ## |
| |
| Color names are provided as conveniences, but are not otherwise special. |
| The values chosen for names may not be the same as values used by |
| SVG, HTML, CSS, or colors named by a platform. |
| |
| #Example |
| ###$ |
| $Function |
| #define SKIA_COLOR_PAIR(name) "SK_Color" #name, SK_Color##name |
| $$ |
| void draw(SkCanvas* canvas) { |
| struct ColorCompare { |
| const char* fSVGName; |
| SkColor fSVGColor; |
| const char* fSkiaName; |
| SkColor fSkiaColor; |
| } colorCompare[] = { // see https://www.w3.org/TR/SVG/types.html#ColorKeywords |
| {"black", SkColorSetRGB( 0, 0, 0), SKIA_COLOR_PAIR(BLACK) }, |
| {"darkgray", SkColorSetRGB(169, 169, 169), SKIA_COLOR_PAIR(DKGRAY) }, |
| {"gray", SkColorSetRGB(128, 128, 128), SKIA_COLOR_PAIR(GRAY) }, |
| {"lightgray", SkColorSetRGB(211, 211, 211), SKIA_COLOR_PAIR(LTGRAY) }, |
| {"white", SkColorSetRGB(255, 255, 255), SKIA_COLOR_PAIR(WHITE) }, |
| {"red", SkColorSetRGB(255, 0, 0), SKIA_COLOR_PAIR(RED) }, |
| {"green", SkColorSetRGB( 0, 128, 0), SKIA_COLOR_PAIR(GREEN) }, |
| {"blue", SkColorSetRGB( 0, 0, 255), SKIA_COLOR_PAIR(BLUE) }, |
| {"yellow", SkColorSetRGB(255, 255, 0), SKIA_COLOR_PAIR(YELLOW) }, |
| {"aqua", SkColorSetRGB( 0, 255, 255), SKIA_COLOR_PAIR(CYAN) }, |
| {"fuchsia", SkColorSetRGB(255, 0, 255), SKIA_COLOR_PAIR(MAGENTA) }, |
| }; |
| SkPaint paint; |
| paint.setAntiAlias(true); |
| paint.setTextSize(14); |
| for (auto compare : colorCompare) { |
| paint.setStyle(SkPaint::kFill_Style); |
| paint.setColor(compare.fSVGColor); |
| canvas->drawRect({5, 5, 15, 15}, paint); |
| paint.setColor(SK_ColorBLACK); |
| canvas->drawString(compare.fSVGName, 20, 16, paint); |
| paint.setColor(compare.fSkiaColor); |
| canvas->drawRect({105, 5, 115, 15}, paint); |
| paint.setColor(SK_ColorBLACK); |
| canvas->drawString(compare.fSkiaName, 120, 16, paint); |
| paint.setStyle(SkPaint::kStroke_Style); |
| canvas->drawRect({5, 5, 15, 15}, paint); |
| canvas->drawRect({105, 5, 115, 15}, paint); |
| canvas->translate(0, 20); |
| } |
| } |
| $$$# |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Const SK_ColorTRANSPARENT 0x00000000 |
| #Line # transparent Color ## |
| #Details Transparent |
| Represents fully transparent SkColor. May be used to initialize a destination |
| containing a mask or a non-rectangular image. |
| ## |
| #Const SK_ColorBLACK 0xFF000000 |
| #Line # black Color ## |
| #Details Black |
| Represents fully opaque black. |
| ## |
| #Const SK_ColorDKGRAY 0xFF444444 |
| #Line # dark gray Color ## |
| Represents fully opaque dark gray. |
| Note that SVG_darkgray is equivalent to 0xFFA9A9A9. |
| ## |
| #Const SK_ColorGRAY 0xFF888888 |
| #Line # gray Color ## |
| Represents fully opaque gray. |
| Note that HTML_Gray is equivalent to 0xFF808080. |
| ## |
| #Const SK_ColorLTGRAY 0xFFCCCCCC |
| #Line # light gray Color ## |
| Represents fully opaque light gray. HTML_Silver is equivalent to 0xFFC0C0C0. |
| Note that SVG_lightgray is equivalent to 0xFFD3D3D3. |
| ## |
| #Const SK_ColorWHITE 0xFFFFFFFF |
| #Line # white Color ## |
| Represents fully opaque white. |
| ## |
| #Const SK_ColorRED 0xFFFF0000 |
| #Line # red Color ## |
| Represents fully opaque red. |
| ## |
| #Const SK_ColorGREEN 0xFF00FF00 |
| #Line # green Color ## |
| Represents fully opaque green. HTML_Lime is equivalent. |
| Note that HTML_Green is equivalent to 0xFF008000. |
| ## |
| #Const SK_ColorBLUE 0xFF0000FF |
| #Line # blue Color ## |
| Represents fully opaque blue. |
| ## |
| #Const SK_ColorYELLOW 0xFFFFFF00 |
| #Line # yellow Color ## |
| Represents fully opaque yellow. |
| ## |
| #Const SK_ColorCYAN 0xFF00FFFF |
| #Line # cyan Color ## |
| Represents fully opaque cyan. HTML_Aqua is equivalent. |
| ## |
| #Const SK_ColorMAGENTA 0xFFFF00FF |
| #Line # magenta Color ## |
| Represents fully opaque magenta. HTML_Fuchsia is equivalent. |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Subtopic Transparent |
| |
| #Example |
| #Image 3 |
| std::vector<uint32_t> srcPixels; |
| constexpr int width = 256; |
| constexpr int height = 256; |
| srcPixels.resize(width * height); |
| SkImageInfo imageInfo = SkImageInfo::MakeN32Premul(width, height); |
| SkPixmap pixmap(imageInfo, &srcPixels.front(), imageInfo.minRowBytes()); |
| pixmap.erase(SK_ColorTRANSPARENT); |
| pixmap.erase(SK_ColorRED, { 24, 24, 192, 192 } ); |
| pixmap.erase(SK_ColorTRANSPARENT, { 48, 48, 168, 168 } ); |
| SkBitmap bitmap; |
| bitmap.installPixels(pixmap); |
| canvas->drawBitmap(bitmap, 0, 0); |
| canvas->drawBitmap(bitmap, 48, 48); |
| ## |
| |
| #SeeAlso SK_AlphaTRANSPARENT SkCanvas::clear |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Subtopic Black |
| |
| #Example |
| std::vector<uint32_t> srcPixels; |
| constexpr int width = 256; |
| constexpr int height = 256; |
| srcPixels.resize(width * height); |
| SkImageInfo imageInfo = SkImageInfo::MakeN32Premul(width, height); |
| SkPixmap pixmap(imageInfo, &srcPixels.front(), imageInfo.minRowBytes()); |
| pixmap.erase(SK_ColorTRANSPARENT); |
| pixmap.erase(SK_ColorRED, { 24, 24, 192, 192 } ); |
| pixmap.erase(SK_ColorBLACK, { 48, 48, 168, 168 } ); |
| SkBitmap bitmap; |
| bitmap.installPixels(pixmap); |
| canvas->drawBitmap(bitmap, 0, 0); |
| canvas->drawBitmap(bitmap, 48, 48); |
| ## |
| |
| #SeeAlso SK_ColorTRANSPARENT |
| |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Subtopic White |
| |
| #Example |
| std::vector<uint32_t> srcPixels; |
| constexpr int width = 256; |
| constexpr int height = 256; |
| srcPixels.resize(width * height); |
| SkImageInfo imageInfo = SkImageInfo::MakeN32Premul(width, height); |
| SkPixmap pixmap(imageInfo, &srcPixels.front(), imageInfo.minRowBytes()); |
| pixmap.erase(SK_ColorTRANSPARENT); |
| pixmap.erase(SK_ColorRED, { 24, 24, 192, 192 } ); |
| pixmap.erase(SK_ColorWHITE, { 48, 48, 168, 168 } ); |
| SkBitmap bitmap; |
| bitmap.installPixels(pixmap); |
| canvas->drawBitmap(bitmap, 0, 0); |
| canvas->drawBitmap(bitmap, 48, 48); |
| ## |
| |
| #SeeAlso SK_ColorTRANSPARENT |
| |
| ## |
| |
| #Subtopic Color_Constants ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Subtopic HSV |
| |
| #Subtopic Hue |
| Hue represents an angle, in degrees, on a color wheel. Hue has a positive value |
| modulo 360, where zero degrees is red. |
| ## |
| |
| #Subtopic Saturation |
| Saturation represents the intensity of the color. Saturation varies from zero, |
| with no Hue contribution; to one, with full Hue contribution. |
| ## |
| |
| #Subtopic Value |
| Value represents the lightness of the color. Value varies from zero, black; to |
| one, full brightness. |
| ## |
| |
| #Method void SkRGBToHSV(U8CPU red, U8CPU green, U8CPU blue, SkScalar hsv[3]) |
| #In Function |
| #Line # converts RGB to HSV ## |
| |
| Converts RGB to its HSV components. |
| hsv[0] contains HSV_Hue, a value from zero to less than 360. |
| hsv[1] contains HSV_Saturation, a value from zero to one. |
| hsv[2] contains HSV_Value, a value from zero to one. |
| |
| #Param red red component value from zero to 255 ## |
| #Param green green component value from zero to 255 ## |
| #Param blue blue component value from zero to 255 ## |
| #Param hsv three element array which holds the resulting HSV components |
| ## |
| |
| #Example |
| #Image 3 |
| canvas->drawBitmap(source, 0, 0);
|
| SkPaint bgPaint;
|
| bgPaint.setColor(0xafffffff);
|
| canvas->drawRect({20, 30, 110, 90}, bgPaint);
|
| SkScalar hsv[3];
|
| SkColor c = source.getColor(226, 128);
|
| SkRGBToHSV(SkColorGetR(c), SkColorGetG(c), SkColorGetB(c), hsv);
|
| canvas->drawString(("h: " + std::to_string(hsv[0]).substr(0, 6)).c_str(), 27, 45, SkPaint());
|
| canvas->drawString(("s: " + std::to_string(hsv[1]).substr(0, 6)).c_str(), 27, 65, SkPaint());
|
| canvas->drawString(("v: " + std::to_string(hsv[2]).substr(0, 6)).c_str(), 27, 85, SkPaint());
|
| canvas->drawLine(110, 90, 226, 128, SkPaint());
|
| ## |
| |
| #SeeAlso SkColorToHSV SkHSVToColor |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void SkColorToHSV(SkColor color, SkScalar hsv[3]) |
| #In Function |
| #Line # converts RGB to HSV ## |
| |
| Converts ARGB to its HSV components. Alpha in ARGB is ignored. |
| hsv[0] contains HSV_Hue, and is assigned a value from zero to less than 360. |
| hsv[1] contains HSV_Saturation, a value from zero to one. |
| hsv[2] contains HSV_Value, a value from zero to one. |
| |
| #Param color ARGB color to convert |
| ## |
| #Param hsv three element array which holds the resulting HSV components |
| ## |
| |
| #Example |
| #Image 3 |
| canvas->drawBitmap(source, 0, 0);
|
| for (int y = 0; y < 256; ++y) {
|
| for (int x = 0; x < 256; ++x) {
|
| SkScalar hsv[3];
|
| SkColorToHSV(source.getColor(x, y), hsv);
|
| hsv[1] = 1 - hsv[1];
|
| SkPaint paint;
|
| paint.setColor(SkHSVToColor(hsv));
|
| canvas->drawRect(SkRect::MakeXYWH(x, y, 1, 1), paint);
|
| }
|
| }
|
| ## |
| |
| #SeeAlso SkRGBToHSV SkHSVToColor |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkColor SkHSVToColor(U8CPU alpha, const SkScalar hsv[3]) |
| #In Function |
| #Line # converts HSV with Alpha to RGB ## |
| |
| Converts HSV components to an ARGB color. Alpha is passed through unchanged. |
| hsv[0] represents HSV_Hue, an angle from zero to less than 360. |
| hsv[1] represents HSV_Saturation, and varies from zero to one. |
| hsv[2] represents HSV_Value, and varies from zero to one. |
| |
| Out of range hsv values are pinned. |
| |
| #Param alpha Alpha component of the returned ARGB color |
| ## |
| #Param hsv three element array which holds the input HSV components |
| ## |
| |
| #Return ARGB equivalent to HSV |
| ## |
| |
| #Example |
| #Image 3 |
| canvas->drawBitmap(source, 0, 0);
|
| for (int y = 0; y < 256; ++y) {
|
| for (int x = 0; x < 256; ++x) {
|
| SkColor color = source.getColor(x, y);
|
| SkScalar hsv[3];
|
| SkColorToHSV(color, hsv);
|
| hsv[0] = hsv[0] + 90 >= 360 ? hsv[0] - 270 : hsv[0] + 90;
|
| SkPaint paint;
|
| paint.setColor(SkHSVToColor(x + y, hsv));
|
| canvas->drawRect(SkRect::MakeXYWH(x, y, 1, 1), paint);
|
| }
|
| }
|
| ## |
| |
| #SeeAlso SkColorToHSV SkRGBToHSV |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkColor SkHSVToColor(const SkScalar hsv[3]) |
| #In Function |
| #Line # converts HSV to RGB ## |
| |
| Converts HSV components to an ARGB color. Alpha is set to 255. |
| hsv[0] represents HSV_Hue, an angle from zero to less than 360. |
| hsv[1] represents HSV_Saturation, and varies from zero to one. |
| hsv[2] represents HSV_Value, and varies from zero to one. |
| |
| Out of range hsv values are pinned. |
| |
| #Param hsv three element array which holds the input HSV components |
| ## |
| |
| #Return RGB equivalent to HSV |
| ## |
| |
| #Example |
| #Image 3 |
| canvas->drawBitmap(source, 0, 0);
|
| for (int y = 0; y < 256; ++y) {
|
| for (int x = 0; x < 256; ++x) {
|
| SkColor color = source.getColor(x, y);
|
| SkScalar hsv[3];
|
| SkColorToHSV(color, hsv);
|
| hsv[0] = hsv[0] + 90 >= 360 ? hsv[0] - 270 : hsv[0] + 90;
|
| SkPaint paint;
|
| paint.setColor(SkHSVToColor(hsv));
|
| canvas->drawRect(SkRect::MakeXYWH(x, y, 1, 1), paint);
|
| }
|
| }
|
| ## |
| |
| #SeeAlso SkColorToHSV SkRGBToHSV |
| |
| #Method ## |
| |
| #Subtopic HSV ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Subtopic PMColor |
| |
| #Typedef uint32_t SkPMColor |
| #Line # defines Premultiplied Color as 32 bits ## |
| |
| #Code |
| typedef uint32_t SkPMColor; |
| ## |
| |
| 32-bit ARGB color value, Premultiplied. The byte order for this value is |
| configuration dependent, matching the format of kBGRA_8888_SkColorType bitmaps. |
| This is different from SkColor, which is Unpremultiplied, and is always in the |
| same byte order. |
| |
| #Typedef ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkPMColor SkPreMultiplyARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) |
| #In Function |
| #Line # converts Unpremultiplied ARGB to Premultiplied PMColor ## |
| |
| Returns a SkPMColor value from Unpremultiplied 8-bit component values. |
| |
| #Param a amount of Alpha, from fully transparent (0) to fully opaque (255) ## |
| #Param r amount of red, from no red (0) to full red (255) ## |
| #Param g amount of green, from no green (0) to full green (255) ## |
| #Param b amount of blue, from no blue (0) to full blue (255) ## |
| |
| #Return Premultiplied Color ## |
| |
| #Example |
| #Height 128 |
| #Width 300 |
| SkPMColor premultiplied = SkPreMultiplyARGB(160, 128, 160, 192);
|
| canvas->drawString("Unpremultiplied:", 20, 20, SkPaint());
|
| canvas->drawString("alpha=160 red=128 green=160 blue=192", 20, 40, SkPaint());
|
| canvas->drawString("Premultiplied:", 20, 80, SkPaint());
|
| std::string str = "alpha=" + std::to_string(SkColorGetA(premultiplied));
|
| str += " red=" + std::to_string(SkColorGetR(premultiplied));
|
| str += " green=" + std::to_string(SkColorGetG(premultiplied));
|
| str += " blue=" + std::to_string(SkColorGetB(premultiplied));
|
| canvas->drawString(str.c_str(), 20, 100, SkPaint()); |
| ## |
| |
| #SeeAlso SkPreMultiplyColor |
| |
| #Method ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method SkPMColor SkPreMultiplyColor(SkColor c) |
| #In Function |
| #Line # converts Unpremultiplied Color to Premultiplied PMColor ## |
| |
| Returns PMColor closest to Color c. Multiplies c RGB components by the c Alpha, |
| and arranges the bytes to match the format of kN32_SkColorType. |
| |
| #Param c Unpremultiplied ARGB Color ## |
| |
| #Return Premultiplied Color ## |
| |
| #Example |
| #Height 128 |
| #Width 300 |
| SkColor unpremultiplied = SkColorSetARGB(160, 128, 160, 192);
|
| SkPMColor premultiplied = SkPreMultiplyColor(unpremultiplied);
|
| canvas->drawString("Unpremultiplied:", 20, 20, SkPaint());
|
| std::string str = "alpha=" + std::to_string(SkColorGetA(unpremultiplied));
|
| str += " red=" + std::to_string(SkColorGetR(unpremultiplied));
|
| str += " green=" + std::to_string(SkColorGetG(unpremultiplied));
|
| str += " blue=" + std::to_string(SkColorGetB(unpremultiplied));
|
| canvas->drawString(str.c_str(), 20, 40, SkPaint());
|
| canvas->drawString("Premultiplied:", 20, 80, SkPaint());
|
| str = "alpha=" + std::to_string(SkColorGetA(premultiplied));
|
| str += " red=" + std::to_string(SkColorGetR(premultiplied));
|
| str += " green=" + std::to_string(SkColorGetG(premultiplied));
|
| str += " blue=" + std::to_string(SkColorGetB(premultiplied));
|
| canvas->drawString(str.c_str(), 20, 100, SkPaint()); |
| ## |
| |
| #SeeAlso SkPreMultiplyARGB |
| |
| #Method ## |
| |
| #Subtopic PMColor ## |
| |
| #Topic Color ## |
