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

基础篇

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)学习笔记_第1张图片
图像处理(C++ CImage class)学习笔记_第2张图片

B2. 数字图像的表示方式

  • 用(x, y)表示一个像素点的坐标,有的图像格式以左上角坐标为(0, 0),有的图像格式以左下角坐标为(0, 0)
  • 用两重循环可以遍历访问数字图像的每一个像素点
    图像处理(C++ CImage class)学习笔记_第3张图片

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

C1. 图像的重要参数

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

C2. 位深度

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

案例
图像处理(C++ CImage class)学习笔记_第4张图片
(空间)分辨率:726*461
宽度:726像素
高度:461像素
位深度:24

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

图像处理(C++ CImage class)学习笔记_第5张图片

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

  • 24位深度可以表示2^24=16777216种不同的颜色
  • 8位深度可以表示2^8=256种不同的颜色
  • 1位深度可以表示2^1=2种不同的颜色
    图像处理(C++ CImage class)学习笔记_第6张图片

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

  • 二值图像(1位)
  • 灰度图像(8位)
  • 彩色图像(16/24/32位)

C5.1 二值图像(1位)

  • 像素值为0(黑色)或1(白色)。
    图像处理(C++ CImage class)学习笔记_第7张图片

C5.2 灰度图像(8位)

  • 灰度取值范围是0~255,黑色为0,白色为255
    图像处理(C++ CImage class)学习笔记_第8张图片

C5.3 彩色图像(24位)

  • 每个像素由RGB三个分量构成,取值范围是0~255

  • 如果一个像素的R、G、B值相同,则该像素等同于灰度图像中的像素
    例如:R=G=B=100,表示灰度为100的像素点
    图像处理(C++ CImage class)学习笔记_第9张图片
    C5.4 灰度图像和彩色图像的转换

  • 彩色图像(R,G,B)转换成灰度图像
    Gray = R * 0.299 + G * 0.587 + B * 0.114

  • 灰度图像转换成彩色图像
    — 灰度图像不可能变换为原来的彩色图像
    — 伪彩色处理可用于把灰度值映射成彩色的RGB值,例如在宇宙星空图片上的应用
    图像处理(C++ CImage class)学习笔记_第10张图片

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)学习笔记_第11张图片
使用CImage类的一般方法

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

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

  • 检查C++ ATL for xxx是否安装,下图是VS2019的界面
    图像处理(C++ CImage class)学习笔记_第12张图片

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)学习笔记_第13张图片
分析:

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

流程:

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

代码:

#include
#include//添加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)学习笔记_第14张图片
分析:

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

流程

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

代码:

#include
#include

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)学习笔记_第15张图片
分析:

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

流程:

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

代码:

#include
#include

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)学习笔记_第16张图片
方法一
分析:

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

流程:

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

代码:

#include
#include

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轴不变

流程:

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

代码:

#include
#include

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图像为例
    图像处理(C++ CImage class)学习笔记_第17张图片
    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)学习笔记_第18张图片
分析:

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

流程:

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

代码:

#include
#include

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. 图像缩放

  1. 改变图像的分辨率
    图像处理(C++ CImage class)学习笔记_第19张图片

图像缩放的步骤:

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

代码:

#include
#include

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. 图像截取

  • 把图像中的一部分内容保存成另一幅图
    图像处理(C++ CImage class)学习笔记_第20张图片

图像截取的步骤:

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

代码:

#include
#include

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. 图像拼接

  • 把多张图片拼接在一起,形成一张新图
    图像处理(C++ CImage class)学习笔记_第21张图片

图片拼接的步骤:

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

代码:

#include
#include

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)学习笔记_第22张图片
方法一
分析:

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

流程:

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

代码:

#include
#include

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;
}

方法二
分析:

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

流程:

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

代码:

#include
#include

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)学习笔记_第23张图片
分析:

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

流程:

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

代码:

#include
#include

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)学习笔记_第24张图片
分析:

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

步骤:

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

代码:

#include
#include

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]
    图像处理(C++ CImage class)学习笔记_第25张图片

RGB到HSV的转换公式

图像处理(C++ CImage class)学习笔记_第26张图片

HSV到RGB的转换公式

图像处理(C++ CImage class)学习笔记_第27张图片

HSV和RGB使用的类

图像处理(C++ CImage class)学习笔记_第28张图片

B. 两个转换函数

RGB到HSV转换函数

函数声明:
HSV RGB2HSV(COLORREF c)

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

代码:

#include
#include
#include
#include

//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(对象名)
*/

你可能感兴趣的:(图像处理(C++ CImage class)学习笔记)