RgbColor object API - Makuna/NeoPixelBus GitHub Wiki

RgbColor represents a color object that is represented by Red, Green, Blue component values.

Properties

There are three properties that represent the component values Red, Green, and Blue. The values range from 0 to 255. Black would 0,0,0 and white would be 255,255,255.

uint8_t R;
uint8_t G;
uint8_t B;

There are also a few constant properties that are helpful to use. These are..

Max

The highest value for a single color element.

    const static uint16_t Max = 255;

Count

The number of color elements. Useful when accessing the elements using the [] operators.

    const static size_t Count = 3;

Constructors

RgbColor(uint8_t r, uint8_t g, uint8_t b) :

Constructs a RgbColor using Red, Green, and Blue color component values.

r - value of Red component (0 - 255)

g - value of Green component (0 - 255)

b - value of Blue component (0 - 255)

explicit RgbColor(RgbwColor color);

Construct a RgbColor using RgbwColor, copying the R,G,B values and ignoring the W value. Due to the loss of information of the W value, this constructor is marked explicit so it will not automatically be used for conversion.

color - an RgbwColor object

RgbColor(uint8_t brightness)

Constructs a RgbColor using a single brightness value(0 - 255). This works well for creating gray tone colors.

brightness - brightness value where (0) = black, (128) = gray, (255) = white

RgbColor(HtmlColor color);

Construct a RgbColor using HtmlColor, converting the Html single value to Rgb component values

color - an HtmlColor object

RgbColor(HslColor color);

Construct a RgbColor using HslColor, converting the Hsl to Rgb

color - an HslColor object

RgbColor(HsbColor color);

Construct a RgbColor using HsbColor, converting the Hsb to Rgb

color - an HsbColor object

RgbColor()

Construct a RgbColor that will have its values set in latter operations.
CAUTION: The R,G,B members are not initialized and may not be consistent until set.

Methods

uint8_t CalculateBrightness();

CalculateBrightness will calculate the overall brightness.
NOTE: This is a simple linear brightness

RgbColor Dim(uint8_t ratio);

Dim will return a new color that is blended to black with the given ratio.
NOTE: This is a simple linear change.

ratio - (0-255) where 255 will return the original color and 0 will return black.

RgbColor Brighten(uint8_t ratio);

Brighten will return a new color that is blended to white with the given ratio.
NOTE: This is a simple linear change.

ratio - (0-255) where 255 will return the original color and 0 will return white.

void Darken(uint8_t delta);

Darken will adjust the color by the given delta toward black.
NOTE: This is a simple linear change.

delta - (0-255) the amount to dim the color by.

void Lighten(uint8_t delta);

Lighten will adjust the color by the given delta toward white.
NOTE: This is a simple linear change.

delta - (0-255) the amount to lighten the color by.

int16_t CompareTo(const RgbColor& other, uint8_t epsilon = 1)

Compares against another color with the given epsilon.
Returns the greatest difference of a set of elements, where 0 means the colors are equal within epsilon delta, negative means this is less than the other, positive means this is greater than the other.

other - the color to compare against.

epsilon - the max delta acceptable for them to be considered the same color.

static int16_t Compare(const RgbColor& left, const RgbColor& right, uint8_t epsilon = 1)

Compares two colors with the given epsilon.
Returns the greatest difference of a set of elements, where 0 means the colors are equal within epsilon delta, negative means left is less than the right, positive means left is greater than the right.

left - the first color to compare.

right - the other color to compare.

epsilon - the max delta acceptable for them to be considered the same color.

static RgbColor LinearBlend(RgbColor left, RgbColor right, float progress);

This will blend between two colors by the amount defined by the progress variable.

left - the color to start the blend at.

right - the color to end the blend at.

progress - (0.0f - 1.0f) value where 0.0f will return left and 1.0f will return right and a value between will blend the color weighted linearly between them.
This is a static function, which means you need to call it scoped to the object class and not an instance like...

    RgbColor results = RgbColor::LinearBlend(RgbColor(255,0,0), RgbColor(0,255,0), 0.33f);

static RgbColor LinearBlend(RgbColor left, RgbColor right, uint8_t progress);

This will blend between two colors by the amount defined by the progress variable.

left - the color to start the blend at.

right - the color to end the blend at.

progress - (0 - 255) value where 0 will return left and 255 will return right and a value between will blend the color weighted linearly between them.
This is a static function, which means you need to call it scoped to the object class and not an instance like...

    RgbColor results = RgbColor::LinearBlend(RgbColor(255,0,0), RgbColor(0,255,0), 85);

static RgbColor BilinearBlend(RgbColor c00, RgbColor c01, RgbColor c10, RgbColor c11, float x, float y);

This will blend between four colors by the amount defined by 2d weighting values.

c00 - upper left quadrant color

c01 - upper right quadrant color

c10 - lower left quadrant color

c11 - lower right quadrant color

x - unit value (0.0 - 1.0) that defines the blend progress in horizontal space

y - unit value (0.0 - 1.0) that defines the blend progress in vertical space

Operators

uint8_t operator[](size_t idx)

The index operator allows accessing the R, G, and B properties using an index. There are both read only and read write versions.

   uint16_t green = color[1];

You can also use the color index constants.

   uint16_t green = color[ColorIndexG];