2 4 8位BMP转24位BMP（代码）

最新推荐文章于 2021-05-20 08:01:52 发布
最新推荐文章于 2021-05-20 08:01:52 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： 图像处理 文章标签： 图像处理 bmp 位图 
//#include "stdafx.h"
#include <math.h>
#define WIDTHBYTE(bit)   ((  ( (bit)+31)/32 )*4)
#define _BITS_PER_PIXEL_24	24	
BOOL ConvertBmp4ToBmp24(const char* pSrcFile,const char* pDesFile)
{
    FILE* fpSrc = fopen(pSrcFile,"rb");
	if(fpSrc == NULL) return FALSE;
	
	// Read BITMAPFILEHEADER info
	BITMAPFILEHEADER bfh;
	fread(&bfh, 1, sizeof(BITMAPFILEHEADER), fpSrc);
	
	// Read BITMAPINFOHEADER info
	BITMAPINFOHEADER bih;
	fread(&bih, 1, sizeof(BITMAPINFOHEADER), fpSrc);
	
	const int iPitch = WIDTHBYTE(bih.biBitCount*bih.biWidth);


	if(bih.biBitCount == 4) //16 色
	{
		//转换为 24 位
		long _bpp = (_BITS_PER_PIXEL_24 >> 3);
		long _pitch = bih.biWidth * _bpp;
		while ((_pitch & 3) != 0)
			_pitch++;
		
		
		FILE* fpDes = fopen(pDesFile,"wb");
		if(fpDes == NULL)
		{
			fclose(fpSrc);
			return FALSE;
		}
		//24 bmp header
		BITMAPFILEHEADER bfh24 = bfh;
		BITMAPINFOHEADER bih24 = bih;
		DWORD dwSize = _pitch * bih.biHeight;
		bfh24.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwSize;
		bfh24.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
		bih24.biBitCount = _BITS_PER_PIXEL_24;
        fwrite(&bfh24,sizeof(BITMAPFILEHEADER),1,fpDes);
		fwrite(&bih24,sizeof(BITMAPINFOHEADER),1,fpDes);
		//end
		
		// Calculate palette entries
		int  iPaletteEntries = bih.biClrUsed;
		if (iPaletteEntries == 0)
			iPaletteEntries = 16;
		
		RGBQUAD lpPalette[256] = {0};
		// Read palette info
		fread(lpPalette, iPaletteEntries, sizeof(RGBQUAD), fpSrc);
		
		//Progress
// 		CProgressDlg dlg;//进度条
// 		dlg.Create();
// 		dlg.SetStep(1);
// 		dlg.SetPos(0);
// 		dlg.SetWindowText(_T("位图格式转换中..."));
		//分批读取数据 200 row
		const int oncerow = 200;
		const int times = bih.biHeight/oncerow;
		for(int i = 0;i<times;i++) //需要处理多少次
		{
			//dlg.SetPos( (1.0*i/times)*100);
			const DWORD dwSize = iPitch * oncerow;
			LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
			fread(lpData, dwSize, sizeof(BYTE), fpSrc);   
			
			// Create temporary bitmap
			const DWORD dw24Size = _pitch * oncerow;
			LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));
			
			// Convert bitmap
			DWORD dwDstHorizontalOffset;
			DWORD dwDstVerticalOffset = 0;
			DWORD dwDstTotalOffset;
			
			DWORD dwSrcHorizontalOffset;
			DWORD dwSrcVerticalOffset = 0;
			DWORD dwSrcTotalOffset;
			
			for (long i=0; i<oncerow; i++) //每次转换 200 行
			{
				dwDstHorizontalOffset = 0;
				dwSrcHorizontalOffset = 0;
				for (long j=0; j<bih.biWidth; j++) //像素个数
				{
					// Update destination total offset
					dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;
					
					// Update source total offset
					dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;
					
					//lpData[dwSrcTotalOffset]
					//第 j 个像素点
					//const int bitoffidx = 7 - j%8; //前 4 个字节的值
					//const int opreatenum = pow(2,bitoffidx);
					//int statevalue = (lpData[dwSrcTotalOffset]&opreatenum) >> bitoffidx;
					int statevalue = 0;
					if(j%2 == 0)
					{
                      statevalue = (lpData[dwSrcTotalOffset] & 0xf0) >> 4;
					}
					else
					{
                      statevalue = lpData[dwSrcTotalOffset] & 0x0f;
					}

					BYTE red = lpPalette[statevalue].rgbRed;
					BYTE green = lpPalette[statevalue].rgbGreen;
					BYTE blue = lpPalette[statevalue].rgbBlue;
					
					// Update bitmap
					lp24Data[dwDstTotalOffset+2] = red;
					lp24Data[dwDstTotalOffset+1] = green;
					lp24Data[dwDstTotalOffset] = blue;
					
					// Update destination horizontal offset
					dwDstHorizontalOffset += _bpp;
					
					// Update source horizontal offset
					dwSrcHorizontalOffset = (j+1)/2;
				}
				
				// Update destination vertical offset
				dwDstVerticalOffset += _pitch;
				
				// Update source vertical offset
				dwSrcVerticalOffset += iPitch;
			}
			fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
			delete[]  lp24Data;
		}
		//剩余不够 200 行的
		const int leftrow  = bih.biHeight%oncerow;
		//dlg.SetPos(100);
		if(leftrow > 0)
		{
			
			
			const DWORD dwSize = iPitch * leftrow;
			LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
			fread(lpData, dwSize, sizeof(BYTE), fpSrc);   
			
			// Create temporary bitmap
			const DWORD dw24Size = _pitch * leftrow;
			LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));
			
			// Convert bitmap
			DWORD dwDstHorizontalOffset;
			DWORD dwDstVerticalOffset = 0;
			DWORD dwDstTotalOffset;
			
			DWORD dwSrcHorizontalOffset;
			DWORD dwSrcVerticalOffset = 0;
			DWORD dwSrcTotalOffset;
			
			
			for (long i=0; i<leftrow; i++) //每次转换 200 行
			{
				dwDstHorizontalOffset = 0;
				dwSrcHorizontalOffset = 0;
				for (long j=0; j<bih.biWidth; j++)
				{
					// Update destination total offset
					dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;
					
					// Update source total offset
					dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;

					//star
					//const int bitoffidx = 7-j%8;
					//const int opreatenum = pow(2,bitoffidx);
					//int statevalue = (lpData[dwSrcTotalOffset]&opreatenum) >> bitoffidx;
					int statevalue = 0;
					if(j%2 == 0)
					{
						statevalue = (lpData[dwSrcTotalOffset] & 0xf0) >> 4;
					}
					else
					{
						statevalue = lpData[dwSrcTotalOffset] & 0x0f;
					}
					
					BYTE red = lpPalette[statevalue].rgbRed;
					BYTE green = lpPalette[statevalue].rgbGreen;
					BYTE blue = lpPalette[statevalue].rgbBlue;
					//end
									
					// Update bitmap
					lp24Data[dwDstTotalOffset+2] = red;
					lp24Data[dwDstTotalOffset+1] = green;
					lp24Data[dwDstTotalOffset] = blue;
					
					// Update destination horizontal offset
					dwDstHorizontalOffset += _bpp;
					
					// Update source horizontal offset
					dwSrcHorizontalOffset = (j+1)/2;
				}
				
				// Update destination vertical offset
				dwDstVerticalOffset += _pitch;
				
				// Update source vertical offset
				dwSrcVerticalOffset += iPitch;
			}
			fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
			delete[]  lp24Data;
		}
		fclose(fpSrc);
		fclose(fpDes);
		return TRUE;

	}
	else
	{
		fclose(fpSrc);
		return FALSE;
	}    
} 
BOOL ConvertBmp1ToBmp24(const char* pSrcFile,const char* pDesFile)
{
	FILE* fpSrc = fopen(pSrcFile,"rb");
	if(fpSrc == NULL) return FALSE;
	
	// Read BITMAPFILEHEADER info
	BITMAPFILEHEADER bfh;
	fread(&bfh, 1, sizeof(BITMAPFILEHEADER), fpSrc);
	
	// Read BITMAPINFOHEADER info
	BITMAPINFOHEADER bih;
	fread(&bih, 1, sizeof(BITMAPINFOHEADER), fpSrc);
	
	const int iPitch = WIDTHBYTE(bih.biBitCount*bih.biWidth);


	if(bih.biBitCount == 1) //黑白图
	{
		//转换为 24 位
		long _bpp = (_BITS_PER_PIXEL_24 >> 3);
		long _pitch = bih.biWidth * _bpp;
		while ((_pitch & 3) != 0)
			_pitch++;
		
		
		FILE* fpDes = fopen(pDesFile,"wb");
		if(fpDes == NULL)
		{
			fclose(fpSrc);
			return FALSE;
		}
		//24 bmp header
		BITMAPFILEHEADER bfh24 = bfh;
		BITMAPINFOHEADER bih24 = bih;
		DWORD dwSize = _pitch * bih.biHeight;
		bfh24.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwSize;
		bfh24.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
		bih24.biBitCount = _BITS_PER_PIXEL_24;
        fwrite(&bfh24,sizeof(BITMAPFILEHEADER),1,fpDes);
		fwrite(&bih24,sizeof(BITMAPINFOHEADER),1,fpDes);
		//end
		
		// Calculate palette entries
		int  iPaletteEntries = bih.biClrUsed;
		if (iPaletteEntries == 0)
			iPaletteEntries = 2;
		
		RGBQUAD lpPalette[256] = {0};
		// Read palette info
		fread(lpPalette, iPaletteEntries, sizeof(RGBQUAD), fpSrc);
		
// 		//Progress
// 		CProgressDlg dlg;//进度条
// 		dlg.Create();
// 		dlg.SetStep(1);
// 		dlg.SetPos(0);
// 		dlg.SetWindowText(_T("位图格式转换中..."));
		//分批读取数据 200 row
		const int oncerow = 200;
		const int times = bih.biHeight/oncerow;
		for(int i = 0;i<times;i++) //需要处理多少次
		{
			//dlg.SetPos( (1.0*i/times)*100);
			const DWORD dwSize = iPitch * oncerow;
			LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
			fread(lpData, dwSize, sizeof(BYTE), fpSrc);   
			
			// Create temporary bitmap
			const DWORD dw24Size = _pitch * oncerow;
			LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));
			
			// Convert bitmap
			DWORD dwDstHorizontalOffset;
			DWORD dwDstVerticalOffset = 0;
			DWORD dwDstTotalOffset;
			
			DWORD dwSrcHorizontalOffset;
			DWORD dwSrcVerticalOffset = 0;
			DWORD dwSrcTotalOffset;
			
			for (long i=0; i<oncerow; i++) //每次转换 200 行
			{
				dwDstHorizontalOffset = 0;
				dwSrcHorizontalOffset = 0;
				for (long j=0; j<bih.biWidth; j++) //像素个数
				{
					// Update destination total offset
					dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;
					
					// Update source total offset
					dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;
					
					//lpData[dwSrcTotalOffset]
					//第 j 个像素点
					const int bitoffidx = 7 - j%8;
					const int opreatenum = pow(2,bitoffidx);
					int statevalue = (lpData[dwSrcTotalOffset]&opreatenum) >> bitoffidx;

					BYTE red = lpPalette[statevalue].rgbRed;
					BYTE green = lpPalette[statevalue].rgbGreen;
					BYTE blue = lpPalette[statevalue].rgbBlue;
					
					// Update bitmap
					lp24Data[dwDstTotalOffset+2] = red;
					lp24Data[dwDstTotalOffset+1] = green;
					lp24Data[dwDstTotalOffset] = blue;
					
					// Update destination horizontal offset
					dwDstHorizontalOffset += _bpp;
					
					// Update source horizontal offset
					dwSrcHorizontalOffset = (j+1)/8;
				}
				
				// Update destination vertical offset
				dwDstVerticalOffset += _pitch;
				
				// Update source vertical offset
				dwSrcVerticalOffset += iPitch;
			}
			fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
			delete[]  lp24Data;
		}
		//剩余不够 200 行的
		const int leftrow  = bih.biHeight%oncerow;
		//dlg.SetPos(100);
		if(leftrow > 0)
		{
			
			
			const DWORD dwSize = iPitch * leftrow;
			LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
			fread(lpData, dwSize, sizeof(BYTE), fpSrc);   
			
			// Create temporary bitmap
			const DWORD dw24Size = _pitch * leftrow;
			LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));
			
			// Convert bitmap
			DWORD dwDstHorizontalOffset;
			DWORD dwDstVerticalOffset = 0;
			DWORD dwDstTotalOffset;
			
			DWORD dwSrcHorizontalOffset;
			DWORD dwSrcVerticalOffset = 0;
			DWORD dwSrcTotalOffset;
			
			
			for (long i=0; i<leftrow; i++) //每次转换 200 行
			{
				dwDstHorizontalOffset = 0;
				dwSrcHorizontalOffset = 0;
				for (long j=0; j<bih.biWidth; j++)
				{
					// Update destination total offset
					dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;
					
					// Update source total offset
					dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;

					//star
					const int bitoffidx = 7-j%8;
					const int opreatenum = pow(2,bitoffidx);
					int statevalue = (lpData[dwSrcTotalOffset]&opreatenum) >> bitoffidx;
					
					BYTE red = lpPalette[statevalue].rgbRed;
					BYTE green = lpPalette[statevalue].rgbGreen;
					BYTE blue = lpPalette[statevalue].rgbBlue;
					//end
									
					// Update bitmap
					lp24Data[dwDstTotalOffset+2] = red;
					lp24Data[dwDstTotalOffset+1] = green;
					lp24Data[dwDstTotalOffset] = blue;
					
					// Update destination horizontal offset
					dwDstHorizontalOffset += _bpp;
					
					// Update source horizontal offset
					dwSrcHorizontalOffset = (j+1)/8;
				}
				
				// Update destination vertical offset
				dwDstVerticalOffset += _pitch;
				
				// Update source vertical offset
				dwSrcVerticalOffset += iPitch;
			}
			fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
			delete[]  lp24Data;
		}
		fclose(fpSrc);
		fclose(fpDes);
		return TRUE;

	}
	else
	{
		fclose(fpSrc);
		return FALSE;
	}
}
BOOL ConvertBmp8ToBmp24(const char* pSrcFile,const char* pDesFile)
{
	FILE* fpSrc = fopen(pSrcFile,"rb");
	if(fpSrc == NULL) return FALSE;
	
	// Read BITMAPFILEHEADER info
	BITMAPFILEHEADER bfh;
	fread(&bfh, 1, sizeof(BITMAPFILEHEADER), fpSrc);
	
	// Read BITMAPINFOHEADER info
	BITMAPINFOHEADER bih;
	fread(&bih, 1, sizeof(BITMAPINFOHEADER), fpSrc);
	
	// Calculate pitch
	const int iBpp = bih.biBitCount >> 3;
	int iPitch = iBpp * bih.biWidth;
	while ((iPitch & 3) != 0)
		iPitch++;	
	if (bih.biBitCount == 8)
	{
		//转换为 24 位
		long _bpp = (_BITS_PER_PIXEL_24 >> 3);
		long _pitch = bih.biWidth * _bpp;
		while ((_pitch & 3) != 0)
			_pitch++;
		
		
		FILE* fpDes = fopen(pDesFile,"wb");
		if(fpDes == NULL)
		{
			fclose(fpSrc);
			return FALSE;
		}
		//24 bmp header
		BITMAPFILEHEADER bfh24 = bfh;
		BITMAPINFOHEADER bih24 = bih;
		DWORD dwSize = _pitch * bih.biHeight;
		bfh24.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwSize;
		bfh24.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
		bih24.biBitCount = _BITS_PER_PIXEL_24;
        fwrite(&bfh24,sizeof(BITMAPFILEHEADER),1,fpDes);
		fwrite(&bih24,sizeof(BITMAPINFOHEADER),1,fpDes);
		//end
		
		// Calculate palette entries
		int  iPaletteEntries = bih.biClrUsed;
		if (iPaletteEntries == 0)
			iPaletteEntries = 256;
		
		RGBQUAD lpPalette[256] = {0};
		// Read palette info
		fread(lpPalette, iPaletteEntries, sizeof(RGBQUAD), fpSrc);
		
		//Progress
// 		CProgressDlg dlg;//进度条
// 		dlg.Create();
// 		dlg.SetStep(1);
// 		dlg.SetPos(0);
// 	    dlg.SetWindowText(_T("位图格式转换中..."));
		//分批读取数据 200 row
		const int oncerow = 200;
		const int times = bih.biHeight/oncerow;
		for(int i = 0;i<times;i++) //需要处理多少次
		{
			//dlg.SetPos( (1.0*i/times)*100);
			const DWORD dwSize = iPitch * oncerow;
			LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
			fread(lpData, dwSize, sizeof(BYTE), fpSrc);   
			
			
			
			
			// Create temporary bitmap
			const DWORD dw24Size = _pitch * oncerow;
			LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));
			
			// Convert bitmap
			DWORD dwDstHorizontalOffset;
			DWORD dwDstVerticalOffset = 0;
			DWORD dwDstTotalOffset;
			
			DWORD dwSrcHorizontalOffset;
			DWORD dwSrcVerticalOffset = 0;
			DWORD dwSrcTotalOffset;
			
			for (long i=0; i<oncerow; i++) //每次转换 200 行
			{
				dwDstHorizontalOffset = 0;
				dwSrcHorizontalOffset = 0;
				for (long j=0; j<bih.biWidth; j++)
				{
					// Update destination total offset
					dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;
					
					// Update source total offset
					dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;
					
					BYTE red = lpPalette[lpData[dwSrcTotalOffset]].rgbRed;
					BYTE green = lpPalette[lpData[dwSrcTotalOffset]].rgbGreen;
					BYTE blue = lpPalette[lpData[dwSrcTotalOffset]].rgbBlue;
					
					// Update bitmap
					lp24Data[dwDstTotalOffset+2] = red;
					lp24Data[dwDstTotalOffset+1] = green;
					lp24Data[dwDstTotalOffset] = blue;
					
					// Update destination horizontal offset
					dwDstHorizontalOffset += _bpp;
					
					// Update source horizontal offset
					dwSrcHorizontalOffset += iBpp;
				}
				
				// Update destination vertical offset
				dwDstVerticalOffset += _pitch;
				
				// Update source vertical offset
				dwSrcVerticalOffset += iPitch;
			}
			fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
			delete[]  lp24Data;
		}
		//剩余不够 200 行的
		const int leftrow  = bih.biHeight%oncerow;
		//dlg.SetPos(100);
		if(leftrow > 0)
		{
			
			
			const DWORD dwSize = iPitch * leftrow;
			LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
			fread(lpData, dwSize, sizeof(BYTE), fpSrc);   
			
			
			
			
			// Create temporary bitmap
			const DWORD dw24Size = _pitch * leftrow;
			LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));
			
			// Convert bitmap
			DWORD dwDstHorizontalOffset;
			DWORD dwDstVerticalOffset = 0;
			DWORD dwDstTotalOffset;
			
			DWORD dwSrcHorizontalOffset;
			DWORD dwSrcVerticalOffset = 0;
			DWORD dwSrcTotalOffset;
			
			
			for (long i=0; i<leftrow; i++) //每次转换 200 行
			{
				dwDstHorizontalOffset = 0;
				dwSrcHorizontalOffset = 0;
				for (long j=0; j<bih.biWidth; j++)
				{
					// Update destination total offset
					dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;
					
					// Update source total offset
					dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;
					
					BYTE red = lpPalette[lpData[dwSrcTotalOffset]].rgbRed;
					BYTE green = lpPalette[lpData[dwSrcTotalOffset]].rgbGreen;
					BYTE blue = lpPalette[lpData[dwSrcTotalOffset]].rgbBlue;
					
					// Update bitmap
					lp24Data[dwDstTotalOffset+2] = red;
					lp24Data[dwDstTotalOffset+1] = green;
					lp24Data[dwDstTotalOffset] = blue;
					
					// Update destination horizontal offset
					dwDstHorizontalOffset += _bpp;
					
					// Update source horizontal offset
					dwSrcHorizontalOffset += iBpp;
				}
				
				// Update destination vertical offset
				dwDstVerticalOffset += _pitch;
				
				// Update source vertical offset
				dwSrcVerticalOffset += iPitch;
			}
			fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
			delete[]  lp24Data;
		}
		fclose(fpSrc);
		fclose(fpDes);
		return TRUE;
	}
	else
	{
		fclose(fpSrc);
		return FALSE;
	}
}
转载 ：http://download.csdn.net/detail/ccxbb/6022487
Cesar-Wu
关注
专栏目录
8bit 位bmp 转换 24bit
03-27
8bit 位bmp 转换 24bit vs 2008 上面编译。 没有安全检查代码，只有核心的转换代码。 里面有 说明.docx 可以查看
bmp格式 8bit与24bit深度相互转换
weixin_45824717的博客
04-10 3719
bmp格式 8bit与24bit相互转换 一、实验要求 在图像处理软件中生成8bit和24bit深度的BMP文件，编写程序实现不同像素深度文件的相互转换。重点掌握函数定义、缓存区分配、倒序读写、结构体操作。 二、算法原理 1. 8bit转24bit 8bitBMP图像文件包括4部分： 位图文件头fileheader typedef struct tagBITMAPFILEHEADER { WORD bfType; DWORD bfSize; WORD
BMP的8位位图转换24位位图
shejiannan的专栏
07-09 3578
#define WIDTHBYTES(bits) (((bits)+31)/32*4)  //一行的位数 /****************************************************************************** *函数功能：获取位图信息 *函数声明：    BOOL GetNormalBmpInfo(    CString m_str
实验二（1）——8bit像素深度bmp图片与24bit像素深度bmp图片互转2021-03-20
weixin_52189060的博客
03-20 2149
一.实验要求 编写8bit像素深度bmp图片与24bit像素深度bmp图片互相转换的程序，将给定的8bitbmp图片和24bitbmp图片分别转换为24bitbmp图片和8bitbmp图片，其中24bit转换成8bit时，转换规则及8bitbmp图片的调色板自行设定。 二.实验原理 1.8bit转换为24bit 只需将原8bit图像实际位图数据通过查找调色板获得对应的RGB数值直接写入到24bit图像的实际位图数据中。 2.24bit转换成8bit 先自行设定8bit图像的调色板及24bit转8
24位真彩色位图和8位灰度位图相互转换（C语言实现）
03-18 3695
<br />#include <stdio.h><br /> #include <stdlib.h><br /> #include <windows.h><br /><br /> FILE *fpSrcBmpfile;<br /> FILE *fpDestBmpfile;<br /><br /> void GetBmpHeader(PBITMAPFILEHEADER, PBITMAPINFOHEADER);<br /> void ChangeBmpHeader(PBITMAPFILEHEADER
把8bit位图转换位24位图的图片
ly611919的专栏
07-26 3392
最近写了一个把8bit位图转换位24位位图图片的程序.当初写时在网上搜索资料没有找到,并且发现很多人在询问,所以就把代码放于此,供大家参考! //下面是头文件 :8bto24b.h./**//*－－－－－－－－－位图文件头－－－－－－－－－－－*/typedef struct tagBITMAPFILEHEADER...{/**//*bmfh*/    char bfType[3]
bmp24位转8位
07-03
"bmp24位转8位"的过程是将原始的24位BMP图像转换为8位BMP图像，这一过程涉及到色彩量化和索引色的概念。色彩量化是将高色彩深度的图像转换为低色彩深度图像时必须进行的步骤，因为低色彩深度无法直接表示那么多的...
BMP8位于24位的转换.zip
03-27
24位真彩色BMP文件则提供更丰富的颜色表现，每个像素由3个8位分量组成，分别代表红、绿、蓝（RGB）三个颜色通道，总计可以表示16777216种颜色（2的24次方），几乎涵盖了人眼可识别的所有颜色。 转换过程分为两部分...
24为bmp转8位bmp
07-30
24位BMP图像转为8位BMP图像的处理...此外，示例代码中还提到了一个名为bmptrue2gray的函数，它接受两个参数：源24位BMP文件路径和目标8位BMP文件路径。这个函数实现了上述的转换逻辑，并最终生成了转换后的8位BMP文件。
BMP 8位转24位
07-20
8位BMP图像意味着每个像素由8位表示，最多可以有256种颜色（2^8），这通常被称为索引彩色图像。而24位BMP图像则提供24位的颜色深度，每像素可以表示16,777,216种颜色（2^24），这种格式称为真彩色图像。 8位到24位...
c++读取bmp文件24位8位4位……
07-09
最新读取bmp的程序， 运行过成功，快快看看吧！别犹豫！
2 4 8位BMP转24位BMP
08-27
支持大bmp文件，函数直接可用，二值图 灰度图 4位BMP转真彩色24位bmp，在vc6.0下测试通过。
图片转换工具（jpg转8位bmp，24位bmp转8位bmp）
11-05
可以实现jpg图片到256色bmp图片的转换，24位bmp图片到256色bmp图片的转换，含源代码，重新编译后即可
8位bmp图转24位bmp图源代码
01-03
bmp位图转换程序源码，支持8位无压缩位图，转换成24位无压缩位图
BMP图24位转换成1位单色
04-04
纯C语言代码，24位BMP转单色BMP，完美实现。用于点阵打印，印刷行业。
8位位图转换成24位位图
羽中仙灵
04-21 4889
c语言32位bmp转24位,BMP(24位)图片显示第三方函数
weixin_39623411的博客
05-20 616
BMP(24位)图片显示第三方函数请注意：这个函数只能打开24位真色彩的BMP图片。『关于将非24位BMP图片转换成24位BMP图片的方法』首先请安装PHOTOSHOP。然后用PS打开这个非24位BMP图片，选择文件—>存储为选择类型位BMP，确定，会弹出来一个对话框，有16位，24位，32位可以选择，请选择24位就可以了。『关于此第三方函数的使用方法』解压压缩包，得到三个文件：Svga64...
8位位图和24位位图的相互转换
彭军的专栏
01-04 1万+
8位位图转换为24位位图其实，只要从8位位图中取得一个像素的灰度值，然后去填充24位位图的三个字节就可以了，很明显，这样得到的24位位图是灰度的，就是RGB各分量是一样的值。主要的转换程序/*******************************************************************************函数功能：将8位位图转换为24位位图*函
实现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; //定义调色板大小， 位图中像素字节大小 ，位
C++实现8位BMP到单色图像转换
"C++代码实现将8位BMP图像转换为单色图像的方法" 在计算机图形学中，BMP（Bitmap）是一种常见的位图文件格式，它存储了像素的颜色信息。8位BMP图像意味着每个像素用8位来表示，可以有256种颜色。然而，在某些应用中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值