1,4,8,16,24,32位颜色之间的转换

最新推荐文章于 2022-12-01 10:51:07 发布
最新推荐文章于 2022-12-01 10:51:07 发布
阅读量2.1k 收藏 1
点赞数
分类专栏： VC技巧 文章标签： c

 //  灰度 .299R + .587G + .114B
#define  PIXEL_GREY(r,g,b) (u8)(((u16)r*77 + (u16)g*150 + (u16)b*29) >> 8)

//  获得 R5G6B5 红色分量
INLINE u8 R565( u16 clr )
 {
      return  (clr  &   0xF800 )  >>   8 ;
}

//  获得 R5G6B5 绿色分量
INLINE u8 G565( u16 clr )
 {
       return  (clr  &   0x07E0 )  >>   3 ;
}

//  获得 R5G6B5 蓝色分量
INLINE u8 B565( u16 clr )
 {
       return  (clr  &   0x001F )  <<   3 ;
}

//  获得 A1R5G5B5 红色分量
INLINE u8 R1555( u16 clr )
 {
       return  (clr  &   0x7C00 )  >>   7 ;
}

//  获得 A1R5G5B5 绿色分量
INLINE u8 G1555( u16 clr )
 {
       return  (clr  &   0x03E0 )  >>   2 ;
}

//  获得 A1R5G5B5 蓝色分量
INLINE u8 B1555( u16 clr )
 {
       return  (clr  &   0x001F )  <<   3 ;
}

//  获得 A1R5G5B5 Alpha值
INLINE u8 A1555( u16 clr )
 {
       return  clr  &   0x8000   ?   255  :  0 ;
}

//  获得 A4R4G4B4 红色分量
INLINE u8 R4444( u16 clr )
 {
       return  (clr  &   0x0F00 )  >>   8 ;
}

//  获得 A4R4G4B4 绿色分量
INLINE u8 G4444( u16 clr )
 {
       return  (clr  &   0x00F0 );
}

//  获得 A4R4G4B4 蓝色分量
INLINE u8 B4444( u16 clr )
 {
       return  (clr  &   0xF000 )  <<   4 ;
}

//  获得 A4R4G4B4 Alpha值
INLINE u8 A4444( u16 clr )
 {
       return  (clr  &   0xF000 )  >>   12 ;
}

//  由rgb组合成一个32位的RGB
INLINE u32 RGB32( u8 r, u8 g, u8 b )
 {
       return  u32(r)  <<   16   |  u32(g)  <<   8   |  u32(b)  |   0xFF000000 ;
}

//  由argb组合成一个32位的ARGB
INLINE u32 ARGB32( u8 a, u8 r, u8 g, u8 b )
 {
       return  u32(a)  <<   24   |  u32(r)  <<   16   |  u32(g)  <<   8   |  u32(b);
}

// ------------------------------------------------------------------------------------
 //   1位转换到4, 8, 16, 24, 32
 // ------------------------------------------------------------------------------------
INLINE u16 _1_to_565(  const  PALETTE  * pal, u16 index )
 {
       return  ( (pal[index].Blue >> 3 )  |  ((pal[index].Green >> 2 ) << 5 )  |  ((pal[index].Red >> 3 ) << 11 ) ); 
}

INLINE u16 _1_to_1555(  const  PALETTE  * pal, u16 index )
 {
       return  ( (pal[index].Blue >> 3 )  |  ((pal[index].Green >> 3 ) << 5 )  |  ((pal[index].Red >> 3 ) << 10 )  |   0x8000  ); 
}

INLINE u16 _1_to_4444(  const  PALETTE  * pal, u16 index )
 {
       return  ( (pal[index].Blue >> 4 )  |  ((pal[index].Green >> 4 ) << 4 )  |  ((pal[index].Red >> 4 ) << 8 )  |   0xF000  ); 
}

INLINE  void  _1_to_24(  const  PALETTE  * pal, u16 index, u8  & r, u8  & g, u8  & b )
 {
      b  =  pal[index].Blue;
      g  =  pal[index].Green;
      r  =  pal[index].Red;
}

INLINE u32 _1_to_32(  const  PALETTE  * pal, u16 index )
 {
       return  ( pal[index].Blue  |  (pal[index].Green  <<   8 )  |  (pal[index].Red  <<   16 ) );
}

// ------------------------------------------------------------------------------------
 //   4位转换到1, 8, 16, 24, 32
 // ------------------------------------------------------------------------------------
INLINE u16 _4_to_565(  const  PALETTE  * pal, u16 index )
 {
       return  ( (pal[index].Blue >> 3 )  |  ((pal[index].Green >> 2 ) << 5 )  |  ((pal[index].Red >> 3 ) << 11 ) ); 
}

