HSV16toRGB()

static CRGB fl::HSV16toRGB ( const HSV16 & hsv )

static

Definition at line 121 of file hsv16.cpp.

                                         {
    // Convert 16-bit values to working range
    u32 h = hsv.h;
    u32 s = hsv.s; 
    u32 v = hsv.v;
 
    if (s == 0) {
        // Grayscale case - use precise mapping
        u8 gray = map16_to_8(v);
        return CRGB{gray, gray, gray};
    }
 
    // Determine which sector of the color wheel (0-5)
    u32 sector = (h * 6) / 65536;
    u32 sector_pos = (h * 6) % 65536; // Position within sector (0-65535)
 
    // Calculate intermediate values using precise mapping
    // c = v * s / 65536, with proper rounding
    u32 c = map32_to_16(v * s);
    
    // Calculate x = c * (1 - |2*(sector_pos/65536) - 1|)
    u32 x;
    if (sector & 1) {
        // For odd sectors (1, 3, 5), we want decreasing values
        // x = c * (65535 - sector_pos) / 65535
        x = map32_to_16(c * (65535 - sector_pos));
    } else {
        // For even sectors (0, 2, 4), we want increasing values  
        // x = c * sector_pos / 65535
        x = map32_to_16(c * sector_pos);
    }
    
    u32 m = v - c;
 
    u32 r1, g1, b1;
    switch (sector) {
        case 0: r1 = c; g1 = x; b1 = 0; break;
        case 1: r1 = x; g1 = c; b1 = 0; break;
        case 2: r1 = 0; g1 = c; b1 = x; break;
        case 3: r1 = 0; g1 = x; b1 = c; break;
        case 4: r1 = x; g1 = 0; b1 = c; break;
        default: r1 = c; g1 = 0; b1 = x; break;
    }
 
    // Add baseline and scale to 8-bit using accurate mapping
    u8 R = map16_to_8(u16(r1 + m));
    u8 G = map16_to_8(u16(g1 + m));
    u8 B = map16_to_8(u16(b1 + m));
 
    return CRGB{R, G, B};
}

References fl::HSV16::h, map16_to_8(), map32_to_16(), fl::HSV16::s, fl::HSV16::v, and x.

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

Here is the call graph for this function:

Here is the caller graph for this function: