对BMP图像进行5*5的卷积核运算

未完待续（源代码已完成，因为作业还没

结束，因此不便于上传源代码，后续会补

上的）....

#在做并行计算的时候有这么一个作业

从bmp图片文件中读取图像像素数据，使用5×5的卷积核，步长为1，对该图像进行卷积运算，MPI并行实现图像卷积过程。请同学们认真查看附件，明确要求。

要求：

1. 将卷积核和卷积后的像素矩阵输出到文本文档以供验证。

2. 计算程序并行部分的运行时间！！在该程序段首尾加入返回时间戳的函数并显示各个核的运算时间

3. 给出并行部分的整体运行时间并对比2核与4核的并行加速比与效率。

4. 写一份实验报告说明实验思路，实验过程，创新和优化部分

5. 程序测试环境为linux

1. 卷积边缘点时，采用空白点按照0处理，对应于opencv的border_constant模式。

2. 卷积核统一使用5x5高斯卷积核。图片现场给定。宽度会是32的整数倍。

3. 结果允许与实际结果有绝对值为1的误差

卷积核是什么

卷积是图像处理常用的方法,给定输入图像,在输出图像中每一个像素是输入图像中一个小区域中像素的加权平均,其中权值由一个函数定义,这个函数称为卷积核,
比如说卷积公式:R(u，v)=∑∑G(u-i，v-j)f(i，j) ，其中f为输入，G为卷积核。

步长是什么

请参考下面文章里面的示例3

卷积如何计算

以下面的动态图通俗直观地来讲，底层的虚线矩阵就代表原始矩阵，阴影矩阵就代表卷积核，阴影矩阵每次移动一格，意思就是步长是1，上层的实线有颜色的矩阵就是输出矩阵，输出矩阵的每个元素的计算方法就如动态图所演示的

最好再参考一下这篇博文帮助理解计算原理（重点看后面的图片）以及填充边

数字图像处理：基本算法-卷积和相关

1、像素数量不变full,假定输入矩阵为x*x, 卷积核为m*m,则输出矩阵为（x-3+1+(3-1)）*（x-3+1+(3-1)），也就是x*x

2、假定输入矩阵为x*x, 假定输入矩阵为x*x, 卷积核为m*m,则输出矩阵为（x-3+1+(3-2)）*（x-3+1+(3-2)），也就是(x-1)*(x-1)

........

m、假定输入矩阵为x*x, 假定输入矩阵为x*x, 卷积核为m*m(3*3为例),则输出矩阵为（x-3+1+(3-3)）*（x-3+1+(3-3)），也就是(x-2)*(x-2)

高斯卷积核的生成（C/C++代码）

高斯公式如下

    

C++实现生成高斯核的代码

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
void gen_gs() {
	int i, j;
	double sigma = 1;
	const int N = 5;
	double gussian[N][N];
	double sum = 0.0;

	for (i = 0; i<N; i++)
	{
		for (j = 0; j<N; j++)
		{
			gussian[i][j] = exp(-((i - N / 2)*(i - N / 2) + (j - N / 2)*(j - N / 2)) / (2.0*sigma*sigma));
			sum += gussian[i][j];
		}
	}
	FILE *fp;
	fp = fopen("gs.txt", "w");
	for (i = 0; i<N; i++)
	{
		for (j = 0; j<N; j++)
		{
			gussian[i][j] /= sum;
			fprintf(fp,"%f ", gussian[i][j]);
		}
		fprintf(fp,"\n");
	}
}
int main() {
	gen_gs();
	return 0;
}

计算优化

用两个级联的3*3的卷积核来代替一个5*5的卷积核。(7*7的可以换成3重的3*3的)

具体的原理可以参考下面的知乎问答。

为什么一个5*5的卷积核可以用两个3*3的卷积核代替，一个7*7的卷积核可以用三个的3*3卷积核代替？

（建议初学者了解一下变形卷积核、可分离卷积？卷积神经网络中十大拍案叫绝的操作。这里对卷积的原理及其发展做了非常清楚的介绍）

使用一个5*5卷积核和两个级联的3*3卷积核的参数量和计算量的对比

参数对比

参数个数仅和卷积核大小相关

	5*5	两个级联的3*3
参数个数对比	5*5+1=26	（3*3+1）*2=20
		更少参数

计算量对比

输入记为x，为了方便讨论假设padding=0,stride=1。此时卷积计算公式 output =( input – kernel + 2padding) / stride + 1简化为output = input – kernel + 1。

• 5*5卷积：有(x-5+1)* (x-5+1)个输出点，每个输出点对应5*5次乘法和5*5次加法（5*5次乘法的结果求和再加上b，一共5*5+1个数相加，所以需要5*5次加法）
  