INLINE u16 _4_to_1555(  const  PALETTE  * pal, u16 index )
 {
       return  ( (pal[index].Blue >> 3 )  |  ((pal[index].Green >> 3 ) << 5 )  |  ((pal[index].Red >> 3 ) << 10 )  |   0x8000  ); 
}

INLINE u16 _4_to_4444(  const  PALETTE  * pal, u16 index )
 {
       return  ( (pal[index].Blue >> 4 )  |  ((pal[index].Green >> 4 ) << 4 )  |  ((pal[index].Red >> 4 ) << 8 )  |   0xF000  ); 
}

INLINE  void  _4_to_24(  const  PALETTE  * pal, u16 index, u8  & r, u8  & g, u8  & b )
 {
      b  =  pal[index].Blue;
      g  =  pal[index].Green;
      r  =  pal[index].Red;
}

INLINE u32 _4_to_32(  const  PALETTE  * pal, u16 index )
 {
       return  ( pal[index].Blue  |  (pal[index].Green  <<   8 )  |  (pal[index].Red  <<   16 ) );
}

// ------------------------------------------------------------------------------------
 //   8位转换到16，24，32
 // ------------------------------------------------------------------------------------
INLINE u16 _8_to_565(  const  PALETTE  * pal, u16 index )
 {
       return  ( (pal[index].Blue >> 3 )  |  ((pal[index].Green >> 2 ) << 5 )  |  ((pal[index].Red >> 3 ) << 11 ) ); 
}

INLINE u16 _8_to_1555(  const  PALETTE  * pal, u16 index )
 {
       return  ( (pal[index].Blue) >> 3   |  ((pal[index].Green >> 3 ) << 5 )  |  ((pal[index].Red >> 3 ) << 10 )  |   0x8000  );
}

INLINE u16 _8_to_4444(  const  PALETTE  * pal, u16 index )
 {
       return  ( (pal[index].Blue >> 4 )  |  ((pal[index].Green >> 4 ) << 4 )  |  ((pal[index].Red >> 4 ) << 8 )  |   0xF000  );
}

INLINE  void  _8_to_24(  const  PALETTE  * pal, u16 index, u8  & r, u8  & g, u8  & b )
 {
      b  =  pal[index].Blue;
      g  =  pal[index].Green;
      r  =  pal[index].Red;
}

INLINE u32 _8_to_32(  const  PALETTE  * pal, u16 index )
 {
       return  ( pal[index].Blue  |  (pal[index].Green  <<   8 )  |  (pal[index].Red  <<   16 )  |   0xFF000000  );
}

// ------------------------------------------------------------------------------------
 //   16位转换到8，24，32
 // ------------------------------------------------------------------------------------
INLINE u8 _565_to_8( u16 clr )
 {
       return  PIXEL_GREY( (((clr  &   0xF800 )  >>   11 )  *   0xFF )  /   0x1F ,
           (((clr  &   0x7E0 )  >>   5 )  *   0xFF )  /   0x3F ,
           ((clr  &   0x1F )  *   0xFF )  /   0x1F  ); 
}

INLINE u16 _565_to_1555( u16 clr )
 {
       return  ( (clr  &   0xF800 )  >>   1   |  (clr  >>   1 )  &   0x03E0   |  (clr  &   0x001F )  |   0x8000  );
}

INLINE u16 _565_to_4444( u16 clr )
 {
       return  ( ((clr  &   0xF800 )  >>   4 )  |  ((clr  &   0x07E0 )  >>   3 )  |  ((clr  &   0x001F )  >>   1 )  |   0xF000  );
}

INLINE  void  _565_to_24( u16 clr, u8  & r, u8  & g, u8  & b )
 {
      r  =  (u8)((clr  &   0xF800 )  >>   11 );
      g  =  (u8)((clr  &   0x07E0 )  >>   5 );
      b  =  (u8)((clr  &   0x001F )  <<   3 );
}

INLINE u32 _565_to_32( u16 clr )
 {
       return ( ((clr  &   0x001F )  <<   3 )  |  ((clr  &   0x07E0 )  <<   5 )  |  ((clr  &   0xF800 )  <<   8 )  |   0xFF000000  );
}

INLINE u8 _1555_to_8( u16 clr )
 {
       return  PIXEL_GREY( (((clr  &   0x7C00 )  >>   10 )  *   0xFF )  /   0x1F ,
           (((clr  &   0x3E0 )  >>   5 )  *   0xFF )  /   0x1F ,
           ((clr  &   0x1F )  *   0xFF )  /   0x1F  );
}

INLINE u16 _1555_to_565( u16 clr )
 {
       return  (u16)( ((clr  &   0x7C00 ) << 1 )  |  ((clr  &   0x03E0 ) << 1 )  |  (clr  &   0x001F ) );
}

INLINE u16 _1555_to_4444( u16 clr )
 {
       return  ( ((clr  &   0x7C00 )  >>   3 )  |  ((clr  &   0x03E0 )  >>   2 )  |  ((clr  &   0x001F )  >>   1 )  |   0xF000  );
}

INLINE  void  _1555_to_24( u16 clr, u8  & r, u8  & g, u8  & b )
 {
      r  =  (u8)((clr  &   0x7C00 )  >>   10 );
      g  =  (u8)((clr  &   0x03E0 )  >>   5 );
      b  =  (u8)((clr  &   0x001F )  <<   3 );
}

INLINE u32 _1555_to_32( u16 clr )
 {
       return ( ((clr  &   0x001F )  <<   3 )  |  ((clr  &   0x03E0 )  <<   6 )  |  ((clr  &   0x7C00 )  <<   9 )  |   0xFF000000  );
}

INLINE u16 _4444_to_565( u16 clr )
 {
       return  ( ((clr  &   0x000F )  <<   1 )  |  ((clr  &   0x00F0 )  <<   3 )  |  ((clr  &   0x0F00 )  <<   4 ) );
}

INLINE u16 _4444_to_1555( u16 clr )
 {
       return  ( ((clr  &   0x000F )  <<   1 )  |  ((clr  &   0x00F0 )  <<   2 )  |  ((clr  &   0x0F00 )  <<   3 )  |   0x8000  );
}

INLINE  void  _4444_to_24( u16 clr, u8  & r, u8  & g, u8  & b )
 {
      r  =  (u8)((clr  &   0x0F00 )  >>   8 );
      g  =  (u8)((clr  &   0x00F0 )  >>   4 );
      b  =  (u8)((clr  &   0x000F )  <<   4 );
}

INLINE u32 _4444_to_32( u16 clr )
 {
       return  ( ((clr  &   0x000F )  <<   4 )  |  ((clr  &   0x00F0 )  <<   8 )  |  ((clr  &   0x0F00 )  <<   12 )  |  ((clr  &   0xF000 )  <<   16 ) );
}

// ------------------------------------------------------------------------------------
 //   24位转换到8，16，32
 // ------------------------------------------------------------------------------------
INLINE u8 _24_to_8( u8 r, u8 g, u8 b )
 {
       return  PIXEL_GREY( b, g, r );
}

INLINE u16 _24_to_565( u8 r, u8 g, u8 b )
 {
       return  ( ((u16)(r >> 3 ) << 11 )  |  ((u16)(g >> 2 ) << 5 )  |  ((u16)b >> 3 ) );
}

INLINE u16 _24_to_1555( u8 r, u8 g, u8 b )
 {
       return  (  0x8000   |  ((u16)(r >> 3 ) << 10 )  |  ((u16)(g >> 3 ) << 5 )  |  ((u16)b >> 3 ) ); 
}

INLINE u16 _24_to_4444( u8 r, u8 g, u8 b )
 {
       return  (  0xF000   |  ((u16)(r >> 4 ) << 8 )  |  ((u16)(g >> 4 ) << 4 )  |  ((u16)b >> 4 ) ); 
}

INLINE u32 _24_to_32( u8 r, u8 g, u8 b )
 {
       return  (  0xFF000000   |  ((u16)r  <<   16 )  |  ((u16)g  <<   8 )  |  (u16)b );
}

// ------------------------------------------------------------------------------------
 //   32位转换到8，16，24
 // ------------------------------------------------------------------------------------
INLINE u8 _32_to_8( u32 clr )
 {
       return  PIXEL_GREY( (clr  &   0xFF ), ((clr  &   0xFF00 )  >>   8 ), ((clr  &   0xFF0000 )  >>   16 ) );
}

INLINE u16 _32_to_565( u32 clr )
 {
       return  (u16)( ((clr  &   0xF8 )  >>   3 )  |  ((clr  &   0xFC00 )  >>   5 )  |  ((clr  &   0xF80000 )  >>   8 ) );
}

INLINE u16 _32_to_1555( u32 clr )
 {
       return  (u16)( ((clr  &   0xF8 )  >>   3 )  |  ((clr  &   0xF800 )  >>   6 )  |  ((clr  &   0xF80000 )  >>   9 )  |   0x8000  );
}

