Matrix to convert between HSL and RGB

最新推荐文章于 2021-10-15 09:45:10 发布
最新推荐文章于 2021-10-15 09:45:10 发布
阅读量945 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Color Space 文章标签： matrix float algorithm 360
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hello_wyq/article/details/3867857
本文详细介绍了RGB颜色空间与HSL颜色空间之间的相互转换算法。包括如何从RGB转换到HSL，以及逆向操作。该算法适用于需要进行颜色转换的应用场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 

Algorithm RGB -> HSL
0 <= R, G, B <= 1
0 <= H       <= 360
0 <= S, L    <= 1

max = MAX( R, G, B )
min = MIN( R, G, B )

1) max = min
h = 0
2) max = R
h = (60 * (G - B) / (max - min) + 360 ) mod 360
3) max = G
h = 60 * (B - R) / (max - min) + 120
4) max = B
h = 60 * (R - G) / (max - min) + 240

L = (max + min) / 2

1) max = min
s = 0;
2) L <= 0.5
s = (max - min) / (max + min) = (max - min) / (2 * L)
3) L > 0.5
s = (max - min) / (2 - (max + min)) = (max - min) / (2 - 2 * L)

Algorithm HSL -> RGB
0 <= R, G, B <= 1
0 <= H       < 360
0 <= S, L    <= 1

1) L < 0.5
Q = L * (L + S)
2) L >= 0.5
Q = L + S - (L * S)

P = 2 * L - Q

Hk = H / 360

Tr = Hk + 1.0 / 3.0
Tg = Hk
Tb = Hk - 1.0 / 3.0

1) Tr < 0
Tr = Tr + 1.0
2) Tr > 1.0
Tr = Tr - 1.0

3) Tg < 0
Tg = Tg + 1.0
4) Tg > 1.0
Tg = Tg - 1.0

5) Tb < 0
Tb = Tb + 1.0
6) Tb > 1.0
Tb = Tb - 1.0

1) Tr < 1.0 / 6.0
Tr = P + ((Q - P) * 6 * Tr)
2) 1.0 / 6.0 <= Tr < 0.5
Tr = Q
3) 0.5 <= Tr < 2.0 / 3.0
Tr = P + ((Q- P) * 6 * (2.0 / 3.0 - Tr))
4) otherwise
Tr = P

5) Tg < 1.0 / 6.0
Tg = P + ((Q - P) * 6 * Tg)
6) 1.0 / 6.0 <= Tg < 0.5
Tg = Q
7) 0.5 <= Tg < 2.0 / 3.0
Tg = P + ((Q- P) * 6 * (2.0 / 3.0 - Tg))
8) otherwise
Tg = P

9) Tb < 1.0 / 6.0
Tb = P + ((Q - P) * 6 * Tb)
10) 1.0 / 6.0 <= Tb < 0.5
Tb = Q
11) 0.5 <= Tb < 2.0 / 3.0
Tb = P + ((Q- P) * 6 * (2.0 / 3.0 - Tb))
12) otherwise
Tb = P

 

// r, g, b are [0, 1]
// h is [0, 360)
// s is [0, 1]
// l is [0, 1]
#define RGB2HSL( r, g, b, h, s, l )                                                                /
    I_MACRO_BEGIN                                                                                /
    if ( (r) == (g) && (g) == (b) )                                                                /
    {                                                                                            /
        (h) = 0;                                                                                /
        (s) = 0;                                                                                /
        (l) = (g);                                                                                /
    }                                                                                            /
    else                                                                                        /
    {                                                                                            /
        float _max;                                                                                /
        float _min;                                                                                /
        if ( (r) > (g) )                                                                        /
        {                                                                                        /
            _min = (g) > (b) ? (b) : (g);                                                        /
            if ( (r) > (b) ) /* r is max */                                                        /
            {                                                                                    /
                _max = (r);                                                                        /
                (h)  = ((int) (60.0 * ((g) - (b)) / ((r) - _min) + 0.5) + 360) % 360;            /
            }                                                                                    /
            else /* b is max */                                                                    /
            {                                                                                    /
                _max = (b);                                                                        /
                (h)  = (int) (60.0 * ((r) - (g)) / ((b) - _min) + 0.5) + 240;                    /
            }                                                                                    /
        }                                                                                        /
        else /* (r) <= (g) */                                                                    /
        {                                                                                        /
            _min = (r) > (b) ? (b) : (r);                                                        /
            if ( (g) > (b) ) /* g is max */                                                        /
            {                                                                                    /
                _max = (g);                                                                        /
                (h)  = (int) (60.0 * ((b) - (r)) / ((g) - _min) + 0.5) + 120;                    /
            }                                                                                    /
            else /* b is max */                                                                    /
            {                                                                                    /
                _max = (b);                                                                        /
                (h)  = (int) (60.0 * ((r) - (g)) / ((b) - _min) + 0.5) + 240;                    /
            }                                                                                    /
        }                                                                                        /
        (l) = 0.5 * (_max + _min);                                                                /
        if ( (l) > 0.5 )                                                                        /
        {                                                                                        /
            (s) = (float) (_max - _min) / (2.0 - (_max + _min));                                /
        }                                                                                        /
        else                                                                                    /
        {                                                                                        /
            (s) = (float) (_max - _min) / (float) (_max + _min);                                /
        }                                                                                        /
    }                                                                                            /
    I_MACRO_END

