Rgbw64Color object API

Rgbw64Color represents a color object that is represented by Red, Green, Blue, and White component values. Its primary use is to contain and manipulate colors for 4 element Pixels with 16bit resolution.

Properties

There are four properties that represent the component values Red, Green, Blue, and White. The values range from 0 to 65535. Black would 0,0,0,0 and white using the color LEDs would be 65535,65535,65535,0 and white using the white LED would be 0,0,0,65535.

uint16_t R;
uint16_t G;
uint16_t B;
uint16_t W;

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 = 65535;

Count

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

    const static size_t Count = 4;

Constructors

Rgbw64Color(uint16_t r, uint16_t g, uint16_t b, uint16_t w) :

Constructs a Rgbw64Color using Red, Green, Blue, and White component values.

r - value for the Red component (0 - 65535)

g - value for the Green component (0 - 65535)

b - value for the Blue component (0 - 65535)

w - value for the White component (0 - 65535)

Rgbw64Color(uint16_t brightness)

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

brightness - value for the white component where (0) = black, (21845) = gray, (65535) = white.
This will only affect the W color element.

Rgbw64Color(RgbColor color);

Construct a Rgbw64Color using RgbColor, converting the R,G,B values and setting W to zero.

color - a RgbColor object.

Rgbw64Color(Rgb48Color color);

Construct a Rgbw64Color using Rgb48Color, copying the R,G,B values and setting W to zero.

color - a Rgb48Color object.

Rgbw64Color(RgbwColor color);

Construct a Rgbw64Color using RgbwColor, converting the R,G,B, and W values.

color - a RgbwColor object.

Rgbw64Color(HslColor color);

Construct a Rgbw64Color using HslColor, converting the Hsl to Rgbw

color - a HslColor object.

Rgbw64Color(HsbColor color);

Construct a Rgbw64Color using HsbColor, converting the Hsb to Rgbw

color - a HsbColor object.

Rgbw64Color()

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

Methods

uint16_t CalculateBrightness();

CalculateBrightness will calculate the overall brightness.
NOTE: For color objects with only W set, it will return W. For color objects with W set to zero this is a simple linear brightness. For color objects with values in W and another color component, the overall brightness is the brighter of the color components and the W.

Rgbw64Color Dim(uint16_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-65535) where 65535 will return the original color and 0 will return black.

Rgbw64Color Brighten(uint16_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-65535) where 65535 will return the original color and 0 will return white.

Rgbw64Color 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.

Rgbw64Color 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(uint16_t delta);

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

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

void Lighten(uint16_t delta);

Lighten will adjust the color by the given delta toward white.
NOTE: This is a simple linear change. If the color only has W value set, only W will be modified; otherwise only the R,G,B will be modified leaving W alone.

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

int32_t CompareTo(const Rgbw64Color& other, uint16_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 int32_t Compare(const Rgbw64Color& left, const Rgbw64Color& right, uint16_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 Rgbw64Color LinearBlend(Rgbw64Color left, Rgbw64Color 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...

    Rgbw64Color results = Rgbw64Color::LinearBlend(Rgbw64Color(65535,0,0,0), Rgbw64Color(0,65535,0,10), 0.33f);

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