C++实现超分辨率 RDN

RDN(由残差密集网络实现的图像超分辨率)

在《RDN-TensorFlow-master》有一个3倍模型(也只有这一个了)：rdn_5_3_64_x3

 

这里用C++实现这个的3倍重建：

流程图：

密集残差块：

这个残差块结构内部和前面的ESRGAN（前面的文章）中的密集残差块是一样的，只是外部有点不同。

定义密集残差块：

struct 密集残差块 // 4个卷积层
{
	//输入       0; -->64

	//0 连续存储 64
	层数据 * conv1;//64-->64

	//0，1 连续存储 128
	层数据 * conv2;//128-->64

	//0，1，2 连续存储 192
	层数据 * conv3;//192-->64

	//0，1，2，3 连续存储 256
	层数据 * conv4;//256-->64    局部特征融合 1x1卷积
};

定义模型数据池和初始化：

struct RDN模型
{
    //浅层特征提取
	层数据 * conv1;//3->64
	层数据 * conv2;//64->64

	//密集残差块
	int 密集残差块数量;//5块
	密集残差块 * 块;

	//5个密集残差块连续存储 320
	层数据 * conv3;	//320-->64 特征融合 1x1卷积
	层数据 * conv4; //64-->64

	//全局残差相加

	//放大
	层数据 * up1;//64->64 卷积
	层数据 * up2;//64->32 卷积
	层数据 * up3;//32->27 卷积
	//亚像素卷积 27->3
	
	//输出
	层数据 * out;//3->3 卷积

	
	//构造函数
	RDN模型();

};

RDN模型::RDN模型()
{

	int size;
	层数据 * 层;

	//用于一层（宏）
	/*输入维度,输出维度,核宽*/
	/*输入维度,输出维度,核宽*/
	#define 初始化ONE层(IN,OUT,KW) \
	\
	层->输入维度=IN;\
	层->输出维度=OUT;\
	层->核宽=KW;\
	层->权重长度=层->输出维度*层->输入维度*层->核宽*层->核宽;\
	层->权重_数据=(float*)malloc(sizeof(float) * 层->权重长度);\
	层->偏移长度=层->输出维度;\
	层->偏移_数据=(float*)malloc(sizeof(float) * 层->偏移长度);\


	#define 初始化层(ConvX,IN,OUT,KW) \
	size = sizeof(层数据);\
\
	层=ConvX =(层数据 *)malloc(size);\
	初始化ONE层(IN,OUT,KW)\




	/*名称,输入维度,输出维度,核宽*/
		初始化层(conv1,3,64,3);
		初始化层(conv2,64,64,3);

		密集残差块数量=5;
		size = sizeof(密集残差块)*密集残差块数量;
		块=(密集残差块*)malloc(size);
		密集残差块 * 密集残差块0=块;
		for (int k = 0;k<密集残差块数量;k++)
		{

			初始化层(密集残差块0->conv1,64,64,3);
			初始化层(密集残差块0->conv2,128,64,3);
			初始化层(密集残差块0->conv3,192,64,3);
			初始化层(密集残差块0->conv4,256,64,1);

			密集残差块0++;
		}

		初始化层(conv3,320,64,1);
		初始化层(conv4,64,64,3);

		初始化层(up1,64,64,5);
		初始化层(up2,64,32,3);
		初始化层(up3,32,27,3);

		初始化层(out,3,3,3);

}

主函数：

void RDN(char * savefilename,RDN模型 & sr)
{

//		
	int wid=bmp.width;
	int hei=bmp.height;
		cout<<"输入图像宽度："<<wid<<endl;
		cout<<"        高度："<<hei<<endl;
//
	卷积层 rgb(wid,hei,3);
	rgb.data=new float[wid * hei * 3 ]; 

	//jpg转换为RGB卷积层
	bmp2RGB(rgb);




	//---------------------------------------------->
	层数据 * 层;

	//两个卷积层 交替前传（源,目标）
			
	//用这个传回
	卷积层 * di=(卷积层 *)malloc(sizeof(卷积层));
		di->width=1;
		di->height=1;
		di->depth=1;
		di->data=new float[1 ]; 

	卷积层 *源,*目标;
	源 = &rgb;
	
	目标 = di;

	int pad;

		

	cout<<"输入层..."<<endl;
	卷积前传无RELU(sr.conv1);

	//备份
	卷积层 conv1备份(wid,hei,源->depth);//F_1
	conv1备份.data=new float[wid * hei * 源->depth ]; 
	卷积层复制(源,&conv1备份);


	卷积前传无RELU(sr.conv2);
		//load_mat2卷积层("me/F0.txt",源);

	//----------------------------------------------<

	    
	    

	//第二部分  5密集残差块
	密集残差块总成(sr,*源);

		
	卷积层相加(&conv1备份,源);
		//load_mat2卷积层("me/FDF.txt",源);
	del卷积层(conv1备份);

	        
	//放大3倍
		
	cout<<"放大3倍... "<<endl;


	卷积前传(sr.up1);
	卷积前传(sr.up2);
	卷积前传无RELU(sr.up3);


	//亚像素卷积
	wid *= 3;hei *= 3;
	Resize卷积层(*目标,wid,hei,3);

	像素混组放大(源,目标);

	std::swap (源,目标);
		//load_mat2卷积层("me/FU.txt",源);
	卷积前传无RELU(sr.out);

	cout<<"生成宽，高:"<<wid<<","<<hei<<endl;

		//load_mat2卷积层("me/result.txt",源);

	RGB2bmp(*源);
						
	
	del卷积层(*源);
	del卷积层(*目标);
	


	cout<<"图像转换成jpg格式... "<<endl;


	savejpg(savefilename);

	cout<<"转换文件已经保存为:    "<<savefilename<<endl;

}

效果图：

小图

RDN 3倍

EDSR 3倍重建（EDSR-PyTorch-master运行结果）

确实和EDSR效果和速度都相差不多。

下载：

win32超分辩重建RDN实用程序

超分辨率重建RDN(3倍)的win32程序，由RDN-TensorFlow-master中的模型改编而来

https://download.csdn.net/download/juebai123/11135013