rgb2hsv_approximate()

CHSV rgb2hsv_approximate

(

const CRGB &

rgb

)

Recover approximate HSV values from RGB.

These values are approximate, not exact. Why is this "only" an approximation? Because not all RGB colors have HSV equivalents! For example, there is no HSV value that will ever convert to RGB(255,255,0) using the code provided in this library. So if you try to convert RGB(255,255,0) "back" to HSV, you'll necessarily get only an approximation. Emphasis has been placed on getting the "hue" as close as usefully possible, but even that's a bit of a challenge. The 8-bit HSV and 8-bit RGB color spaces are not a "bijection".

Nevertheless, this function does a pretty good job, particularly at recovering the 'hue' from fully saturated RGB colors that originally came from HSV rainbow colors. So if you start with CHSV(hue_in,255,255), and convert that to RGB, and then convert it back to HSV using this function, the resulting output hue will either exactly the same, or very close (+/-1). The more desaturated the original RGB color is, the rougher the approximation, and the less accurate the results.

Note

This function is a long-term work in progress; expect results to change slightly over time as this function is refined and improved.

Note

This function is most accurate when the input is an RGB color that came from a fully-saturated HSV color to start with. E.g. CHSV( hue, 255, 255) -> CRGB -> CHSV will give best results.

Note

This function is not nearly as fast as HSV-to-RGB. It is provided for those situations when the need for this function cannot be avoided, or when extremely high performance is not needed.

See also

https://en.wikipedia.org/wiki/Bijection

Parameters

rgb	an RGB value to convert

Returns

the approximate HSV equivalent of the RGB value

Definition at line 559 of file hsv2rgb.cpp.hpp.

