c++将24位bmp转8位bmp灰度, 8位bmp灰度反色，24位转3张8位bmp灰度图

已于 2022-08-03 13:43:33 修改
阅读量688 收藏 2
点赞数 1
分类专栏： c++ 文章标签： BMP文件 图像处理 颜色转换 位图数据 内存对齐
于 2022-08-03 10:36:13 首次发布
原文链接：https://blog.csdn.net/qq_58665528/article/details/123294711
版权

1首先我们需要定义组成bmp的四部分的结构体

#pragma once
 
using BYTE = unsigned char;//1
using WORD  = unsigned short;//2
using DWORD = unsigned int;//4
using LONG  = unsigned long;//4
 
#pragma pack(push)
#pragma pack(2) //每次读取两个字节，以确保为结构体创建的内存刚刚好是我们想要的
struct BITMAPFILEHEADER {//定义bitmap文件头结构
	WORD  bfType;//记录文件标识符，BM
	DWORD bfSize;//记录文件的大小:文件头，信息头，颜色表，颜色数据
	WORD  bfReserved1;//保留字 0
	WORD  bfReserved2;//保留字 0
	DWORD bfOffBits;//颜色数据距文件头的偏移量
};
 
//定义位图信息头结构
struct BITMAPINFOHEADER {
	DWORD biSize;//本结构体的大小
	LONG  biWidth;//位图的宽：像素
	LONG  biHeight;//位图的高：像素
	WORD  biPlanes;//为平面数（一般为1）
	WORD  biBitCount;//每个像素所需的位数：1，4，8，16，24，32
	DWORD biCompression;//位图压缩类型（一般不压缩，取0）
	DWORD biSizeImage;//位图的大小
	LONG  biXPelsPerMeter;//水平分辨率 0代表取标准值
	LONG  biYPelsPerMeter;//垂直分辨率 0代表取标准值
	DWORD biClrUsed;//颜色数 标准取0 计算方法为2的biBitCount次方
	DWORD biClrImportant;//重要颜色数 标准取0
};
 
//颜色表
struct RGBQUAD {
	BYTE rgbBlue;//蓝
	BYTE rgbGreen;//绿
	BYTE rgbRED;//红
	BYTE rgbReserved;//保留字 0
};
#pragma pack(pop)

2 构建可以读取bmp的类bitmap

#pragma once
#include "bitmapQuad.h"
#include <iostream>
#include <fstream>
 
class bitmap {
private:
	FILE* m_rfp;//读入文件指针
	FILE* m_wfp;//写入文件指针
	FILE* m_wfp1;//写入文件指针
	FILE* m_wfp2;//写入文件指针
	BITMAPFILEHEADER* m_pbfHeader;//文件头指针
	BITMAPINFOHEADER* m_pbiHeader;//位图信息头指针
	RGBQUAD* m_prgbQuad;//颜色表指针
	BYTE* m_pImgData;//位图数据指针
	DWORD m_imgSize;//位图数据大小
 
private:
	inline void readFileHeader(BITMAPFILEHEADER* bmFileHeader);//读取文件头数据
	inline void readInfoHeader(BITMAPINFOHEADER* bmInfoHeader);//读取信息头数据
	inline void readRgbQuad(RGBQUAD* rgbQuad, const int& rgbQuadSize);//读取颜色表数据
	inline void readImgData(BYTE* pImgData, const DWORD& imgSize);//读取位图数据
 
private:
	inline void writeFileHeader(BITMAPFILEHEADER* pbfHeader);//读取文件头数据
	inline void writeInfoHeader(BITMAPINFOHEADER* pbiHeader);//读取信息头数据
	inline void writeRgbQuad(RGBQUAD* prgbQuad, const int& rgbQuadSize);//读取颜色表数据
	inline void writeImgData(BYTE* pImgData, const DWORD& imgSize);//读取位图数据
 
private:
	void createGrey_8();//创建8位灰度颜色表
 
public:
	bitmap(const char* readFilePath, const char* writeFilePath);
	bitmap(const char* readFilePath, const char* writeFilePath0, const char* writeFilePath1, const char* writeFilePath2);
	~bitmap();
	void rgb24_to_grey8();//24位图转为8位灰度图
	void grey8_to_antiGrey8();//8位图反色
	void rgb24_to_3grey8();//24位图分离为3个8位灰度图
 
};

3 实现

#include "bitmap.h"
 
#pragma region bmp文件四部分的读入
/*读取文件头*/
inline
void bitmap::readFileHeader(BITMAPFILEHEADER* bmFileHeader) {
	fread(bmFileHeader, sizeof(BITMAPFILEHEADER), 1, m_rfp);
}
 
/*读取信息头*/
inline
void bitmap::readInfoHeader(BITMAPINFOHEADER* bmInfoHeader) {
	fread(bmInfoHeader, sizeof(BITMAPINFOHEADER), 1, m_rfp);
}
 
/*读取颜色表*/
inline
void bitmap::readRgbQuad(RGBQUAD* rgbQuad, const int& rgbQuadSize) {
	fread(rgbQuad, rgbQuadSize, 1, m_rfp);
}
 
/*读取位图数据*/
inline
void bitmap::readImgData(BYTE* pImgData, const DWORD& imgSize) {
	fread(pImgData, imgSize, 1, m_rfp);
}
#pragma endregion
 
 
#pragma region bmp文件四部分的写入
/*写入文件头*/
inline
void bitmap::writeFileHeader(BITMAPFILEHEADER* bmFileHeader) {
	fwrite(bmFileHeader, sizeof(BITMAPFILEHEADER), 1, m_wfp);
}
 
/*写入信息头*/
inline
void bitmap::writeInfoHeader(BITMAPINFOHEADER* bmInfoHeader) {
	fwrite(bmInfoHeader, sizeof(BITMAPINFOHEADER), 1, m_wfp);
}
 
/*写入颜色表*/
inline
void bitmap::writeRgbQuad(RGBQUAD* rgbQuad, const int& rgbQuadSize) {
	fwrite(rgbQuad, rgbQuadSize, 1, m_wfp);
}
 
/*写入位图数据*/
inline
void bitmap::writeImgData(BYTE* pImgData, const DWORD& imgSize) {
	fwrite(pImgData, imgSize, 1, m_wfp);
}
#pragma endregion
 
 
#pragma region 构造和析构函数
 
bitmap::bitmap(const char* readFilePath, const char* writeFilePath) {
	m_rfp = fopen(readFilePath, "rb");//只读二进制文件
	m_wfp = fopen(writeFilePath, "wb");//只写二进制文件
 
	m_pbfHeader = new BITMAPFILEHEADER;//为文件头分配存储空间
	readFileHeader(m_pbfHeader);//将图片的文件头读入
 
	if (m_pbfHeader->bfType == 0x4d42/*检查是否为bm图片*/) {
		m_pbiHeader = new BITMAPINFOHEADER;//为信息头分配内存空间
		readInfoHeader(m_pbiHeader);//将图片的信息头读入
 
		//24位
		if (m_pbiHeader->biBitCount == 24) {
			m_imgSize = m_pbiHeader->biSizeImage;//获取位图数据大小
			m_pImgData = new BYTE[m_imgSize];//为位图数据分配内存
			readImgData(m_pImgData, m_imgSize);//将图片数据读入
 
			fclose(m_rfp);//结束读入
		}
 
		//8位
		if (m_pbiHeader->biBitCount == 8) {
			m_prgbQuad = new RGBQUAD[256];//位颜色表分配内存空间
			readRgbQuad(m_prgbQuad, sizeof(RGBQUAD) * 256);//读取颜色表
 
			m_imgSize = m_pbiHeader->biSizeImage;//获取位图数据大小
			m_pImgData = new BYTE[m_imgSize];//为位图数据分配内存
			readImgData(m_pImgData, m_imgSize);//将图片数据读入
 
			fclose(m_rfp);//结束读入
		}
 
	}
	
}
 
bitmap::bitmap(const char* readFilePath, const char* writeFilePath0, const char* writeFilePath1, const char* writeFilePath2) {
	m_rfp = fopen(readFilePath, "rb");//只读二进制文件
	m_wfp = fopen(writeFilePath0, "wb");//只写二进制文件
	m_wfp1 = fopen(writeFilePath1, "wb");//只写二进制文件
	m_wfp2 = fopen(writeFilePath2, "wb");//只写二进制文件
 
	m_pbfHeader = new BITMAPFILEHEADER;//为文件头分配存储空间
	readFileHeader(m_pbfHeader);//将图片的文件头读入
 
	if (m_pbfHeader->bfType == 0x4d42/*检查是否为bm图片*/) {
		m_pbiHeader = new BITMAPINFOHEADER;//为信息头分配内存空间
		readInfoHeader(m_pbiHeader);//将图片的信息头读入
 
		//24位
		if (m_pbiHeader->biBitCount == 24) {
			m_imgSize = m_pbiHeader->biSizeImage;//获取位图数据大小
			m_pImgData = new BYTE[m_imgSize];//为位图数据分配内存
			readImgData(m_pImgData, m_imgSize);//将图片数据读入
 
			fclose(m_rfp);//结束读入
		}
	}
}
 
//析构函数
bitmap::~bitmap() {
	fclose(m_wfp);//结束写入
	if(m_pbfHeader != nullptr)
		delete m_pbfHeader;
	if (m_pbiHeader != nullptr)
		delete m_pbiHeader;
	if (m_prgbQuad != nullptr)
		delete m_prgbQuad;
	if (m_pImgData != nullptr)
		delete m_pImgData;
}
#pragma endregion
 
 
#pragma region 创建颜色表
//创建灰度8位颜色表
void bitmap::createGrey_8() {
	BYTE rgb = 0;
	BYTE rgbReserved = 0;
 
	m_prgbQuad = new RGBQUAD[256];//256色颜色分配内存
	for (int i = 0; i < 256; ++i) {
		m_prgbQuad[i].rgbBlue = rgb;
		m_prgbQuad[i].rgbGreen = rgb;
		m_prgbQuad[i].rgbRED = rgb;
		m_prgbQuad[i].rgbReserved = rgbReserved;
		++rgb;
	}
}
#pragma endregion
 
 
#pragma region 处理图片的方法
//将24位转为8位灰图
void bitmap::rgb24_to_grey8() {
	DWORD imgSize = m_pbiHeader->biHeight * (m_pbiHeader->biWidth / 4 + 1) * 4;//新图片的数据大小
	BYTE* imgData = new BYTE[imgSize]{};//为其分配内存
 
	//处理文件头
	m_pbfHeader->bfOffBits = 54 + 1024;//多加了一个颜色表256*4
	m_pbfHeader->bfSize = m_pbfHeader->bfOffBits + imgSize;//得出8位灰度时该分辨率的数据大小
	
	//处理信息头
	m_pbiHeader->biBitCount = 8;//每个像素现在8位
	m_pbiHeader->biSizeImage = imgSize;//更新数据大小
	m_pbiHeader->biClrUsed = 256;//将颜色表索引数改为256
	
	//创建颜色表
	createGrey_8();
	
	//将24位数据转换位8位数据
	int tmp;
	for (unsigned int i = 0; i < m_imgSize; i += 3) {
		tmp = (float)m_pImgData[i] * 0.114f + (float)m_pImgData[i + 1] * 0.587f + (float)m_pImgData[i + 2] * 0.299f;
		imgData[i / 3] = BYTE(tmp);
	}
 
	//写入数据
	writeFileHeader(m_pbfHeader);//写入文件头
	writeInfoHeader(m_pbiHeader);
	writeRgbQuad(m_prgbQuad, 256 * sizeof(RGBQUAD));
	writeImgData(imgData, imgSize);
}
 
//将8位灰度图反色
void bitmap::grey8_to_antiGrey8() {
	//数据区反色
	for (unsigned int i = 0; i < m_imgSize; ++i) {
		m_pImgData[i] = abs(m_pImgData[i] - 255);
	}
 
	//写入
	writeFileHeader(m_pbfHeader);
	writeInfoHeader(m_pbiHeader);
	writeRgbQuad(m_prgbQuad, sizeof(RGBQUAD) * 256);
	writeImgData(m_pImgData, m_imgSize);
}
 
//将24位分离成3个8位图
void bitmap::rgb24_to_3grey8() {
	DWORD imgSize = m_pbiHeader->biHeight * (m_pbiHeader->biWidth / 4 + 1) * 4;//新图片数据大小
	BYTE* imgData0 = new BYTE[imgSize]{};//为其1分配内存
	BYTE* imgData1 = new BYTE[imgSize]{};//为其2分配内存
	BYTE* imgData2 = new BYTE[imgSize]{};//为其3分配内存
 
	#pragma region 生成第一张图片
	//生成第一张图片
		//处理文件头
	m_pbfHeader->bfOffBits = 54 + 1024;//多加了一个颜色表256*4
	m_pbfHeader->bfSize = m_pbfHeader->bfOffBits + imgSize;//得出8位灰度时该分辨率的数据大小
 
		//处理信息头
	m_pbiHeader->biBitCount = 8;//每个像素现在8位
	m_pbiHeader->biSizeImage = imgSize;//更新数据大小
	m_pbiHeader->biClrUsed = 256;//将颜色表索引数改为256
 
		//处理颜色表
	createGrey_8();
 
	//分离数据
	for (unsigned int i = 0; i < m_imgSize; i += 3) {
		imgData0[i / 3] = m_pImgData[i];
	}
 
	//写入数据
	writeFileHeader(m_pbfHeader);//写入文件头
	writeInfoHeader(m_pbiHeader);
	writeRgbQuad(m_prgbQuad, 256 * sizeof(RGBQUAD));
	writeImgData(imgData0, imgSize);
 
	//关闭
	fclose(m_wfp);
	m_wfp = m_wfp1;
	#pragma endregion
 
	#pragma region 生成第二张图片
	//生成第二张图片
		//分离数据
	for (unsigned int i = 0; i < m_imgSize; i += 3) {
		imgData0[i / 3] = m_pImgData[i + 1];
	}
		//写入数据
	writeFileHeader(m_pbfHeader);
	writeInfoHeader(m_pbiHeader);
	writeRgbQuad(m_prgbQuad, 256 * sizeof(RGBQUAD));
	writeImgData(imgData0, imgSize);
 
		//关闭
	fclose(m_wfp);
	m_wfp = m_wfp2;
	#pragma endregion
 
	#pragma region 生成第三张图片
	//生成第三张图片
		//分离数据
	for (unsigned int i = 0; i < m_imgSize; i += 3) {
		imgData0[i / 3] = m_pImgData[i + 2];
	}
	//写入数据
	writeFileHeader(m_pbfHeader);
	writeInfoHeader(m_pbiHeader);
	writeRgbQuad(m_prgbQuad, 256 * sizeof(RGBQUAD));
	writeImgData(imgData0, imgSize);
	#pragma endregion
 
}
#pragma endregion

一个测试读写BMP文件的例子 自己定义了BMP文件的结构体

#pragma pack(push)  
#pragma pack(1)  //改变内存对齐模式

typedef struct  tag_bitmap_file_header {
	unsigned short 		file_type;
	unsigned long 		file_size;
	unsigned short 		reserved1;
	unsigned short 		reserved2;
	unsigned int 		offset_bits;
}bitmap_file_header;

typedef struct tag_bitmap_info_header {
	unsigned int 		bitmap_info_size;
	int 				bitmap_width;
	int 				bitmap_height;
	unsigned short 		planes;
	unsigned short 		image_depth;
	unsigned int 		compression;
	unsigned int 		image_size;
	int 				x_pels_permeter;
	int 				y_pels_permeter;
	unsigned int 		color_used;
	unsigned int 		color_important;
}bitmap_info_header;

typedef struct tag_bitmap_palette {
	unsigned char 		blue;
	unsigned char 		green;
	unsigned char 		red;
	unsigned char 		reserved;
}bitmap_palette;

#pragma pack(pop)

实现代码

#pragma region 创建颜色表
//创建灰度8位颜色表
RGBQUAD* m_prgbQuad;
void createGrey_8() {
	BYTE rgb = 0;
	BYTE rgbReserved = 0;

	m_prgbQuad = new RGBQUAD[256];//256色颜色分配内存
	for (int i = 0; i < 256; ++i) {
		m_prgbQuad[i].rgbBlue = rgb;
		m_prgbQuad[i].rgbGreen = rgb;
		m_prgbQuad[i].rgbRed = rgb;
		m_prgbQuad[i].rgbReserved = rgbReserved;
		++rgb;
	}
}
#pragma endregion

void saveToBMP()
{
	//读test.bmp 再写回到mybmp.bmp
	Mat src = imread("d:\\test.bmp");
	//颜色表大小,以字节为单位,灰度图像颜色表为1024字节,彩色图像颜色表大小为0
	
	bitmap_file_header src_file_head;  //BITMAPFILEHEADER
	bitmap_info_header src_info_head;  //BITMAPINFOHEADER
	bitmap_palette src_palette;        //RGBQUAD
	//BITMAPFILEHEADER src_file_head;
	//BITMAPINFOHEADER src_info_head;
	//RGBQUAD			 src_palette;
	int s1 = sizeof(BITMAPFILEHEADER);
	int s2 = sizeof(bitmap_file_header);
	int s3 = sizeof(bitmap_palette);
	FILE* fsrc = fopen("d:\\test.bmp", "rb");
	fread(&src_file_head, 1, sizeof(BITMAPFILEHEADER), fsrc);
	fread(&src_info_head, 1, sizeof(BITMAPINFOHEADER), fsrc);
	fread(&src_palette, 1, sizeof(RGBQUAD), fsrc);
	int src_image_size = src_info_head.image_size; //biSizeImage;
	unsigned char* src_image_buff = new unsigned char[src_image_size];
	fread(src_image_buff, 1, src_image_size, fsrc);
	fclose(fsrc);

	FILE* fw = fopen("d:\\mybmp.bmp", "wb");
	if (fw == nullptr)
		return;
	fwrite(&src_file_head, 1, sizeof(bitmap_file_header), fw);
	fwrite(&src_info_head, 1, sizeof(bitmap_info_header), fw);
	fwrite(&src_palette, 1, sizeof(bitmap_palette), fw);
	fwrite(src_image_buff, 1, src_image_size /*line_bytes * src.rows*/, fw);
	fclose(fw);
	//delete[] src_image_buff;
	
	/// <summary>
	/// 写8位 BMP文件
	/// </summary>
	auto rows = src.rows;
	int colorTablesize = 0;
	auto biBitCount = src.depth();
	if (src.depth() == 8)
		colorTablesize = 1024;
	auto depth = src.depth();
	auto channels = src.channels();
	unsigned char* pData = src.data;
	auto elem_size = src.elemSize();
	//int line_bytes = (src.cols * elem_size +4) / 4 *4 ;  //24 bit
	int line_bytes = (src.cols * elem_size  / 4 +1) *4 ;  //8 bit
	int image_size = line_bytes * src.rows;
	bitmap_file_header fileHead;
	fileHead.file_type = 0x4D42;	
	fileHead.reserved1 = 0;
	fileHead.reserved2 = 0;
	//fileHead.offset_bits = 54 + 0;  //24 bit
	fileHead.offset_bits = 54 + 1024;  //8 bit
	fileHead.file_size =fileHead.offset_bits //sizeof(bitmap_file_header)	+ sizeof(bitmap_info_header) + sizeof(bitmap_palette)
		+ image_size;
	

	//write file head
	FILE* fp = fopen("d:\\mybmp2.bmp", "wb");
	if (fp == nullptr)
		return;
	fwrite(&fileHead,1, sizeof(bitmap_file_header), fp);

	bitmap_info_header head;
	head.bitmap_info_size = 40;
	head.image_depth = 8; //elem_size * 8; //32 bit 
	head.color_important = 0;
	//head.color_used = 0;  //24 bit
	head.color_used = 256; //8 bit
	head.compression = 0;
	head.bitmap_height = src.rows;
	head.bitmap_width = src.cols*3;
	head.planes = 1;
	head.image_size = image_size;// line_bytes* src.rows;
	head.x_pels_permeter = 0;
	head.y_pels_permeter = 0;
	fwrite(&head, 1,sizeof(bitmap_info_header), fp);

	//如果灰度图像,有颜色表,写入文件 
	if (head.image_depth == 8)
	{
		createGrey_8();
		fwrite(m_prgbQuad, sizeof(RGBQUAD), 256, fp);
	}
	else {
		bitmap_palette palette = src_palette;

		palette.blue = 255; palette.green = 255; palette.red = 255; palette.reserved = 255;
		fwrite(&palette, 1, sizeof(bitmap_palette), fp);
	}

	//fwrite(src_image_buff, 1, src_image_size /*line_bytes * src.rows*/, fp);
	fwrite(src_image_buff, 1, src_image_size, fp);
	fclose(fp);
	delete[] src_image_buff;
	delete[] m_prgbQuad;
}
richer_live
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
matlab 将24位图转换为8位图,实现1位,4位,8位,24位BMP位图的互相转换的方法
weixin_39613744的博客
03-20 1390
BOOL SaveTrueBmp(HBITMAP hBitmap, CString FileName){//设备描述表HDC hDC;//真彩色位图中每象素所占字节数为24WORD wBitCount=24;//定义调色板大小， 位图中像素字节大小 ，位图文件大小 ， 写入文件字节数DWORD dwPaletteSize=0, dwBmBitsSize=0, dwDIBSize=0,dwWritt...
数字图像处理 将24位真彩色BMP图像转化成8位BMP灰度图像
01-11
实验名称：彩色图转换成灰度图 实验任务：将24位真彩色BMP图像转化成8位BMP灰度图像
24位位深bmp文件转换为8位位深bmp文件
最新发布
daocaoren94的博客
05-19 532
位深（Bit Depth）是衡量数字图像中每个像素可以表示的颜色数量的一个指标。位深越高，每个像素可以表示的颜色就越丰富，图像的细节和质量也就越高。常见的位深为8位、16位、24位和32位。​由于dsp上的限制，在RTOS上只能显示8位位深的bmp，所以需要将24位位深的bmp转为8位位深的bmp。
24位真彩色转换为８位灰度图片（完整代码）
qinxiaoli1204的专栏
03-11 2592
图像的灰度与二值化 http://www.cnblogs.com/maozefa/archive/2011/12/09/2281656.html 图像的灰度化与二值化是图像处理中最常见的处理方法，也是很多图像处理方法的基础，如图像灰度统计、图像识别等。 图像的灰度化与二值化方法较多，处理过程也比较简单。但切不可因其简单而忽视效率。如常用的图像灰度计算公式：gray = red * 0
VS2010 C++学习（3）：BMP图像文件的特效显示代码
05-22
在本篇中，我们将深入探讨如何使用C++在Visual Studio 2010环境下处理BMP图像文件，并实现一些特效显示。BMP是Windows操作系统中常见的位图图像格式，它包含未经压缩的像素数据，因此非常适合进行直接的编程操作。 ...
bmp图像改色程序
11-09
- 颜色深度：对于不同颜色深度的BMP图像，处理方式可能会有所不同，尤其是对于1位、4位和8位的索引颜色模式，需要处理颜色表。 - 图像大小：大图像可能需要更多的内存和时间来处理，优化算法以减少资源消耗是必要...
bmp图像的简单处理
11-04
每个像素可以是8位、16位、24位或32位，对应灰度、索引颜色、真彩色和带Alpha通道的颜色。对于24位BMP（即每个像素有红、绿、蓝三个分量），每个像素占用3个字节。你可以遍历这些字节，进行颜色转换、滤波或其他图像...
打印BMP格式文件
04-14
同时，根据色彩位数转换像素值，例如从24位色彩转换为灰度图像。 3. **创建设备上下文**（Device Context，DC）：在Windows操作系统中，设备上下文是用于图形输出的接口。通过`CreateDC()`函数，我们可以创建一个...
MFC数字图像处理（BMP格式读取 保存 DFT FFT 直方图 色调均化 缩放 模糊 锐化 滤镜 形态学处理 曲线 裁剪 灰度图 彩色图 自动阈值）
07-23
BMP格式读取 保存 DFT FFT 直方图 色调均化 缩放 模糊 锐化 滤镜 形态学处理 曲线 裁剪 灰度图 彩色图 自动阈值 等等...除此之外还有很多其他小功能... 建议使用VS2013打开！！！核心代码在Bmp.cpp中！！！ 更新...
bmp24位彩色图像转8位灰度图像（纯C++）
03-06
bmp24位彩色图像转8位灰度图像，纯C++语言实现，适合图片处理初学者。
bmp图像读写操作和基本图像处理
12-22
3. **彩色图像转灰度图像**：将彩色图像转换为灰度图像，一般通过加权求和红、绿、蓝三原色的亮度来实现，权重通常为0.299R + 0.587G + 0.114B。 4. **图像叠置分析**：在图像处理中，叠置是指将一个图像覆盖到另一...
cximage599c_full.rar_图形图像处理_Visual_C++_
08-12
2. 图像操作：包括图像缩放、旋转、裁剪、平移、颜色转换（如灰度化、反色）、滤波（如模糊、锐化）、色彩空间转换（如RGB到HSV）等。 3. 图像效果：提供了一些特效处理，如alpha混合、透明度调整、自定义滤镜应用...
Visual C++程序开发范例宝典(PDF扫描版).part3
03-15
　cc实例095　图像的灰度化转换　 　cc实例096　显示JPG图片　 　3.5　图形转换与缩放　 　cc实例097　将位图转换为JPG　 　cc实例098　将位图转为GIF图标　 　cc实例099　图片的平滑缩放　 　3.6　图像的剪切与合成...
直接通过ESC指令操作打印机打印图片
11-30
3. 数据转换：将图片数据转换成打印机可以理解的点阵格式，通常是1位黑白色或8位灰度数据。 4. ESC指令生成：基于转换后的数据生成对应的ESC指令序列。 5. 数据传输：将ESC指令序列通过合适的通信协议发送给打印机。...
实现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++ BYTE保存为8位BMP/bitmap位图
u013972657的博客
06-03 4045
该内容主要涉及位图文件结构以及位图存储时的四字节对齐两个重点。两个重点之后给出BYTE数组保存为8位位图的c++ code。 如想直接查阅代码可以跳过1、2部分，直接查看第3部分。 本文主要参照如下五个博客，将内容综合整理以备查阅。 1）位图格式分析：https://blog.csdn.net/aidem_brown/article/details/80500637 https://blog.csdn.net/qq_31094099/ar...
C++实现对图像文件的放大、缩小、旋转、翻转、反色、灰度化、裁剪等功能
11-14
以下是C++实现对图像文件的放大、缩小、旋转、翻转、反色、灰度化、裁剪等功能的示例代码： ```c++ #include #include using namespace cv; using namespace std; int main() { // 读取图像文件 Mat img = ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值