#define II_HSL2RGB( p, q, tc )                                                                    /
    I_MACRO_BEGIN                                                                                /
    if ( (tc) < 1.0 / 6.0 )                                                                        /
    {                                                                                            /
        (tc) = (p) + ((q) - (p)) * 6.0 * (tc);                                                    /
    }                                                                                            /
    else if ( (tc) < 1.0 / 2.0 )                                                                /
    {                                                                                            /
        (tc) = (q);                                                                                /
    }                                                                                            /
    else if ( (tc) < 2.0 / 3.0 )                                                                /
    {                                                                                            /
        (tc) = (p) + ((q) - (p)) * 6.0 * (2.0 / 3.0 - (tc));                                    /
    }                                                                                            /
    else                                                                                        /
    {                                                                                            /
        (tc) = (p);                                                                                /
    }                                                                                            /
    I_MACRO_END


// h is [0, 360)
// s is [0, 1]
// l is [0, 1]
// r, g, b are [0, 1]
#define HSL2RGB( h, s, l, r, g, b )                                                                /
    I_MACRO_BEGIN                                                                                /
    float _p;                                                                                    /
    float _q;                                                                                    /
    float _hk;                                                                                    /
    float _tr;                                                                                    /
    float _tg;                                                                                    /
    float _tb;                                                                                    /
    assert( (h) < 360 );                                                                        /
    if ( (l) < 0.5 )                                                                            /
    {                                                                                            /
        _q = (l) * (1 + (s));                                                                    /
    }                                                                                            /
    else                                                                                        /
    {                                                                                            /
        _q = (l) + (s) - (l) * (s);                                                                /
    }                                                                                            /
    _p  = 2.0 * (l) - _q;                                                                        /
    _hk = (float) (h) / 360.0;                                                                    /
    _tr = _hk + 1.0 / 3.0;                                                                        /
    if ( _tr < 0 )                                                                                /
        _tr += 1.0;                                                                                /
    else if ( _tr > 1.0 )                                                                        /
        _tr -= 1.0;                                                                                /
    _tg = _hk;                                                                                    /
    if ( _tg < 0 )                                                                                /
        _tg += 1.0;                                                                                /
    else if ( _tg > 1.0 )                                                                        /
        _tg -= 1.0;                                                                                /
    _tb = _hk - 1.0 / 3.0;                                                                        /
    if ( _tb < 0 )                                                                                /
        _tb += 1.0;                                                                                /
    else if ( _tb > 1.0 )                                                                        /
        _tb -= 1.0;                                                                                /
    II_HSL2RGB( _p, _q, _tr );                                                                    /
    II_HSL2RGB( _p, _q, _tg );                                                                    /
    II_HSL2RGB( _p, _q, _tb );                                                                    /
    (r) = _tr;                                                                                    /
    (g) = _tg;                                                                                    /
    (b) = _tb;                                                                                    /
    I_MACRO_END

 