{
    // These channels can exceed 255 while saturation is being undone. Keep
    // the intermediate values wide until they are normalized below.
    fl::u16 r = rgb.r;
    fl::u16 g = rgb.g;
    fl::u16 b = rgb.b;
    fl::u8 h, s, v;
 
    // find desaturation
    fl::u8 desat = 255;
    if( r < desat) desat = r;
    if( g < desat) desat = g;
    if( b < desat) desat = b;
 
    // remove saturation from all channels
    r -= desat;
    g -= desat;
    b -= desat;
 
    //Serial.print("desat="); Serial.print(desat); Serial.println("");
 
    //uint8_t orig_desat = sqrt16( desat * 256);
    //Serial.print("orig_desat="); Serial.print(orig_desat); Serial.println("");
 
    // saturation is opposite of desaturation
    s = 255 - desat;
    //Serial.print("s.1="); Serial.print(s); Serial.println("");
 
    if( s != 255 ) {
        // undo 'dimming' of saturation
        s = 255 - fl::sqrt16( (255-s) * 256);
    }
    // without lib8tion: float ... ew ... sqrt... double ew, or rather, ew ^ 0.5
    // if( s != 255 ) s = (255 - (256.0 * sqrt( (float)(255-s) / 256.0)));
    //Serial.print("s.2="); Serial.print(s); Serial.println("");
 
 
    // at least one channel is now zero
    // if all three channels are zero, we had a
    // shade of gray.
    if( (r + g + b) == 0) {
        // we pick hue zero for no special reason
        return CHSV( 0, 0, 255 - s);
    }
 
    // scale all channels up to compensate for desaturation
    if( s < 255) {
        if( s == 0) s = 1;
        fl::u32 scaleup = 65535 / (s);
        r = ((fl::u32)(r) * scaleup) / 256;
        g = ((fl::u32)(g) * scaleup) / 256;
        b = ((fl::u32)(b) * scaleup) / 256;
    }
    //Serial.print("r.2="); Serial.print(r); Serial.println("");
    //Serial.print("g.2="); Serial.print(g); Serial.println("");
    //Serial.print("b.2="); Serial.print(b); Serial.println("");
 
    fl::u16 total = r + g + b;
 
    //Serial.print("total="); Serial.print(total); Serial.println("");
 
    // Normalize the channels to the range expected by the hue approximation.
    // This scales low totals up as before, and also scales high totals down
    // instead of letting wide intermediates wrap when stored in u8 channels.
    if( total != 255) {
        if( total == 0) total = 1;
        fl::u32 scaleup = 65535 / (total);
        r = ((fl::u32)(r) * scaleup) / 256;
        g = ((fl::u32)(g) * scaleup) / 256;
        b = ((fl::u32)(b) * scaleup) / 256;
    }
    //Serial.print("r.3="); Serial.print(r); Serial.println("");
    //Serial.print("g.3="); Serial.print(g); Serial.println("");
    //Serial.print("b.3="); Serial.print(b); Serial.println("");
 
    if( total > 255 ) {
        v = 255;
    } else {
        v = qadd8(desat,total);
        // undo 'dimming' of brightness
        if( v != 255) v = fl::sqrt16( v * 256);
        // without lib8tion: float ... ew ... sqrt... double ew, or rather, ew ^ 0.5
        // if( v != 255) v = (256.0 * sqrt( (float)(v) / 256.0));
 
    }
 
    //Serial.print("v="); Serial.print(v); Serial.println("");
 
 
#if 0
 
    //#else
    if( v != 255) {
        // this part could probably use refinement/rethinking,
        // (but it doesn't overflow & wrap anymore)
        fl::u16 s16;
        s16 = (s * 256);
        s16 /= v;
        //Serial.print("s16="); Serial.print(s16); Serial.println("");
        if( s16 < 256) {
            s = s16;
        } else {
            s = 255; // clamp to prevent overflow
        }
    }
#endif
 
    //Serial.print("s.3="); Serial.print(s); Serial.println("");
 
 
    // since this wasn't a pure shade of gray,
    // the interesting question is what hue is it
 
 
 
    // start with which channel is highest
    // (ties don't matter)
    fl::u16 highest = r;
    if( g > highest) highest = g;
    if( b > highest) highest = b;
 
    if( highest == r ) {
        // Red is highest.
        // Hue could be Purple/Pink-Red,Red-Orange,Orange-Yellow
        if( g == 0 ) {
            // if green is zero, we're in Purple/Pink-Red
            h = (HUE_PURPLE + HUE_PINK) / 2;
            h += scale8( qsub8(r, 128), FIXFRAC8(48,128));
        } else if ( (r - g) > g) {
            // if R-G > G then we're in Red-Orange
            h = HUE_RED;
            h += scale8( g, FIXFRAC8(32,85));
        } else {
            // R-G < G, we're in Orange-Yellow.
            //
            // This used to read `(g - 85) + (171 - r)`. Reaching this branch
            // requires g >= r/2, and r is the largest channel, so r > 171 is
            // the normal case here -- making (171 - r) negative. The sum was
            // then truncated to u8 by qsub8() and wrapped to a large value,
            // sending orange out into the greens: rgb(255,153,0) returned hue
            // 122 instead of ~26. See issue #436.
            //
            // (255 - r) is the same measure of "how far r has fallen" but
            // cannot go negative, and the sum (g - 85) + (255 - r) has a
            // minimum of ~42 over this branch's own entry condition, so the
            // wrap is structurally impossible rather than merely unlikely.
            // Spans ~42..170, hence FIXFRAC8(32,170) to land the top of the
            // range on HUE_YELLOW.
            h = HUE_ORANGE;
            h += scale8( qsub8((g - 85) + (255 - r), 4), FIXFRAC8(32,170));
        }
 
    } else if ( highest == g) {
        // Green is highest
        // Hue could be Yellow-Green, Green-Aqua
        if( b == 0) {
            // if Blue is zero, we're in Yellow-Green
            //   G = 171..255
            //   R = 171..  0
            h = HUE_YELLOW;
            fl::u8 radj = scale8( qsub8(171,r),   47); //171..0 -> 0..171 -> 0..31
            fl::u8 gadj = scale8( qsub8(g,171),   96); //171..255 -> 0..84 -> 0..31;
            fl::u8 rgadj = radj + gadj;
            fl::u8 hueadv = rgadj / 2;
            h += hueadv;
            //h += scale8( qadd8( 4, qadd8((g - 128), (128 - r))),
            //             FIXFRAC8(32,255)); //
        } else {
            // if Blue is nonzero we're in Green-Aqua
            if( (g-b) > b) {
                h = HUE_GREEN;
                h += scale8( b, FIXFRAC8(32,85));
            } else {
                h = HUE_AQUA;
                h += scale8( qsub8(b, 85), FIXFRAC8(8,42));
            }
        }
 
    } else /* highest == b */ {
        // Blue is highest
        // Hue could be Aqua/Blue-Blue, Blue-Purple, Purple-Pink
        if( r == 0) {
            // if red is zero, we're in Aqua/Blue-Blue
            h = HUE_AQUA + ((HUE_BLUE - HUE_AQUA) / 4);
            h += scale8( qsub8(b, 128), FIXFRAC8(24,128));
        } else if ( (b-r) > r) {
            // B-R > R, we're in Blue-Purple
            h = HUE_BLUE;
            h += scale8( r, FIXFRAC8(32,85));
        } else {
            // B-R < R, we're in Purple-Pink
            h = HUE_PURPLE;
            h += scale8( qsub8(r, 85), FIXFRAC8(32,85));
        }
    }
 
    h += 1;
    return CHSV( h, s, v);
}

References FIXFRAC8, HUE_AQUA, HUE_BLUE, HUE_GREEN, HUE_ORANGE, HUE_PINK, HUE_PURPLE, HUE_RED, and HUE_YELLOW.