HSV转RGB去浮点优化--为MCU简化

HSV做为基本的调色空间，有较多的使用场景，目前越来越多的IOT产品也需要用的HSV到RGB的颜色空间转换，其中不乏低成本的单片机。
低成本的单片机没有FPU，所以只能靠编译器将浮点运算转为模拟浮点。当然模拟浮点运算就需要cpu来算了，同时需要更大的代码空间。恰巧mcu一般主频低，RAM、ROM小。
所以原有的代码需要简化才能适用于这类平台。

HSV.png

为了脱敏，这里使用网上能找到python代码，来说明化简方法。

1.原本的代码：

来自互联网

import math
def hsv2rgb(h, s, v):
    h = float(h)
    s = float(s)
    v = float(v)
    h60 = h / 60.0
    h60f = math.floor(h60)
    hi = int(h60f) % 6
    f = h60 - h60f
    p = v * (1 - s)
    q = v * (1 - f * s)
    t = v * (1 - (1 - f) * s)
    r, g, b = 0, 0, 0
    if hi == 0: r, g, b = v, t, p
    elif hi == 1: r, g, b = q, v, p
    elif hi == 2: r, g, b = p, v, t
    elif hi == 3: r, g, b = p, q, v
    elif hi == 4: r, g, b = t, p, v
    elif hi == 5: r, g, b = v, p, q
    r, g, b = int(r * 255), int(g * 255), int(b * 255)
    return r, g, b

2.简化分析

2.1去浮点

    h = float(h)
    s = float(s)
    v = float(v)

原来需要转置为浮点型，但是低端MCU不带浮点运算，S，V可以扩大100or1000倍输入，改为整形计算

scal=1000

2.2取余

没了浮点运算，取小数部分也改改。求模再除（这个除60放到后面算式里）。
原：

    h60 = h / 60.0
    h60f = math.floor(h60)
    hi = int(h60f) % 6
    f = h60 - h60f

改：

hi = int(h/60) % 6 
f = (h%60)#/60

2.3运算简化

需要保持扩大比例，但又不能增加太多计算量，人工化简一下，找找规律

    p = v * (1 - s)
    q = v * (1 - f * s)
    t = v * (1 - (1 - f) * s)

改：

    vs = v * s / scal
    vfs = v * f * s/60 /scal
    p = v  - vs 
    q = v - vfs
    t = p + vfs

3.简化结果

def hsv2rgb(h, s, v):
    scal=1000
    hi = int(h/60) % 6
    f = (h%60)#/60

    vs = v * s / scal
    vfs = v * f * s/60 /scal
    print(v,vs,vfs)

    p = v  - vs 
    q = v - vfs
    t = p + vfs  

    r, g, b = 0, 0, 0

    if hi == 0: r, g, b = v, t, p
    elif hi == 1: r, g, b = q, v, p
    elif hi == 2: r, g, b = p, v, t
    elif hi == 3: r, g, b = p, q, v
    elif hi == 4: r, g, b = t, p, v
    elif hi == 5: r, g, b = v, p, q

    r, g, b = r * 255/scal, g * 255/scal, b * 255/scal
    return r, g, b

4 注意

• 资源更受限的MCU可以调低放大系数scal，如100，当然会有部分精度损失
• 在转为C代码时，注意计算中间值，别溢出了，可能有些编译器比较抠门

5. 附：RGB转HSV

这个比较简单，就不解释了，直接贴结果

def rgb2hsv(r, g, b):
    scal = 100
    mx = max(r, g, b)
    mn = min(r, g, b)
    df = mx-mn
    if mx == mn:
        h = 0
    elif mx == r:
        h = (60 * (g-b)/df ) % 360
    elif mx == g:
        h = (60 * (b-r)/df+ 120) % 360
    elif mx == b:
        h = (60 * (r-g)/df+ 240) % 360

    if mx == 0:
        s = 0
    else:
        s = df*scal/mx

    v = mx*scal/255
    return h, s, v