冈萨雷斯数字图像处理——彩色图像增强3实例
火雨(Nick)
12-26 6735
基于直方图均衡化的彩色图像增强, 双边滤波(Bilateral Filtering) , 图像的模糊增强.
2020-11-25
yirenzhimeng_xr的博客
01-13 773
public
色彩转换——RGB & HSL
weixin_30364147的博客
04-15 221
RGB to HSL TheR,G,Bvalues are divided by 255 to change the range from 0..255 to 0..1: R' =R/255 G' =G/255 B' =B/255 Cmax= max(R',G',B') Cmin= min(R',G',B') Δ =Cmax-Cm...
CartO
weixin_30621711的博客
12-10 359
Carto documentation The following is a list of properties provided in CartoCSS that you can apply to map elements. All elements image-filters functions agg-stack-blurembossblurgraysobeledge-detectx-gr...
D3.js中文API
风火一回，一生不毁
12-03 7169
选择集 d3.select - 从当前文档中选择一系列元素。 d3.selectAll - 从当前文档中选择多项元素。 selection.attr - 设置或获取指定属性。 selection.classed - 添加或删除选定元素的 CSS 类（CSS class）。 selection.style - 设置或删除 CSS 属性。style优先级高于att
QT图像处理 -- http://developer.nokia.com/Community/Wiki/Image_editing_techniques_and_algorithms_using_Qt
每天都要进步！
09-05 2075
English Log inJoin Design Develop Distribute Devices Resources Community Share Wiki
Colour Space Conversions
wmzjzwlzs的专栏
10-15 733
------------------------------------------------------------------------ Colour Space Conversions. ------------------------------------------------------------------------ Complied by Alan Roberts (Alan.Roberts@rd.bbc.co.uk) and Adrian Ford (ajo.
YUV
天下对手教会少林武僧
09-09 747
YUV is a color encoding system typically used as part of a color image pipeline. It encodes a color image or video taking human perception into account, allowing reduced bandwidth for chrominance comp...
Vehicle Color Recognition using Convolutional Neural Network
程永强
12-05 2593
Vehicle Color Recognition using Convolutional Neural Network Reza Fuad Rachmadi, I Ketut Eddy Purnama Department of Multimedia and Networking Engineering, Institut Teknologi Sepuluh Nopember, Surabaya...
glsl-hsl2rgb:GLSL 中 HSL 到 RGB 颜色的转换
06-11
glsl-hsl2rgb GLSL 中的 HSL 到 RGB 颜色转换。 #pragma glslify : hsl2rgb = require(glsl - hsl2rgb) ... // 75deg hue, 50% sat, 25% lightness vec3 rgb = hsl2rgb( 75.0 / 360.0 , 0.5 , 0.25 ); gl_...
HSL.rar_HSL RGB_RGB转hsl_hsl_rgb h_rgb hsl
09-24
def rgb_to_hsl(r, g, b): r, g, b = r / 255, g / 255, b / 255 max_val, min_val = max(r, g, b), min(r, g, b) L = (max_val + min_val) / 2 if max_val == min_val: H, S = 0, 0 else: delta = max_val ...
1.rar_Cieluv_HSV RGB MATLAB_hsl_rgb to cie xyz_yuv jpeg
07-15
这个Matlab程序用于颜色空间的转换。可以在RGB, YPbPr, YCbCr, YUV, YIQ, YDbDr, JPEG-YCbCr, HSV, HSL, XYZ, CIE Lab (CIELAB), CIE Luv (CIELUV), and CIE Lch (CIELCH)等颜色空间中任意转换。.rar
HSL.rar_hsl_rgb hsl
09-14
在计算机图形学和色彩处理领域，RGB和HSL（色相、饱和度、亮度）是两种常见的颜色模型。RGB模型基于光的三原色理论，而HSL模型更符合人类对颜色的认知方式。本篇文章将深入探讨这两种颜色模型以及它们之间的转换。 ...
hsl_rgb.zip
01-07
在色彩处理和图形设计领域，HSL（色相、饱和度、亮度）和RGB（红色、绿色、蓝色）是两种常见的颜色模型。本文件“hsl_rgb.zip”显然是与这两种颜色模型相关的资源，可能包含代码示例、图像或教程，用于帮助理解如何...
ITU709 Matrix to convert between YCbCr and RGB
燕青专栏
02-07 1945
[ITU 709: YCbCr RGB]0    -0.5 Y  =  0.2215 * R + 0.7154 * G + 0.0721 * BCb = -0.1145 * R - 0.3855 * G + 0.5000 * BCr =  0.5016 * R - 0.4556 * G - 0.0459 * BR  = Y + 0.0000 * Cb + 1.5701 * CrG  = Y -
ITU601 Matrix to convert between YCbCr and RGB
燕青专栏
02-07 1305
 [ITU 601: YCbCr RGB]0    -0.5 Y  =  0.299 * R + 0.587 * G + 0.114 * BCb = -0.169 * R - 0.331 * G + 0.500 * BCr =  0.500 * R - 0.419 * G - 0.081 * BR  = Y + 0.000 * Cb + 1.403 * CrG  = Y - 0.344 *
The fusion matrixes for Color space
燕青专栏
02-07 803
[ITU 601: YCbCr RGB]0    -0.5 Y  =  0.299 * R + 0.587 * G + 0.114 * BCb = -0.169 * R - 0.331 * G + 0.500 * BCr =  0.500 * R - 0.419 * G - 0.081 * BR  = Y + 0.000 * Cb + 1.403 * CrG  = Y - 0.344 * Cb
Matrix to convert between HSV and RGB
燕青专栏
02-07 767
Algorithm RGB -> HSV0 0 0 max = MAX( R, G, B )min = MIN( R, G, B )1) max = minh = 02) max = Rh = (60 * (G - B) / (max - min) + 360 ) mod 3603) max = Gh = 60 * (B - R) / (max - min) + 1204) max = Bh =
C#实现HSL与RGB相互转换的ColorConvertDemo
HSL与RGB是两种在计算机图形学和色彩理论中常用的色彩模式。HSL代表色相(Hue)、饱和度(Saturation)、亮度(Lightness)，而RGB代表红(Red)、绿(Green)、蓝(Blue)。这两种模型对于色彩的表示有各自的特点和用途，而它们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值