• 3*3卷积：第一个3*3卷积有(x-3+1)*(x-3+1)个输出点，每个输出点对应3*3次乘法和3*3次加法，第二个3*3卷积的输入是(x-3+1)*(x-3+1)，在其上做卷积有(x-3+1 -3+1)* (x-3+1-3+1)个输出点，每个输出点对应3*3次乘法和3*3次加法。

综上，当x<22/7 或者10<x ，两个3*3的卷积核在参数个数和计算量上都占优势。

在计算卷积的时候，特别是我这里是用来做BMP图像的卷积计算，x的值一般比较大，所以选择用两个级联的3*3的卷积核来代替5*5的卷积核

https://www.cnblogs.com/hejunlin1992/p/7624807.html

下面预计要写的东西有：

MPI并行编程（这个需要，但是不打算写了，因为主要是个人学习笔记，这部分已经学习过了，但更重要的是觉得自己并不足以写出比网上教程更好的介绍，就略了）

2018-4-30续

参考bmp文件格式解析BMP文件格式详解

BITMAPFILEHEADER fileHead;
fileHead.bfType = 0x4D42;//bmp类型

			//bfSize是图像文件4个组成部分之和
fileHead.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + colorTablesize + lineByte*height;

上面是BMP图像的C++代码格式的表示，可以看到一幅bmp图像分为：文件头、信息头、颜色表（仅灰度图像有）、像素值4个部分，我们最终需要读取的就是第4部分的数据信息。前面的BITMAPFILEHEADER和BITMAPINFOHEADER这是两个系统定义的结构体。结构体的定义我也顺便贴出来吧：

typedef struct tagBITMAPFILEHEADER {
        WORD    bfType;
        DWORD   bfSize;
        WORD    bfReserved1;
        WORD    bfReserved2;
        DWORD   bfOffBits;
} BITMAPFILEHEADER, FAR *LPBITMAPFILEHEADER, *PBITMAPFILEHEADER;

typedef struct tagBITMAPINFOHEADER{
        DWORD      biSize;
        LONG       biWidth;
        LONG       biHeight;
        WORD       biPlanes;
        WORD       biBitCount;
        DWORD      biCompression;
        DWORD      biSizeImage;
        LONG       biXPelsPerMeter;
        LONG       biYPelsPerMeter;
        DWORD      biClrUsed;
        DWORD      biClrImportant;
} BITMAPINFOHEADER, FAR *LPBITMAPINFOHEADER, *PBITMAPINFOHEADER;

下面是读取BMP图像并输出像素数据到文件，另外再将同一张图片的各个部分输出形成原图的一份拷贝的演示代码，以供参考

#define _CRT_SECURE_NO_WARNINGS

#include<math.h>
#include <iomanip> 
#include <stdlib.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
using namespace std;
//---------------------------------------------------------------------------------------
//以下该模块是完成BMP图像(彩色图像是24bit RGB各8bit)的像素获取，并存在文件名为xiang_su_zhi.txt中
unsigned char *pBmpBuf;//读入图像数据的指针

int bmpWidth;//图像的宽
int bmpHeight;//图像的高
RGBQUAD *pColorTable;//颜色表指针

int biBitCount;//图像类型，每像素位数 8-灰度图 24-彩色图

			   //-------------------------------------------------------------------------------------------
			   //读图像的位图数据、宽、高、颜色表及每像素位数等数据进内存，存放在相应的全局变量中
bool readBmp(char *bmpName)
{
	FILE *fp = fopen(bmpName, "rb");//二进制读方式打开指定的图像文件

	if (fp == 0)
		return 0;

	//跳过位图文件头结构BITMAPFILEHEADER

	fseek(fp, sizeof(BITMAPFILEHEADER), 0);

	//定义位图信息头结构变量，读取位图信息头进内存，存放在变量head中

	BITMAPINFOHEADER head;

	fread(&head, sizeof(BITMAPINFOHEADER), 1, fp); //获取图像宽、高、每像素所占位数等信息

	bmpWidth = head.biWidth;	//宽度用来计算每行像素的字节数

	bmpHeight = head.biHeight;  // 像素的行数

	biBitCount = head.biBitCount;//定义变量，计算图像每行像素所占的字节数（必须是4的倍数）
	int lineByte = (bmpWidth * biBitCount / 8 + 3) / 4 * 4;//灰度图像有颜色表，且颜色表表项为256 (可以理解为lineByte是对bmpWidth的以4为步长的向上取整)

	if (biBitCount == 8)
	{
		//申请颜色表所需要的空间，读颜色表进内存
		pColorTable = new RGBQUAD[256];
		fread(pColorTable, sizeof(RGBQUAD), 256, fp);
	}

	//申请位图数据所需要的空间，读位图数据进内存

	pBmpBuf = new unsigned char[lineByte * bmpHeight];
	cout << "lineByte" << lineByte << " bmpHeight" << bmpHeight << " bibitCount"<<biBitCount << endl;
	fread(pBmpBuf, 1, lineByte * bmpHeight, fp);

	fclose(fp);//关闭文件
	return 1;//读取文件成功
}

//-----------------------------------------------------------------------------------------
//给定一个图像位图数据、宽、高、颜色表指针及每像素所占的位数等信息,将其写到指定文件中
bool saveBmp(char *bmpName, unsigned char *imgBuf, int width, int height, int biBitCount, RGBQUAD *pColorTable)
{

	//如果位图数据指针为0，则没有数据传入，函数返回

	if (!imgBuf)
		return 0;

	//颜色表大小，以字节为单位，灰度图像颜色表为1024字节，彩色图像颜色表大小为0

	int colorTablesize = 0;

	if (biBitCount == 8)
		colorTablesize = 1024;//8*128

	//待存储图像数据每行字节数为4的倍数

	int lineByte = (width * biBitCount / 8 + 3) / 4 * 4;

	//以二进制写的方式打开文件

	FILE *fp = fopen(bmpName, "wb");

	if (fp == 0)
		return 0;

	//申请位图文件头结构变量，填写文件头信息

	BITMAPFILEHEADER fileHead;

	fileHead.bfType = 0x4D42;//bmp类型

							 //bfSize是图像文件4个组成部分之和阿

	fileHead.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + colorTablesize + lineByte*height;

	fileHead.bfReserved1 = 0;

	fileHead.bfReserved2 = 0;

	//bfOffBits是图像文件前3个部分所需空间之和

	fileHead.bfOffBits = 54 + colorTablesize;

	//写文件头进文件

	fwrite(&fileHead, sizeof(BITMAPFILEHEADER), 1, fp);

	//申请位图信息头结构变量，填写信息头信息

	BITMAPINFOHEADER head;

	head.biBitCount = biBitCount;

	head.biClrImportant = 0;

	head.biClrUsed = 0;

	head.biCompression = 0;

	head.biHeight = height;

	head.biPlanes = 1;

	head.biSize = 40;

	head.biSizeImage = lineByte*height;

	head.biWidth = width;

	head.biXPelsPerMeter = 0;

	head.biYPelsPerMeter = 0;

	//写位图信息头进内存

	fwrite(&head, sizeof(BITMAPINFOHEADER), 1, fp);

	//如果灰度图像，有颜色表，写入文件 

	if (biBitCount == 8)
		fwrite(pColorTable, sizeof(RGBQUAD), 256, fp);

	//写位图数据进文件

	fwrite(imgBuf, height*lineByte, 1, fp);

	//关闭文件

	fclose(fp);

	return 1;

}

//----------------------------------------------------------------------------------------
//以下为像素的读取函数
void doIt()
{

	//读入指定BMP文件进内存

	char readPath[] = "nx.BMP";

	readBmp(readPath);

	//输出图像的信息

	cout << "width=" << bmpWidth << " height=" << bmpHeight << " biBitCount=" << biBitCount << endl;

	//循环变量，图像的座标

	//每行字节数

	int lineByte = (bmpWidth*biBitCount / 8 + 3) / 4 * 4;

	//循环变量，针对彩色图像，遍历每像素的三个分量

	int m = 0, n = 0, count_xiang_su = 0;

	//将图像左下角1/4部分置成黑色

	ofstream outfile("图像像素.txt", ios::in | ios::trunc);

	if (biBitCount == 8) //对于灰度图像
	{
		//------------------------------------------------------------------------------------
		//以下完成图像的分割成8*8小单元，并把像素值存储到指定文本中。由于BMP图像的像素数据是从
		//左下角：由左往右，由上往下逐行扫描的
		int L1 = 0;
		int hang = 63;
		int lie = 0;
		//int L2=0;
		//int fen_ge=8;
		for (int fen_ge_hang = 0; fen_ge_hang<8; fen_ge_hang++)//64*64矩阵行循环
		{
			for (int fen_ge_lie = 0; fen_ge_lie<8; fen_ge_lie++)//64*64列矩阵循环
			{
				//--------------------------------------------
				for (L1 = hang; L1>hang - 8; L1--)//8*8矩阵行
				{
					for (int L2 = lie; L2<lie + 8; L2++)//8*8矩阵列
					{
						m = *(pBmpBuf + L1*lineByte + L2);
						outfile << m << " ";
						count_xiang_su++;
						if (count_xiang_su % 8 == 0)//每8*8矩阵读入文本文件
						{
							outfile << endl;
						}
					}
				}
				//---------------------------------------------
				hang = 63 - fen_ge_hang * 8;//64*64矩阵行变换
				lie += 8;//64*64矩阵列变换
						 //该一行（64）由8个8*8矩阵的行组成
			}
			hang -= 8;//64*64矩阵的列变换
			lie = 0;//64*64juzhen
		}
	}

	//double xiang_su[2048];
	//ofstream outfile("xiang_su_zhi.txt",ios::in|ios::trunc);
	if (!outfile)
	{
		cout << "open error!" << endl;
		exit(1);
	}
	else if (biBitCount == 24)
	{//彩色图像
		for (int i = 0; i<bmpHeight; i++)
		{
			for (int j = 0; j<bmpWidth; j++)
			{
				for (int k = 0; k<3; k++)//每像素RGB三个分量分别置0才变成黑色
				{
					//*(pBmpBuf+i*lineByte+j*3+k)-=40;
					m = *(pBmpBuf + i*lineByte + j * 3 + k);
					outfile << m << " ";
					count_xiang_su++;
					if (count_xiang_su % 8 == 0)
					{
						outfile << endl;
					}
					//n++;
				}
				n++;
			}


		}
	}
	cout << "总的像素个素为:" << count_xiang_su << endl;
	cout << "----------------------------------------------------" << endl;
	//将图像数据存盘

	char writePath[] = "nvcpy.BMP";//图片处理后再存储

	saveBmp(writePath, pBmpBuf, bmpWidth, bmpHeight, biBitCount, pColorTable);

	//清除缓冲区，pBmpBuf和pColorTable是全局变量，在文件读入时申请的空间

	delete[]pBmpBuf;

	if (biBitCount == 8)
		delete[]pColorTable;
}

void main()
{
	doIt();
}

可能遇到的问题

黑线的问题：是因为分发数据的时候导致的，要得到x行的结果，分发的时候就必须有x+m-1行的原始数据（m代表卷积核的规格，不足部分使用0填充）

部分优化及分析

优化一

首先声明：这里我一定要说清楚，贴出我的一段错误代码，但是主要是优化的思路及分析（个人感觉这个思路比较有mark的必要）。错误的代码分析完了之后会附上正确的代码

在计算行座标时每计算一个像素就会多出3*5*5次加法和3*5*5次乘法，这样总的计算次数就会多出3*5*5*height*width次加法和乘法

同样的列座标多出3*5*5*height*width次加法

如果只是将3次计算统一成一次计算，那只会将多余的计算量减少为原来的1/3.而事实上注意到在卷积的过程中这个行座标的计算在不同像素之间计算时也是有很多的重叠部分（同一行的像素）因此考虑对同一行多余计算进行统一。

改进如下

对行座标的多余计算总共只需要height次乘法和height*width*5次加法。

对列座标的多余计算总共只需要5*5*height*width。

共计减少了(3*5*5* width- 1)* height次乘法

共计减少了(2*3*5-1-5）*5*height*width次加法，

实际上必须的乘法和加法为3*5*5*height*width次，

必须的加法为3*(5*5-1)* height*width次，

这样优化之后，相当于把程序做的乘法次数减少了将近50%，加法次数减少到原来的46%（我在计算的时候把浮点乘和整数乘的时间看做相等来进行计算，记得去年做矩阵乘的时候这两个相乘的时间好像就是差不太多）

综上，经过这步优化，程序的计算效率大约提升为优化前的2倍。

下面是正确的代码（其实优化效果没有上面错误的那么明显，仅仅是减少了一些加法而已）

优化二：考虑cache的缓存数据更新的资源消耗

优化方法：改变循环的嵌套次序

优化前

优化后

这一步优化可以很明显看出不会对计算结果产生影响，但是在计算的顺序上有了很大的变化。

line=i+a放在外层循环，lie=j+b放在内层循环，很容易理解，先对一行进行计算，然后对下一行进行计算，

优化的原理是cache有一个预取技术，假如你去了R[0][0]位置的元素，它就会预测你可能还会使用临近的R[0][1]以及更多的元素，然后会帮你把它一起取到缓存，而下一个要用的正好就是这个，所以直接在缓存中就可以找到，节省了存取时间，利用这个原理，以及矩阵的顺序存储的特性，我们计算完一行之后，再去计算下一行，而不是像原来那样一个卷积核一个卷积核地计算，因为那样会有5行的跨度，极大地浪费了缓存的资源。