RGBtoHSV16()

static HSV16 fl::RGBtoHSV16 ( const CRGB & rgb )

static

Definition at line 20 of file hsv16.cpp.hpp.

                                                      {
    // Work with 8-bit values directly
    u8 r = rgb.r;
    u8 g = rgb.g;
    u8 b = rgb.b;
 
    // Find min and max
    u8 mx = max(r, max(g, b));
    u8 mn = min(r, min(g, b));
    u8 delta = mx - mn;
 
    u16 h = 0;
    u16 s = 0;
    u16 v = scale8_to_16_accurate(mx);
 
    // Calculate saturation using improved scaling
    if (mx > 0) {
        // s = (delta * 65535) / mx, but with better accuracy
        // Use the same technique as scale8_to_16_accurate but for arbitrary denominator
        if (delta == mx) {
            s = 65535;  // Saturation is 100%
        } else {
            s = (u16)(((u32)delta * 65535 + (mx >> 1)) / mx);
        }
    }
 
    // Calculate hue using improved algorithms
    if (delta > 0) {
        u32 hue_calc = 0;
        
        if (mx == r) {
            // Hue in red sector (0-60 degrees)
            if (g >= b) {
                // Use improved division: hue_calc = (g - b) * 65535 / (6 * delta)
                u32 numerator = (u32)(g - b) * 65535;
                if (delta <= 42) {  // 6 * 42 = 252, safe for small delta
                    hue_calc = numerator / (6 * delta);
                } else {
                    hue_calc = numerator / delta / 6;  // Avoid overflow
                }
            } else {
                u32 numerator = (u32)(b - g) * 65535;
                if (delta <= 42) {
                    hue_calc = 65535 - numerator / (6 * delta);
                } else {
                    hue_calc = 65535 - numerator / delta / 6;
                }
            }
        } else if (mx == g) {
            // Hue in green sector (60-180 degrees)
            // Handle signed arithmetic properly to avoid integer underflow
            i32 signed_diff = (i32)b - (i32)r;
            u32 sector_offset = 65535 / 3;  // 60 degrees (120 degrees in 16-bit space)
            
            if (signed_diff >= 0) {
                // Positive case: b >= r
                u32 numerator = (u32)signed_diff * 65535;
                if (delta <= 42) {
                    hue_calc = sector_offset + numerator / (6 * delta);
                } else {
                    hue_calc = sector_offset + numerator / delta / 6;
                }
            } else {
                // Negative case: b < r  
                u32 numerator = (u32)(-signed_diff) * 65535;
                if (delta <= 42) {
                    hue_calc = sector_offset - numerator / (6 * delta);
                } else {
                    hue_calc = sector_offset - numerator / delta / 6;
                }
            }
        } else { // mx == b
            // Hue in blue sector (180-300 degrees)
            // Handle signed arithmetic properly to avoid integer underflow
            i32 signed_diff = (i32)r - (i32)g;
            u32 sector_offset = (2 * 65535) / 3;  // 240 degrees (240 degrees in 16-bit space)
            
            if (signed_diff >= 0) {
                // Positive case: r >= g
                u32 numerator = (u32)signed_diff * 65535;
                if (delta <= 42) {
                    hue_calc = sector_offset + numerator / (6 * delta);
                } else {
                    hue_calc = sector_offset + numerator / delta / 6;
                }
            } else {
                // Negative case: r < g
                u32 numerator = (u32)(-signed_diff) * 65535;
                if (delta <= 42) {
                    hue_calc = sector_offset - numerator / (6 * delta);
                } else {
                    hue_calc = sector_offset - numerator / delta / 6;
                }
            }
        }
        
        h = (u16)(hue_calc & 0xFFFF);
    }
 
    return HSV16{h, s, v};
}

References FL_NO_EXCEPT, g, max(), min(), and scale8_to_16_accurate().

Referenced by fl::HSV16::HSV16().

Here is the call graph for this function:

Here is the caller graph for this function: