图像处理(C++ CImage class)学习笔记

程序员文章站 2022-03-07 20:19:01

基础篇A. 图像三原色及灰度值A1. 彩色图像的三原色图像三原色— R：红色red— G：绿色green— B：蓝色blue三原色的取值范围：0（无）~255（满）— 红色：R=255 G=0 B=0— 紫色：R=112 G=48 B=160— 黑色：R=0 G=0 B=0— 黄色：R=255 G=255 B=0— 粉色：R=255 G=0 B=255A2. 灰度图像的灰度值灰度值（gray-scale value）：描述黑白图像点的颜色深度灰度值的取值范围：0（黑）~2...

基础篇

A. 图像三原色及灰度值

A1. 彩色图像的三原色

图像三原色
— R：红色red
— G：绿色green
— B：蓝色blue
三原色的取值范围：0（无）~255（满）
— 红色：R=255 G=0 B=0
— 紫色：R=112 G=48 B=160
— 黑色：R=0 G=0 B=0
— 黄色：R=255 G=255 B=0
— 粉色：R=255 G=0 B=255

A2. 灰度图像的灰度值

灰度值（gray-scale value）：描述黑白图像点的颜色深度
灰度值的取值范围：0（黑）~255（白）
— 黑色：Gray=0
— 深灰：Gray=100
— 浅灰：Gray=200
— 白色：Gray=255

A3. 用彩色图像表示灰度图像

当图像的R、G、B值相等时，彩色图像表现为灰度图像
— 深灰 Gray=100 —— R = 100， G = 100， B = 100
— 白色 Gray=255 —— R = 255， G = 255， B = 255

B. 数字图像的原理和表示方法

B1. 数字图像原理

图像处理(C++ CImage class)学习笔记

B2. 数字图像的表示方式

用(x, y)表示一个像素点的坐标，有的图像格式以左上角坐标为(0, 0)，有的图像格式以左下角坐标为(0, 0)
用两重循环可以遍历访问数字图像的每一个像素点

C. 数字图像的分辨率和位深度

C1. 图像的重要参数

空间分辨率：图像在水平和垂直方向的像素个数，值越大图像越清晰
位深度：用来表示一个像素点颜色的位数(bit)，值越大图像的颜色区分度越好

C2. 位深度

彩色图像的位深度
— 16位（不常用），用2个字节表示一个像素点的RGB值
— 24位，用3个字节表示一个像素点的RGB值
— 32位，额外的1个字节表示透明度Alpha值
灰度图像的位深度
— 8位，用1个字节表示一个像素点的灰度值

案例
图像处理(C++ CImage class)学习笔记
（空间）分辨率：726*461
宽度：726像素
高度：461像素
位深度：24

C3. 空间分辨率与数字图像的质量

图像处理(C++ CImage class)学习笔记

C4. 位深度与数字图像的质量

24位深度可以表示2^24=16777216种不同的颜色
8位深度可以表示2^8=256种不同的颜色
1位深度可以表示2^1=2种不同的颜色

C5. 数字图像根据位深度的分类

二值图像（1位）
灰度图像（8位）
彩色图像（16/24/32位）

C5.1 二值图像（1位）

像素值为0（黑色）或1（白色）。

C5.2 灰度图像（8位）

灰度取值范围是0~255，黑色为0，白色为255

C5.3 彩色图像（24位）

每个像素由RGB三个分量构成，取值范围是0~255
如果一个像素的R、G、B值相同，则该像素等同于灰度图像中的像素
例如：R=G=B=100，表示灰度为100的像素点

C5.4 灰度图像和彩色图像的转换
彩色图像(R，G，B)转换成灰度图像
Gray = R * 0.299 + G * 0.587 + B * 0.114
灰度图像转换成彩色图像
— 灰度图像不可能变换为原来的彩色图像
— 伪彩色处理可用于把灰度值映射成彩色的RGB值，例如在宇宙星空图片上的应用

D. C++ CImage class

D1. C++ CImage类概述

支持jpg、bmp、png、gif格式图像文件的读写和操作，可以转换成不同的文件格式
参考：https://docs.microsoft.com/zh-cn/cpp/atl-mfc-shared/reference/cimage-class

CImage类常用方法
图像处理(C++ CImage class)学习笔记
使用CImage类的一般方法

添加CImage类的包含方法：#include<atlimage.h>
定义一个CImage类对象，然后调用CImage::Load方法装载一个外部图像文件
根据题目要求处理图像
调用CImage::Save方法保存图像

如果atlimage.h编译报错提示不存在

检查C++ ATL for xxx是否安装，下图是VS2019的界面

D2. COLORREF类

COLORREF类(color reference)，表示颜色值(RGB)，实际上是unsigned long类型
从COLORREF类获取红绿蓝三原色的方法
— 红色：int GetRValue(COLORREF &)
— 绿色：int GetGValue(COLORREF &)
— 蓝色：int GetBValue(COLORREF &)
— 返回值是0~255之间的整数
利用红绿蓝三原色生成COLORREF类的方法
— COLORREF RGB(int R, int G, int B)

COLORREF类应用

例：某个像素点的RGB值分别为r、g、b，定义颜色类对象c存储RGB值
COLORREF c = RGB(r, g, b);
例：已知某点用颜色类对象c存储RGB值，求其中的R、G、B值分别为多少？
BYTE b = GetBValue(c）;
BYTE g = GetGValue(c）;
BYTE r = GetRValue(c）;

D3. BYTE类

BYTE类，通常用来表示一个0~255之间的整数，实际上是unsigned char类型

E. 案例

E1. 把图像中所有红色的点改成绿色

图像处理(C++ CImage class)学习笔记
分析：

并不是所有的红点都是纯红(255,0,0)
如何确定某些点偏红？
R>G && R>B
如何把偏红的点变成变绿的点？
方法一：设置为(0,255,0)
方法二：swap(R,G)

流程：

读图片（要先把源图片放到读路径下）
根据图片宽度和高度开两重循环
①读取指定坐标的像素点颜色
②如果颜色中红色分量最大，则红色与绿色交换
③设置指定坐标的像素点颜色
保存图片

代码：

#include<iostream>
#include<atlimage.h>//添加CImage类

void swap(BYTE& a, BYTE& b)//交换函数
{
	BYTE temp;
	temp = a;
	a = b;
	b = temp;
}

void redToGreen(COLORREF& c)//E1:把图像中所有红色的点改成绿色
{
	//获取c中RGB的值
	BYTE r = GetRValue(c);//获取c中R的值
	BYTE g = GetGValue(c);//获取c中G的值
	BYTE b = GetBValue(c);//获取c中B的值
	//如果红色分量更大，则与绿色交换
	if (r > g && r > b)
	{
		swap(r, g);//调用交换函数
	}

	c = RGB(r, g, b);//c中存储交换后的rgb值
}

int main()
{
	//1 读取与保存图像路径
	LPCTSTR srcFilePath = _T("1a.jpg");//源图像路径
	LPCTSTR destFilePath = _T("1b.jpg");//目标图像路径

	//2 加载图像
	CImage srcImage;//新建一个CImage类对象
	srcImage.Load(srcFilePath);//从源图像路径中加载图像

	//3 获取图像的高和宽
	int width, high;
	width = srcImage.GetWidth();//获取图像的宽度
	high = srcImage.GetHeight();//获取图像的高度

	//4 遍历整个图像的像素点，获取整个图像
	for (int x = 0; x < width; x++)//遍历x轴
	{
		for (int y = 0; y < high; y++)//遍历y轴
		{
			COLORREF c = srcImage.GetPixel(x, y);//新建一个COLORREF类对象，用来存储得到的图像像素点颜色
			redToGreen(c);//调用E1函数，处理颜色
			srcImage.SetPixel(x, y, c);//设置图像像素点的颜色
		}
	}

	//6 保存图像到指定路径
	srcImage.Save(destFilePath);

	return 0;
}

E2. 把彩色图像修改成灰色图像

图像处理(C++ CImage class)学习笔记
分析：

通用的彩色转灰度公式
— Gray = R * 0.299 + G * 0.587 + B * 0.114
可以把图像中每个点的R、G、B值，都分别设置为该点用上述公式计算出的Gray值，则彩色图像变为灰度图像

流程

读图片（要先把源图片放到读路径下）
根据图片宽度和高度开两重循环
①读取指定坐标的像素点颜色
②计算灰度值，并将RGB值都赋值为该灰度值
③设置指定坐标的像素点颜色
保存图片

代码：

#include<iostream>
#include<atlimage.h>

void colorToGray(COLORREF& c)//E2:把彩色图像修改成灰度图像
{
	BYTE r = GetRValue(c);
	BYTE g = GetGValue(c);
	BYTE b = GetBValue(c);
	BYTE gray = r * 0.299 + g * 0.587 + b * 0.114;//彩色转灰度图像公式

	c = RGB(gray, gray, gray);//c中存储转换后的灰度值
}

int main()
{
	LPCTSTR srcFilePath = _T("1a.jpg");
	LPCTSTR destFilePath = _T("3c.jpg");

	CImage srcImage;
	srcImage.Load(srcFilePath);

	int width, high;
	width = srcImage.GetWidth();
	high = srcImage.GetHeight();

	for (int x = 0; x < width; x++)
	{
		for (int y = 0; y < high; y++)
		{
			COLORREF c = srcImage.GetPixel(x, y);
			colorToGray(c);//调用E2函数，处理颜色
			srcImage.SetPixel(x, y, c);
		}
	}

	srcImage.Save(destFilePath);

	return 0;
}

E3. 反色

图像处理(C++ CImage class)学习笔记
分析：

对于某个点的颜色(R, G, B)而言，对应的反色是(255-R, 255-G, 255-B)

流程：

读图片（要先把源图片放到读路径下）
根据图片宽度和高度开两重循环
①读取指定坐标的像素点颜色(R, G, B)
②把(255-R, 255-G, 255-B)赋值为该点反色值
③设置指定坐标的像素点颜色
保存图片

代码:

#include<iostream>
#include<atlimage.h>

void invertColor(COLORREF& c)//E3:反色
{
	BYTE r = GetRValue(c);
	BYTE g = GetGValue(c);
	BYTE b = GetBValue(c);

	c = RGB(255 - r, 255 - g, 255 - b);//对该像素点的rgb值进行反色处理
}

int main()
{
	LPCTSTR srcFilePath = _T("1a.jpg");
	LPCTSTR destFilePath = _T("4d.jpg");

	CImage srcImage;
	srcImage.Load(srcFilePath);

	int width, high;
	width = srcImage.GetWidth();
	high = srcImage.GetHeight();

	for (int x = 0; x < width; x++)
	{
		for (int y = 0; y < high; y++)
		{
			COLORREF c = srcImage.GetPixel(x, y);
			invertColor(c);//调用E3函数，处理颜色
			srcImage.SetPixel(x, y, c);
		}
	}

	srcImage.Save(destFilePath);

	return 0;
}

E4. 左右颠倒图像

图像处理(C++ CImage class)学习笔记
方法一
分析：

获取源图像的像素点颜色后，新建一个CImage类对象作为目标图像，以免直接修改了源图片，导致重叠
左右颠倒相当于获取颜色从左到右，设置颜色从右到左（x轴正方向开始到负方向开始）

流程：

读图片（要先把源图片放到读路径下）
根据图片宽度和高度开两重循环
①获取指定坐标的像素点颜色(R, G, B)
②把获取的指定坐标像素点颜色设置为目标图像从x轴负方向开始的像素点颜色（获取x = 0，设置x = width - x - 1）（-1的原因是因为循环从0开始）
保存图片

代码：

#include<iostream>
#include<atlimage.h>

int main()
{
	LPCTSTR srcFilePath = _T("11a.jpg");
	LPCTSTR destFilePath = _T("22b.jpg");

	CImage srcImage;//创建源图像的对象
	CImage srcImage2;//创建目标图像的对象
	srcImage.Load(srcFilePath);//加载srcImage的源图像
	srcImage2.Load(srcFilePath);//加载srcImage2的源图像

	int width, high;
	width = srcImage.GetWidth();
	high = srcImage.GetHeight();

	for (int x = 0; x < width; x++)
	{
		for (int y = 0; y < high; y++)
		{
			COLORREF c = srcImage.GetPixel(x, y);//从源图像中获取像素点的颜色
			
			srcImage2.SetPixel(width - x - 1, y, c);//从x负方向设置目标图像的像素点的颜色
		}
	}

	srcImage2.Save(destFilePath);//保存目标图像

	return 0;
}

方法二
分析：

图像x轴最左端坐标（x, y）和x轴右端坐标（width - x - 1, y）互换
高度一样，y轴不变

流程：

读图片（要先把源图片放到读路径下）
根据图片宽度和高度开两重循环
①获取指定坐标的像素点颜色(R, G, B)
②定义一个新COLORREF对象c1
③将c和c1的像素点颜色交换
保存图片

代码：

#include<iostream>
#include<atlimage.h>

int main()
{
	LPCTSTR srcFilePath = _T("11a.jpg");
	LPCTSTR destFilePath = _T("222b.jpg");

	CImage srcImage;
	srcImage.Load(srcFilePath);

	int width, high;
	width = srcImage.GetWidth();
	high = srcImage.GetHeight();

	for (int x = 0; x < width / 2; x++)//除以2，互换一半即可，若不除以2会导致又重新互换回去
	{
		for (int y = 0; y < high; y++)//高度不变，高度需一直遍历
		{
			COLORREF c = srcImage.GetPixel(x, y);//从源图像中获取像素点的颜色
			COLORREF c1 = srcImage.GetPixel(width - x - 1, y);//创建一个新COLORREF对象，用于从源图像x轴最右端获取指定坐标像素点的颜色

			srcImage.SetPixel(x, y, c1);//将x轴左边图像像素点的颜色换成x轴右边图像像素点的颜色
			srcImage.SetPixel(width - x - 1, y, c);//将x轴右边图像像素点的颜色换成x轴左边图像像素点的颜色
		}	
	}

	srcImage.Save(destFilePath);

	return 0;
}

进阶篇–1

A. 图像的快速读写访问

A1. 图像读写存在的问题

GetPixel和SetPixel的速度太慢，处理大图时耗时太长
解决方案：利用GetBits方法，获取图像的首字节地址，通过指针访问图像的颜色信息

A2. 图像文件在内存中的存储格式

以24位深度Top-down图像为例

Top-down和Button-up
图像在内存中的两种不同格式
Top-down：图像的缓冲区从顶层行的像素开始，图像的底层行是图像缓冲区的最后一行
Buttom-up：图像的缓冲区从底层行的像素开始，图像的顶层行是图像缓冲区的最后一行

CImage类快速读写常用方法

GetBPP()：返回图像位深度，常见的24位jpg图片的返回值是24
GetPitch()：图像一行的字节数，对于Top-down类型图片，值是正的；对于Buttom-up类型图片，值是负的
GetBits()：返回指向图像左上角像素点的指针（无论是Top-down还是Buttom-up）

A3. 使用GetBits的细节问题

函数原型
void * CImage::GetBits()
如何访问图像(x,y)坐标像素点的颜色？
— 即第y行第x列像素点，假设图像CImage类对象是img
— 需要利用GetBits、GetPitch、GetBPP这三个方法的返回值
— Top-Down图像和Buttom-Up图像一样有效

int bpp = img.GetBPP();
int pitch = img.GetPitch();
BYTE *pData = (BYTE *)img.GetBits();
BYTE b = *(pData + y * pitch + x * bpp / 8 + 0);
BYTE g = *(pData + y * pitch + x * bpp / 8 + 1);
BYTE r = *(pData + y * pitch + x * bpp / 8 + 2);

注意：同一个像素点的三原色分量在内存中存放的顺序是B、G、R
通过指针访问，也可以修改颜色，这样就取代了GetPixel和SetPixel

A4. 使用快速读写把彩色图片变成灰度图片

图像处理(C++ CImage class)学习笔记
分析：

600多万像素的图片，如果使用GetPixel和SetPixel方法，需要82秒时间（不同电脑不一样）才能处理完所有像素点。使用图像指针将把运行时间降低至640毫秒。（同一台计算机上运行）

流程：

读图片（要先把源图片放到读路径下）
根据图片宽度和高度开两重循环
①通过指针访问图像(x,y)坐标像素点的颜色RGB值
②通过公式计算灰度值
③对指针指向的值进行赋值，从而改变源图像
保存图片

代码：

#include<iostream>
#include<atlimage.h>

int main()
{
	//1 获取和设置图像
	LPCTSTR srcFilePath = _T("3.jpg");
	LPCTSTR destFilePath = _T("3c.jpg");
	//2 加载图像
	CImage srcImage;
	srcImage.Load(srcFilePath);
	//3 获取图像的宽度和高度
	int width, high;
	width = srcImage.GetWidth();
	high = srcImage.GetHeight();
	//4 得到位深度和一行字节数
	int bpp = srcImage.GetBPP();//获取图像像素点的位数;bpp / 8 获取像素点的字节数
	int pitch = srcImage.GetPitch();//获取一行的字节数
	//5 获取首字节地址
	BYTE* pData = (BYTE*)srcImage.GetBits();//获取图像首字节的地址
	//6 遍历图像
	for (int x = 0; x < width; x++)
	{
		for (int y = 0; y < high; y++)
		{
			//通过指针访问图像(x,y)坐标像素点的颜色RGB值，相邻两个像素点之间相差3个字节
			BYTE b = *(pData + y * pitch + x * bpp / 8 + 0);//指针访问像素点颜色的B值
			BYTE g = *(pData + y * pitch + x * bpp / 8 + 1);//指针访问像素点颜色的G值
			BYTE r = *(pData + y * pitch + x * bpp / 8 + 2);//指针访问像素点颜色的R值

			BYTE gray = r * 0.299 + g * 0.587 + b * 0.114;//彩色转灰度图像公式
			//对指针指向的值进行赋值，从而改变源图像
			*(pData + y * pitch + x * bpp / 8 + 0) = gray;
			*(pData + y * pitch + x * bpp / 8 + 1) = gray;
			*(pData + y * pitch + x * bpp / 8 + 2) = gray;
		}	
	}

	srcImage.Save(destFilePath);

	return 0;
}

B. 图像缩放

改变图像的分辨率

图像缩放的步骤：

调用Create函数创建一张缩放后尺寸的新图
调用SetStretchBltMode函数设置清晰的缩放模式
调用Draw函数或者StretchBlt函数把源图Src的数据缩放写入新图Dest中
调用Save函数保存图片

代码：

#include<iostream>
#include<atlimage.h>

void getBGR(int x, int y, int bpp, int pitch, BYTE* pData)//获取图像像素点颜色的函数
{
	BYTE b = *(pData + y * pitch + x * bpp / 8 + 0);
	BYTE g = *(pData + y * pitch + x * bpp / 8 + 1);
	BYTE p = *(pData + y * pitch + x * bpp / 8 + 2);
}

int main()
{
	LPCTSTR srcFilePath = _T("3.jpg");
	LPCTSTR destFilePath = _T("4.jpg");

	CImage srcImage;//创建源图像
	CImage destImage;//创建目标图像
	srcImage.Load(srcFilePath);

	int width, high;
	width = srcImage.GetWidth();
	high = srcImage.GetHeight();
	
	int bpp, pitch;
	bpp = srcImage.GetBPP();
	pitch = srcImage.GetPitch();

	BYTE* pData = (BYTE*)srcImage.GetBits();
	//1 调用Create函数创建一张缩放后尺寸的新图
	destImage.Create(width / 2, high / 2, bpp);//宽度，高度，位深度；创建的目标图片的大小和位深度
	//2 调用SetStretchBltMode函数设置清晰的缩放模式
	SetStretchBltMode(destImage.GetDC(), COLORONCOLOR);//COLORONCOLOR——清晰模式；GetDC()——关联srcImage和destImage两个图像的数据
	destImage.ReleaseDC();//释放一下(因为有GetDC)
	//3 调用Draw函数或者StretchBlt函数把源图Src的数据缩放写入新图Dest中
	srcImage.Draw(destImage.GetDC(), 0, 0, width / 2, high / 2);//填充数据：目标图像的填充位置与大小
	destImage.ReleaseDC();//释放一下(因为有GetDC)
	//4 调用Save函数保存图片
	destImage.Save(destFilePath);

	return 0;
}

注意事项：

每次用GetDC，都要ReleaseDC，否则会报错
使用Create创建图像，需要指定宽度、高度和深度
COLORONCOLOR模式保证图像缩放时不会产生失真，必须写在Draw函数之前
Draw函数或者StretchBlt函数
— 第1个参数表示目标图像的句柄（handle）
— 第2~5个参数分别表示目标图像左上角的x轴坐标、y轴坐标、目标图像的宽度、高度，即定义了要把源图像写到目标图像的哪一块位置
— 第6~9个参数分别表示源图像左上角的x轴坐标、y轴坐标、源图像的宽度、高度，即定义了要把源图像的哪一块内容写到目标图像中。默认值是写整张源图像

C. 图像截取

把图像中的一部分内容保存成另一幅图

图像截取的步骤：

调用Create函数创建一张新图
调用Draw函数把源图src的部分数据写入新图dest中
调用Save函数保存图片

代码：

#include<iostream>
#include<atlimage.h>

void getBGR(int x, int y, int bpp, int pitch, BYTE* pData)
{
	BYTE b = *(pData + y * pitch + x * bpp / 8 + 0);
	BYTE g = *(pData + y * pitch + x * bpp / 8 + 1);
	BYTE p = *(pData + y * pitch + x * bpp / 8 + 2);
}

int main()
{
	LPCTSTR srcFilePath = _T("3.jpg");
	LPCTSTR destFilePath = _T("5.jpg");

	CImage srcImage;
	CImage destImage;
	srcImage.Load(srcFilePath);

	int width, high;
	width = srcImage.GetWidth();
	high = srcImage.GetHeight();
	
	int bpp, pitch;
	bpp = srcImage.GetBPP();

	//1 调用Create函数创建一张新图
	destImage.Create(width / 2, high / 2, bpp);
	//2 调用Draw函数把源图src的部分数据写入新图dest中
	srcImage.Draw(destImage.GetDC(), 0, 0, width / 2, high / 2, width / 4, high / 8, width / 2, high / 2);
	//前四个参数表示：填充到目标图像的哪个位置以及填充的大小；后四个参数表示：从源图像哪个位置开始截取以及截取的大小
	destImage.ReleaseDC();
	//3 调用Save函数保存图片
	destImage.Save(destFilePath);

	return 0;
}

D. 图像拼接

把多张图片拼接在一起，形成一张新图

图片拼接的步骤：

调用Create函数创建一张能够放得下拼接后图像大小的新图
调用Draw函数多次将原图数据写入到新图中合适的位置，实现图像拼接
调用Save函数保存图片

代码：

#include<iostream>
#include<atlimage.h>

void getBGR(int x, int y, int bpp, int pitch, BYTE* pData)
{
	BYTE b = *(pData + y * pitch + x * bpp / 8 + 0);
	BYTE g = *(pData + y * pitch + x * bpp / 8 + 1);
	BYTE p = *(pData + y * pitch + x * bpp / 8 + 2);
}

int main()
{
	LPCTSTR srcFilePath = _T("5.jpg");
	LPCTSTR destFilePath = _T("6.jpg");

	CImage srcImage;
	CImage destImage;
	srcImage.Load(srcFilePath);

	int width, high;
	width = srcImage.GetWidth();
	high = srcImage.GetHeight();
	
	int bpp, pitch;
	bpp = srcImage.GetBPP();

	//1 调用Create函数创建一张新图
	destImage.Create(width * 2, high, bpp);
	//2 调用Draw函数把源图src的部分数据写入新图dest中
	srcImage.Draw(destImage.GetDC(), 0, 0, width, high, 0, 0, width, high);//第一次截取并填充了左半部分
	destImage.ReleaseDC();
	srcImage.Draw(destImage.GetDC(), width, 0, width, high, 0, 0, width, high);//第二次截取并填充了右半部分，填充起始点发生变化
	destImage.ReleaseDC();
	//3 调用Save函数保存图片
	destImage.Save(destFilePath);

	return 0;
}

案例

E1. 分隔

把图片变成m行n列的图，要求彩色图像和灰度图像间隔。m和n由键盘输入。例如当m=4，n=5时：
图像处理(C++ CImage class)学习笔记
方法一
分析：

用两层嵌套循环填充指定的行和列
寻找行与列的填充规律以及彩色图像和灰度图像的填充规律

流程：

调用Create函数创建一张和源图像大小相等的新图
先判断总列数是奇数还是偶数，再判断当前列数和行数的奇偶
调用Draw函数多次将原图数据写入到新图中合适的位置，实现图像拼接
调用Save函数保存图片

代码：

#include<iostream>
#include<atlimage.h>

void colorToGray(int x, int y, int bpp, int pitch, BYTE* pData)
{
	BYTE b = *(pData + y * pitch + x * bpp / 8 + 0);
	BYTE g = *(pData + y * pitch + x * bpp / 8 + 1);
	BYTE r = *(pData + y * pitch + x * bpp / 8 + 2);

	BYTE gray = r * 0.299 + g * 0.587 + b * 0.114;
	*(pData + y * pitch + x * bpp / 8 + 0) = gray;
	*(pData + y * pitch + x * bpp / 8 + 1) = gray;
	*(pData + y * pitch + x * bpp / 8 + 2) = gray;
}

void traversal(int width, int high, int bpp, int pitch, BYTE* pData)
{
	for (int x = 0; x < width; x++)
	{
		for (int y = 0; y < high; y++)
		{
			colorToGray(x, y, bpp, pitch, pData);
		}
	}
}

int main()
{
	LPCTSTR srcFilePath = _T("5.jpg");
	LPCTSTR destFilePath = _T("5c.jpg");

	CImage srcImage, srcImage2;
	CImage destImage;
	srcImage.Load(srcFilePath);
	srcImage2.Load(srcFilePath);
		
	int width, high;
	width = srcImage.GetWidth();
	high = srcImage.GetHeight();

	int bpp, pitch;
	bpp = srcImage.GetBPP();
	pitch = srcImage.GetPitch();

	BYTE* pData = (BYTE*)srcImage.GetBits();

	int m, n; std::cin >> m >> n;

	destImage.Create(width, high, bpp);
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (n % 2 != 0)//若总列数是奇数
			{
				if (j % 2 != 0 && i % 2 == 0)//若列数是奇数且行数为偶数，则位灰度图
				{
					traversal(width, high, bpp, pitch, pData);
					srcImage.Draw(destImage.GetDC(), (j * width) / n, (i * high) / m, width / n, high / m, 0, 0, width, high);
					destImage.ReleaseDC();
				}
				else if (j % 2 == 0 && i % 2 != 0)//若列数为偶数且行数为奇数，则为灰度图
				{
					traversal(width, high, bpp, pitch, pData);
					srcImage.Draw(destImage.GetDC(), (j * width) / n, (i * high) / m, width / n, high / m, 0, 0, width, high);
					destImage.ReleaseDC();
				}
				else//其他均为彩色图
				{
					srcImage2.Draw(destImage.GetDC(), (j * width) / n, (i * high) / m, width / n, high / m, 0, 0, width, high);
					destImage.ReleaseDC();
				}
			}
			else//若总列数是偶数
			{
				if (j % 2 != 0)//若列数是奇数
				{
					traversal(width, high, bpp, pitch, pData);
					srcImage.Draw(destImage.GetDC(), (j * width) / n, (i * high) / m, width / n, high / m, 0, 0, width, high);
					destImage.ReleaseDC();
				}
				else//若列数是偶数
				{
					srcImage2.Draw(destImage.GetDC(), (j * width) / n, (i * high) / m, width / n, high / m, 0, 0, width, high);
					destImage.ReleaseDC();
				}
			}
		}
	}

	destImage.Save(destFilePath);

	return 0;
}

方法二
分析：

用两层嵌套循环填充指定的行和列
寻找行与列的填充规律以及彩色图像和灰度图像的填充规律

流程：

调用Create函数创建一张和源图像大小相等的新图
判断行和列坐标之和是偶数还是奇数，偶数为彩色图，奇数为灰度图
调用Draw函数多次将原图数据写入到新图中合适的位置，实现图像拼接
调用Save函数保存图片

代码：

#include<iostream>
#include<atlimage.h>

int main()
{
	//获取和设置保存源图片和目标图像的路径
	LPCTSTR srcFilePath = _T("5.jpg");
	LPCTSTR destFilePath = _T("123.jpg");
	//创建类对象，源图像对象，灰度图对象，目标图像对象;加载源图像和灰度图
	CImage srcImage, grayImage, destImage;
	srcImage.Load(srcFilePath);
	grayImage.Load(srcFilePath); 
	//获取宽度、高度、位深度、一行字节数、首字节地址
	int width = grayImage.GetWidth();
	int high = grayImage.GetHeight();
	int bpp = grayImage.GetBPP();
	int pitch = grayImage.GetPitch();
	BYTE* pData = (BYTE*)grayImage.GetBits();
	//输入m行n列
	int m, n; std::cin >> m >> n;
	//将彩色图变为灰度图
	for (int x = 0; x < width; x++)
	{
		for (int y = 0; y < high; y++)
		{
			BYTE b = *(pData + y * pitch + x * bpp / 8 + 0);
			BYTE g = *(pData + y * pitch + x * bpp / 8 + 1);
			BYTE r = *(pData + y * pitch + x * bpp / 8 + 2);
			int gray = r * 0.299 + g * 0.587 + b * 0.114;
			*(pData + y * pitch + x * bpp / 8 + 0) = gray;
			*(pData + y * pitch + x * bpp / 8 + 1) = gray;
			*(pData + y * pitch + x * bpp / 8 + 2) = gray;
		}
	}
	//创建一个“存放”目标图像的新窗口
	destImage.Create(n * width, m * high, bpp);
	////按照输入的行和列遍历每个目标图像的位置
	for (int x = 0; x < m; x++)//行
	{
		for (int y = 0; y < n; y++)//列
		{
			if ((x + y) % 2 == 0)//如果“行+列”的坐标为偶数，绘制源图
			{
				srcImage.Draw(destImage.GetDC(), y * width, x * high, width, high, 0, 0, width, high);//从源图像中获取彩色像素点
				destImage.ReleaseDC();//释放
			}
			else//如果“行+列”的坐标为奇数，绘制灰度图
			{
				grayImage.Draw(destImage.GetDC(), y * width, x * high, width, high, 0, 0, width, high);//从灰度图中获取彩色像素点
				destImage.ReleaseDC();
			}
		}
	}

	destImage.Save(destFilePath);//保存目标图像到指定路径

	return 0;
}

E2. 平铺

将下图平铺成5000*5000分辨率的图像
图像处理(C++ CImage class)学习笔记
分析：

用两层嵌套循环填充计算最大的行和列
宽度和高度随着填充图像的个数而变化

流程：

调用Create函数创建一张分辨率为5000*5000的新图
用总宽度、高度除以一张目标图像的宽度、高度，计算出指定窗口的容纳量
调用Draw函数循环将原图数据写入到新图中合适的位置，实现图像拼接
调用Save函数保存图片

代码：

#include<iostream>
#include<atlimage.h>

int main()
{
	//读取和保存源图像和目标图像路径
	LPCTSTR srcFilePath = _T("5.jpg");
	LPCTSTR destFilePath = _T("56.jpg");
	//创建CImage类对象及加载图像
	CImage srcImage, destImage;
	srcImage.Load(srcFilePath);
	//获取图像的宽度、高度及位深度
	int width, high, bpp;
	width = srcImage.GetWidth();
	high = srcImage.GetHeight();
	bpp = srcImage.GetBPP();
	//创建一个目标图像窗口
	destImage.Create(5000, 5000, bpp);//创建一个分辨率为5000*5000的窗口
	//遍历图像
	for (int x = 0; x <= ceil(5000 / width); x++)//ceil()——取整函数
	{
		for (int y = 0; y <= ceil(5000 / high) + 1; y++)
		{
			srcImage.Draw(destImage.GetDC(), width * x, high * y, width, high, 0, 0, width, high);//目标图像的绘制位置随x，y（已填充个数）的变化而变化
			destImage.ReleaseDC();
		}
	}

	destImage.Save(destFilePath);

	return 0;
}

E3. 变色

将图中所有红色的花变成蓝色的花
图像处理(C++ CImage class)学习笔记
分析：

找出图中偏红的颜色
将红色R值与蓝色B值交换

步骤：

读图片（要先把源图片放到读路径下）
根据图片宽度和高度开两重循环
①通过指针访问图像(x,y)坐标像素点的颜色RGB值
②判断偏红的像素点
③对指针指向的值进行赋值，从而改变源图像，交换红色和蓝色
保存图片

代码：

#include<iostream>
#include<atlimage.h>

void colorChange(int width, int high, int bpp, int pitch, BYTE* pData)//变色函数
{
	for (int x = 0; x < width; x++)
	{
		for (int y = 0; y < high; y++)
		{
			//获取每个坐标像素点的颜色
			BYTE b = *(pData + y * pitch + x * bpp / 8 + 0);
			BYTE g = *(pData + y * pitch + x * bpp / 8 + 1);
			BYTE r = *(pData + y * pitch + x * bpp / 8 + 2);
			
			if (r > g && r > b)//偏红的像素点
			{
				//R值和B值交换
				*(pData + y * pitch + x * bpp / 8 + 0) = r;
				*(pData + y * pitch + x * bpp / 8 + 1) = g;
				*(pData + y * pitch + x * bpp / 8 + 2) = b;
			}
		}
	}
}

int main()
{
	LPCTSTR srcFilePath = _T("Flower.jpg");
	LPCTSTR destFilePath = _T("Flower2.jpg");

	CImage srcImage;
	srcImage.Load(srcFilePath);

	int width, high;
	width = srcImage.GetWidth();
	high = srcImage.GetHeight();

	int bpp, pitch;
	bpp = srcImage.GetBPP();
	pitch = srcImage.GetPitch();

	BYTE* PData = (BYTE*)srcImage.GetBits();

	colorChange(width, high, bpp, pitch, PData);
	
	srcImage.Save(destFilePath);

	return 0;
}

进阶篇–2

A. RGB和HSV

像素颜色的两种表示方式

RGB：使用红、绿、蓝三种颜色表示，范围都在0~255之间
HSV：
— H：色度，取值范围[0,360)
— S：饱和度，取值范围[0,1]
— V：亮度，取值范围]0,1]

RGB到HSV的转换公式

图像处理(C++ CImage class)学习笔记

HSV到RGB的转换公式

图像处理(C++ CImage class)学习笔记

HSV和RGB使用的类

图像处理(C++ CImage class)学习笔记

B. 两个转换函数

RGB到HSV转换函数

函数声明：
HSV RGB2HSV(COLORREF c)

函数功能：
把COLORREF类对象c的颜色信息转换成一个HSV类对象返回。

代码：

#include<iostream>
#include<atlimage.h>
#include<cmath>
#include<algorithm>

//RGB->HSV
class HSV//HSV类
{
public:
	double H, S, V;//定义成员变量
	HSV() {}//无参构造函数
	HSV(double h, double s, double v) :H(h), S(s), V(v) {}//有参构造函数且初始化
};

HSV RGB2HSV(COLORREF c)//RGB至HSV转换函数
{
	//从COLORREF类对象c中获取颜色RGB值
	BYTE R = GetRValue(c);
	BYTE G = GetGValue(c);
	BYTE B = GetBValue(c);
	double H, S, V;
	//转换公式
	R = R / 255, G = G / 255, B = B / 255;
	V = max(R, G, B);
	
	if (V != 0)
	{
		S = (V - min(R, G, B)) / V;
		if (V = R)
		{
			H = (60 * (G - B)) / V - min(R, G, B);
			if (H < 0)
			{
				H = H + 360;
				return HSV(H, S, V);
			}
			return HSV(H, S, V);
		}
		if (V = G)
		{
			H = 120 + ((60 * (B - R)) / (V - min(R, G, B)));
			if (H < 0)
			{
				H = H + 360;
				return HSV(H, S, V);
			}
			return HSV(H, S, V);
		}
		if (V = B)
		{
			H = 240 + ((60 * (R - G)) / (V - min(R, G, B)));
			if (H < 0)
			{
				H = H + 360;
				return HSV(H, S, V);
			}
			return HSV(H, S, V);
		}
	}
	else//V = 0，此时RGB均为0
	{
		S = 0;
		H = 0;

		return HSV(H, S, V);
	}
}

HSV到RGB转换函数

函数声明：
COLORREF HSV2RGB(HSV hsv)

函数功能：
把HSV类对象hsv的颜色信息转换成一个COLORREF类对象返回。

代码：

//HSV->RGB
COLORREF HSV2RGB(HSV hsv)
{
	//定义变量
	BYTE R, G, B;
	double H, S, V;
	H = hsv.H;
	S = hsv.S;
	V = hsv.V;
	//转换公式
	double C, X, m;
	C = V * S;
	X = C * (1 - (abs(((int)H / 60) % 2 - 1)));
	m = V - C;

	if (H >= 0 && H < 60)
	{
		R = C;
		G = X;
		B = 0;

		R = (R + m) * 255;
		G = (G + m) * 255;
		B = (B + m) * 255;
		//返回COLORREF类型的值
		COLORREF c;
		c = RGB(R, G, B);
		return c;
	}
	if (H >= 60 && H < 120)
	{
		R = X;
		G = C;
		B = 0;

		R = (R + m) * 255;
		G = (G + m) * 255;
		B = (B + m) * 255;
		//返回COLORREF类型的值
		COLORREF c;
		c = RGB(R, G, B);
		return c;
	}
	if (H >= 120 && H < 180)
	{
		R = 0;
		G = C;
		B = X;

		R = (R + m) * 255;
		G = (G + m) * 255;
		B = (B + m) * 255;
		//返回COLORREF类型的值
		COLORREF c;
		c = RGB(R, G, B);
		return c;
	}
	if (H >= 180 && H < 240)
	{
		R = 0;
		G = X;
		B = C;

		R = (R + m) * 255;
		G = (G + m) * 255;
		B = (B + m) * 255;
		//返回COLORREF类型的值
		COLORREF c;
		c = RGB(R, G, B);
		return c;
	}
	if (H >= 240 && H < 300)
	{
		R = X;
		G = 0;
		B = C;

		R = (R + m) * 255;
		G = (G + m) * 255;
		B = (B + m) * 255;
		//返回COLORREF类型的值
		COLORREF c;
		c = RGB(R, G, B);
		return c;
	}
	if (H >= 300 && H < 360)
	{
		R = C;
		G = 0;
		B = X;

		R = (R + m) * 255;
		G = (G + m) * 255;
		B = (B + m) * 255;
		//返回COLORREF类型的值
		COLORREF c;
		c = RGB(R, G, B);
		return c;
	}
}
/*
提取信息：HSV——对象名.成员函数
		 RGB——GetRVaule(对象名)
*/

本文地址：https://blog.csdn.net/Zixz99/article/details/107189720

上一篇： webrtc windows 编译

下一篇： vue播放直播流

图像处理(C++ CImage class)学习笔记

基础篇

A. 图像三原色及灰度值

A1. 彩色图像的三原色

A2. 灰度图像的灰度值

A3. 用彩色图像表示灰度图像

B. 数字图像的原理和表示方法

B1. 数字图像原理

B2. 数字图像的表示方式

C. 数字图像的分辨率和位深度

C1. 图像的重要参数

C2. 位深度

C3. 空间分辨率与数字图像的质量

C4. 位深度与数字图像的质量

C5. 数字图像根据位深度的分类

D. C++ CImage class

D1. C++ CImage类概述

D2. COLORREF类

D3. BYTE类

E. 案例

E1. 把图像中所有红色的点改成绿色

E2. 把彩色图像修改成灰色图像

E3. 反色

E4. 左右颠倒图像

进阶篇–1

A. 图像的快速读写访问

A1. 图像读写存在的问题

A2. 图像文件在内存中的存储格式

A3. 使用GetBits的细节问题

A4. 使用快速读写把彩色图片变成灰度图片

B. 图像缩放

C. 图像截取

D. 图像拼接

案例

E1. 分隔

E2. 平铺

E3. 变色

进阶篇–2

A. RGB和HSV

像素颜色的两种表示方式

RGB到HSV的转换公式

HSV到RGB的转换公式

HSV和RGB使用的类

B. 两个转换函数

RGB到HSV转换函数

HSV到RGB转换函数

C++学习笔记之浅谈异常处理