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

最新推荐文章于 2022-02-23 15:02:25 发布
最新推荐文章于 2022-02-23 15:02:25 发布
阅读量1.4k 收藏 1
点赞数 1
文章标签： c

http://blog.csdn.net/check_into/archive/2007/08/17/1748630.aspx

 

1,4,8,16,24,32位颜色之间的转换
 //  灰度 .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 );
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/check_into/archive/2007/08/17/1748630.aspx

dinosaur_star
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java处理图片转为的Base64编码中固定颜色为黑色
when_known的博客
03-29 3049
/** * base64字符串转化成图片 ,图片进行噪点和像素处理 * @param imageBase64 图片编码 * @param color 需要处理的颜色 * @return * @throws IOException */ public static boolean GenerateImage(String ima...
24位颜色值转换16位工具
12-16
总之，"24位颜色值转换16位工具"是一个实用的软件，它解决了在不同颜色深度之间转换颜色值的问题。对于需要优化显示性能或处理低功耗设备的开发者来说，它是一个不可或缺的辅助工具。通过合理使用这个工具，可以在...
RGB及ARGB中16进制的表示与转换方法
学习笔记
01-29 2943
原文地址:RGB及ARGB中16进制的表示与转换方法   Flash 中的颜色 在 Flash 中，颜色就是一串特殊的数字，一个颜色值可以是0到16,777,215中的任意数值，这就是24位(bit)色彩。也许大家会问，为什么有 16,777,216(256*256*256)种颜色值，因为 Flash 使用 RGB 颜色值，意味着每个颜色都可以由红(red)，绿(green)，蓝(blue)
bmp 转 4字节 RGB888 2字节 RGB565 （注意大小头） 代码
RICH的专栏
09-03 3057
1. main.c #include typedef unsigned char    BYTE; typedef unsigned short    WORD; typedef unsigned int    DWORD; typedef unsigned
【方法】Ilitek ILI9325、ILI9341 LCD TFT彩屏利用Memory Read指令读取屏幕上显示的内容
ZLK1214的专栏
07-06 4666
网上很多彩屏例程都通过0号命令读取彩屏的ID号，以此来判断彩屏的芯片型号，然而ILI9341芯片的0号命令是一个空操作（No Operation），无法得到器件ID。 4号命令和0xda~0xdc命令虽然是读取ID的命令，但是读出来的ID全都是0。这会不会是STM32 FSMC的时序配置问题？或者STM32的FSMC根本就不支持这款液晶的读操作？到底是STM32的时序问题，还是芯片的器件ID本来就为0？ 通过Memory Read（0x2e）命令可以发现，即使把FSMC的时序值配置为最小值，STM32也
实现1位,4位,8位,24位BMP位图的互相转换的方法,32位转24位
热门推荐
lys07962000的专栏
05-09 3万+
from: http://blog.sina.com.cn/s/blog_61e61df60100igzb.html BOOL SaveTrueBmp(HBITMAP hBitmap, CString FileName) { //设备描述表 HDC hDC; //真彩色位图中每象素所占字节数为24 WORD wBitCount=24; //定义调色板大小， 位图中像素字节大小 ，位
利用python将16位图像转换为8位图像，支持批量
04-01
在图像处理领域，有时我们需要将高动态范围的图像（如16位图像）转换为低动态范围的图像（如8位图像）。这个过程通常是为了适应显示设备或进行特定的算法处理。本文将深入探讨如何使用Python来实现16位图像到8位图像...
BMP8位于24位的转换.zip
03-27
24位真彩色BMP文件则提供更丰富的颜色表现，每个像素由3个8位分量组成，分别代表红、绿、蓝（RGB）三个颜色通道，总计可以表示16777216种颜色（2的24次方），几乎涵盖了人眼可识别的所有颜色。 转换过程分为两部分...
颜色格式转换（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...
ColorBmpTo_OneBitBmp实现1/2/4/8/16/24/32位图转换
07-30
1/2/4/8/16/24/32位图转换代码 BOOL SaveTrueBmp(char* p_SrcFileName, char* p_szNewBitCountFile, WORD wBitCountIN) { HBITMAP hBitmap=(HBITMAP)LoadImage(NULL,p_SrcFileName,IMAGE_BITMAP,0,0,LR_LOADFROMFILE|LR_CREATEDIBSECTION|LR_DEFAULTSIZE); //设备描述表 HDC hDC; //位图中每象素所占字节数为1/2/4/8/16/24/32 WORD wBitCount = wBitCountIN; //定义调色板大小， 位图中像素字节大小 ，位图文件大小 ， 写入文件字节数 DWORD dwPaletteSize=0, dwBmBitsSize=0, dwDIBSize=0, dwWritten=0; //位图属性结构 BITMAP Bitmap; //位图文件头结构 BITMAPFILEHEADER bmfHdr; //位图信息头结构 BITMAPINFOHEADER bi; //指向位图信息头结构 LPBITMAPINFOHEADER lpbi; //定义文件，分配内存句柄，调色板句柄 HANDLE fh=0, hDib=0, hPal=0,hOldPal=NULL; GetObject(hBitmap, sizeof(Bitmap), (LPSTR)&Bitmap); bi.biSize = sizeof(BITMAPINFOHEADER); bi.biWidth = Bitmap.bmWidth; bi.biHeight = Bitmap.bmHeight; bi.biPlanes = 1; bi.biBitCount = wBitCount; bi.biCompression = BI_RGB; bi.biSizeImage = 0; bi.biXPelsPerMeter = 0; bi.biYPelsPerMeter = 0; bi.biClrImportant = 0; bi.biClrUsed = 0;
RGB与十六位颜色代码转换工具ColorUtility
11-29
RGB颜色与十六位颜色代码转换工具 RGB颜色与十位颜色代码转换工具 十位颜色代码与十六位颜色代码转换工具 效果截图： http://hi.csdn.net/attachment/201111/29/5628048_1322528285S621.jpg
创建压缩纹理的工具
weixin_34191845的博客
08-31 187
 Once a texture has been loaded as a compressed texture, it can be used for texturing in exactly the same way as an uncompressed texture. The details of the ETC2/EAC formats are beyond our scope her...
颜色转换工具原理
King的博客
07-21 404
一、16进制–>RGB function colorConversion(color) { let arr = []; let l = 0; if (color.length === 7) { l = 2; } if (color.length === 4) { l = 1; } for (let i = 1; i < color.length; i += l) { if (color.length ==
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 8827
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
（1） 实现RGB颜色空间和HSI颜色空间之间的转换
最新发布
03-25
A：（1）RGB颜色空间和HSI颜色空间之间的转换可以通过以下步骤实现： 1. 将 RGB 的 R、G、B 值分别归一化到 [0, 1] 区间内。 2. 计算出 H（色相）、S（饱和度）和 I（强度/亮度）三个分量。 1）色相 H 的计算...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值