INLINE u16 _32_to_4444( u32 clr )
 {
       return  (u16)( ((clr  &   0xF0 )  >>   4 )  |  ((clr  &   0xF000 )  >>   8 )  |  ((clr  &   0xF00000 )  >>   12 )  |  ((clr  &   0xF0000000 )  >>   16 ) );
}

INLINE  void   _32_to_24( u32 clr, u8  & r, u8  & g, u8  & b )
 {
      b  =  (u8)(clr  &   0xFF );
      g  =  (u8)((clr  &   0xFF00 )  >>   8 );
      r  =  (u8)((clr  &   0xFF0000 )  >>   16 );
}

VChen
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
24位颜色值转换16位工具
12-16
总之，"24位颜色值转换16位工具"是一个实用的软件，它解决了在不同颜色深度之间转换颜色值的问题。对于需要优化显示性能或处理低功耗设备的开发者来说，它是一个不可或缺的辅助工具。通过合理使用这个工具，可以在...
BMP8位于24位的转换.zip
03-27
24位真彩色BMP文件则提供更丰富的颜色表现，每个像素由3个8位分量组成，分别代表红、绿、蓝（RGB）三个颜色通道，总计可以表示16777216种颜色（2的24次方），几乎涵盖了人眼可识别的所有颜色。 转换过程分为两部分...
C语言：8位、16位、32位数据转换
位文杰的博客
09-27 9241
如何把两个八位的16进制结合成一个16位的16进制,C语言printf输出十六进制16进制 C语言中的二进制数、八进制数和十六进制数 4位16进制和八位16进制转换 两个16位有符号整数转换为32位有符号整数的方法
前端需要了解的颜色模型，RGB、HSL和HSV
jh035512的博客
12-01 1917
颜色模型，是用来表示颜色的数学模型。比如最常见的RGB模型，使用红绿蓝三色来表示颜色。一般的颜色模型，可以按照如下分类：面向硬件设备的颜色模型：RGB，CMYK，YCrCb。面向视觉感知的颜色模型：HSL，HSV(B)，HSI，Lab。不同的颜色模型有不同的应用场景，而RGB模型适合于显示器这样的的设备。其中，RGBHSL，即在前端页面中只有这两种模型的颜色值可以有效展示出来。而对于HSV，则是我们在创建颜色选择器插件时所需要了解的一种模型。目前，chrome浏览器，实现H5。
Halcon与OpenCV 16位/32位图像相互转换C++
Color Space的博客
01-09 1721
Halcon与OpenCV图像类型转换基于C++ (附代码) 8位图像的转换参考上面链接，这里再给出16位的转换代码，32位大家可以自己修改一下，uint2改为real还有一些其他地方需要修改，大家可以自己试试 16bit--OpenCV Mat转Halcon HObject //16bit--OpenCV Mat转Halcon HObject HObject MatToHImage16Bit(Mat &imgMat) { HObject Hobj = HObject();
16位增强色RGB转换为24/32位真色彩
Enbiting的专栏
05-07 8085
biBitCount=16 表示位图最多有65536种颜色。每个色素用16位（2个字节）表示。这种格式叫作高彩色，或叫增强型16位色，或64K色。它的情况比较复杂，当biCompression成员的值是BI_RGB时，它没有调色板。16位中，最低的5位表示蓝色分量，中间的5位表示绿色分量，高的5位表示红色分量，一共占用了15位，最高的一位保留，设为0。这种格式也被称作555 16位位图。如果b
32位颜色 转换成16位颜色
weixin_30279751的博客
07-30 2914
向别人学习而来：分享。。 1.颜色值有32位存储和16位存储实现呼唤。 2.原理new Color(97,100,255);这个是32位存储 参数依次是 r、g、b。省略了a，alpha通道的值 rgba; 实现： int32 int32Color(unsigned int r,unsigned int g, unsigned int b) { 　　return (((r)&0...
利用python将16位图像转换为8位图像，支持批量
04-01
在图像处理领域，有时我们需要将高动态范围的图像（如16位图像）转换为低动态范围的图像（如8位图像）。这个过程通常是为了适应显示设备或进行特定的算法处理。本文将深入探讨如何使用Python来实现16位图像到8位图像...
颜色格式转换（24bit-16bit）.zip
10-05
首先，24位RGB（888）颜色格式，也称为真彩色，提供了8位（256个级别）来表示红色、绿色和蓝色三种原色。这意味着它总共可以表示256x256x256=16,777,216种不同的颜色，几乎涵盖了人类视觉可以识别的全部色彩范围。 ...
8bit 位bmp 转换 24bit
03-27
24bit BMP 文件则使用3个8位通道（红、绿、蓝）来表示每个像素，总共24位，能表达的颜色数量高达16,777,216（即256 * 256 * 256）。24bit BMP 提供了丰富的色彩层次，适用于现代彩色图像显示。 "8bit 位bmp 转换 24...
32位色下运行需16位色程序
03-31
32位色下运行需16位色程序 小程序,有的软件需要16位色.但又不想改的话.就用这个软件吧,相当实用10K都不到
16色、16位色、24位色位图文件那些事
zurong的专栏
11-18 9202
最近，因为项目需要使用16色图片，顺带了解了一下位图格式和相关知识，现在在此做个笔记记录一下。 一、BMP文件格式 1、BMP文件格式 BMP文件由文件头、位图信息头、颜色信息和图形数据四部分组成。 2、BMP文件头（14字节） BMP文件头数据结构含有BMP文件的类型、文件大小和位图起始位置等信息。 其结构定义如下： typedefstructtagBITMAPFILEHEADER { WORDbfType;//位图文件的类型，必须为BM(1-2字节） ...
基于Labview的图像傅里叶变换研究-含Labview程序
m0_70745318的博客
11-20 2846
法国数学家傅里叶（Fourier） 于 1807 年受到热传导理论的启示， 首先提出傅里叶（Fourier）分析，傅里叶（Fourier）分析是小波分析的基础。傅里叶级数又叫三角级数，简单地说就是把一个函数 Y 拆成若干三角函数的和。 这个公式的含义就是正弦函数和余弦函数以某种方式叠加可以等于一个周期函数。也就是说信号函数可以用正弦函数和余弦函数组合替代。用画图来表示就是一条看似很不规则的多弯曲的周期曲线，也可以用许许多多的规整的光滑曲线组合而成， 这就是傅里叶变换的思路。 如图3。
32位色和16位色
在线笔记
10-08 4997
计算机表示颜色也是用二进制。 16位色的发色总数是65536色，也就是2的16次方； 24位色被称为真彩色，它可以达到人眼分辨的极限，发色数是1677万多色，也就是2的24次方。 32位色就并非是2的32次方的发色数，它其实也是1677万多色，不过它增加了256阶颜色的灰度也就是8位透明度，发色数其实2的24次方，但是增加了8位透明度，就规定它为32位色。
系统学习 Java IO (十二)----数据流和对象流
weixin_30338461的博客
11-24 103
目录：系统学习 Java IO---- 目录，概览 DataInputStream/DataOutputStream 允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。 要想使用数据输出流和输入流，必须按指定的格式保存数据，才可以将数据输入流将数据读取进来，所以通常使用 DataInputStream 来读取 DataOutputStream 写入的数据。 Data...
灰度图raw8转raw16或raw16转raw8方法
May-gemini的博客
07-15 1919
raw8转raw16或raw16转raw8方法，废话不多说，直接上代码。
（1） 实现RGB颜色空间和HSI颜色空间之间的转换
最新发布
03-25
A：（1）RGB颜色空间和HSI颜色空间之间的转换可以通过以下步骤实现： 1. 将 RGB 的 R、G、B 值分别归一化到 [0, 1] 区间内。 2. 计算出 H（色相）、S（饱和度）和 I（强度/亮度）三个分量。 1）色相 H 的计算公式为： H = cos⁻¹{[0.5*((R−G)+(R−B))]/√[(R−G)²+(R−B)(G−B)]} 如果 B > G，则 H = 360 - H。 2）饱和度 S 的计算公式为： S = 1 - 3×min(R, G, B)/(R+G+B) 3）强度/亮度 I 的计算公式为： I = (R+G+B)/3 3. 将 HSI 转换成 RGB 颜色空间的值，可以通过以下方式实现： 1）如果 H < 120 度，则 RGB 分量的计算公式为： B = I × (1 - S) R = I × [1 + S × cos(H)/cos(60 - H)] G = 3 × I - (R + B) 2）如果 120 度 <= H < 240 度，则 RGB 分量的计算公式为： R = I × (1 - S) G = I × [1 + S × cos(H - 120)/cos(180 - H)] B = 3 × I - (R + G) 3）如果 240 度 <= H < 360 度，则 RGB 分量的计算公式为： G = I × (1 - S) B = I × [1 + S × cos(H - 240)/cos(300 - H)] R = 3 × I - (G + B) 注意：在计算 RGB 分量的值之后，需要将其值乘以 255 并四舍五入到最近的整数，得到最终的 RGB 颜色值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值