32位C++改编 对抗(SRGAN)之生成(generator)超分辨重建 ---（二）主函数

先展示主函数，和前面的那些程序有不同之地方到后面的文章中再说明：

void SRResNet(int up_scale)
{
	generator_tf模型 sr;
	// 加载 CNN 模型参数
	loadModel(&sr);

	int wid=jpg.getwidth();
	int hei=jpg.getheight();
		cout<<"输入图像宽度："<<wid<<endl;
		cout<<"        高度："<<hei<<endl;
//
	卷积层 rgb(wid,hei,3);//即rgb通道
	rgb.data=new float[wid * hei *3]; 

	//jpg转换为RGB卷积层
	jpg2RGB(&jpg,&rgb);
	//save_卷积层2jpg(&rgb,"rgb");
			

	卷积层 bgr(wid,hei,3);//即rgb通道
	bgr.data=new float[wid * hei *3]; 
	RGB2BGR(&rgb,&bgr);

		del卷积层(rgb);

	//------------------------------------->
	//卷积层 png= loadpng2卷积层("6bpng.png");
	//卷积层复制(&png,&bgr);
	//save_卷积层2txt ("rgb.txt",&png);  //保存
	//-------------------------------------<

//	 save_卷积层2txt ("bgr.txt",&bgr);  //保存
//load_mat2卷积层 ("gen_inputs_3fen.txt",&bgr);  //载入tf中的中间层数据

	//输入层结果
	卷积层 convfea1(wid,hei,64);
	convfea1.data=new float[wid * hei * 64 ]; 







	//第一部分 输入层

	层数据 * 层=sr.输入层->卷积层;

	    

		        
					cout<<"生成64个特征图..."<<endl;
		            
		            
						
						vl_nnconv(&bgr,&convfea1,层 ,1,1,4,4,4,4);
						

						vl_nnrelu(&convfea1, sr.输入层->Prelu_alpha);//激励函数Prelu
					
						//save_卷积层2jpg(&convfea1,"con0");

	    
	    
	    
//load_mat2卷积层 ("stage1_output.txt",&convfea1);  //载入tf中的数据

								del卷积层(bgr);



	//第二部分  16残差层
	卷积层 convfea2(wid,hei,64);
	convfea2.data=new float[wid * hei * 64 ]; 
	卷积层 convfea3(wid,hei,64);
	convfea3.data=new float[wid * hei * 64 ]; 
	卷积层 convfea4(wid,hei,64);
	convfea4.data=new float[wid * hei * 64 ];

	卷积层 *源,*目标,*源备份;

	源=&convfea2;
	目标=&convfea3;
	源备份=&convfea4;
	卷积层复制(&convfea1,源);


	//2。16个残差块
	残差块 * 残差块0=sr.块;
	cout<<"16个残差块... 包括 2 组(卷积，归一化，缩放平移)"<<endl;

	for (int k = 0;k<sr.残差块数量;k++)
	{
		cout<<k<<endl;
		//备份
		卷积层复制(源,源备份);

		for(int p=0;p<2;p++){
		//第一部分
			层=残差块0->数据[p].卷积层;
						
			vl_nnconv(源,目标,层 ,1,1,1,1,1,1);
		
			//save_卷积层2jpg(目标,"cc0");

		//第二部分 BatchNorm

			//if(	残差块0->数据[p].有无BatchNorm_beta==true)
			//{
				tf_BatchNorm(目标,残差块0->数据[p].u,残差块0->数据[p].std,残差块0->数据[p].BatchNorm_beta);
				//save_卷积层2jpg(目标,"cc1");


			//}
			if(p==0)
			//if(	残差块0->数据[p].有无Prelu==true)
				vl_nnrelu(目标,残差块0->数据[p].Prelu_alpha);

							//save_卷积层2jpg(目标,"cc2");
				std::swap (源,目标);
		}
		//save_卷积层2jpg(源,"a0");
		//save_卷积层2txt ("a0.txt",源);  //保存

		//求和
        卷积层相加(源备份,源);
		//save_卷积层2jpg(源,"a1");
							//char txt[255];
							//sprintf(txt, "ca%d", k);  
							//save_卷积层2jpg(目标,txt);
		

		残差块0++;//到下残差块
	}//end

	//	基本单位 残差输出层; 
	  //残差输出层--->开始
	cout<<"残差完成输出层... "<<endl;
		//第一部分
			层=sr.残差输出层.卷积层;
			vl_nnconv(源,目标,层 ,1,1,1,1,1,1);

		//save_卷积层2jpg(目标,"o0");
		//第二部分
			//if(	sr.残差输出层.有无BatchNorm_beta==true)
			//{
	//load_mat2卷积层 ("resblock_output_batchnorm.txt",目标);  
							//save_卷积层2jpg(目标,"roa_");

				tf_BatchNorm(目标,sr.残差输出层.u,sr.残差输出层.std,sr.残差输出层.BatchNorm_beta);


							//save_卷积层2jpg(目标,"rob_");

			//}
			//sum17 与输入层相加
			卷积层相加(&convfea1,目标);
		std::swap (源,目标);
		//残差输出层  <----结束

		del卷积层(convfea1);
		del卷积层(*目标);
		del卷积层(*源备份);

	//后3层
	基本单位 *后=sr.后3层;

		卷积层 中间2倍(wid*2,hei*2,64);
		卷积层 中间4倍(wid*4,hei*4,64);
	// 3倍重建图
	卷积层 hR1(wid*4,hei*4,3);

				卷积层 temp0(wid,hei,256);
				卷积层 temp1(wid*2,hei*2,256);

	for (int k = 0;k<3;k++)
	{
		层=后->卷积层;

		switch(k)
		{
			case 0:
					
				cout<<"第一像数组合放大层(2倍)... "<<endl;

				temp0.data=new float[wid * hei * 256 ];
				vl_nnconv(源,&temp0,层 ,1,1,1,1,1,1);


				//save_卷积层2jpg(&temp0,"t");

		del卷积层(*源);

				//放大排列
				中间2倍.data=new float[wid * hei *4*64 ];

				放大排列256_64(&temp0,&中间2倍);
				//放大排列2(&temp0,&中间2倍);//
				delete []temp0.data;  temp0.data=NULL;  

				//if(sr.后3层->有无Prelu==true)
					vl_nnrelu(&中间2倍,后->Prelu_alpha);

				//save_卷积层2jpg(&中间2倍,"h2");

				break;
			case 1:
				cout<<"第二像数组合放大层(2倍)... "<<endl;
				temp1.data=new float[wid * hei *4* 256 ];
				vl_nnconv(&中间2倍,&temp1,层 ,1,1,1,1,1,1);

						del卷积层(中间2倍);


				//放大排列
				中间4倍.data=new float[wid * hei *16*64 ];

				

				放大排列256_64(&temp1,&中间4倍);
				//delete []temp1.data;  temp1.data=NULL;  
				del卷积层(temp1);
								
	//load_mat2卷积层 ("subpixelconv_stage2_prelu_tf.txt",&中间4倍); 


					vl_nnrelu(&中间4倍,后->Prelu_alpha);

				//save_卷积层2jpg(&中间4倍,"h4");
//load_mat2卷积层 ("subpixelconv_stage2_out.txt",&中间4倍); 
				break;
			case 2:
				cout<<"合成结果图像... "<<endl;
				hR1.data=new float[wid * hei * 16*3 ]; 

				vl_nnconv(&中间4倍,&hR1,层 ,1,1,4,4,4,4);

				//delete []中间4倍.data;  中间4倍.data=NULL;  
								del卷积层(中间4倍);

				//save_卷积层2jpg(&hR1,"hR1");

				//save_卷积层2txt ("hR1.txt",&hR1);  //保存
				break;

		}


		后++;
	}
	//save_卷积层2txt ("hR1.txt",&hR1) ;
	cout<<"图像转换成jpg格式... "<<endl;

//load_mat2卷积层 ("output_stage.txt",&hR1); 

	//卷积层 bgr2(wid*4,hei*4,3);//即rgb通道
	//bgr2.data=new float[wid * hei * 16*3 ]; 
	//RGB2BGR(&hR1,&bgr2);
	RGB2BGR(hR1) ;//R<--互换-->B


	RGB2jpg(&hR1,&jpg);
			//delete []hR1.data;  hR1.data=NULL;  
			del卷积层(hR1);
									//del卷积层(bgr2);

	cout<<"保存为'SRResNet 4倍重建.jpg'文件... "<<endl;
	savejpg(&jpg,"SRResNet 4倍重建");
	                
}

其中注掉的代码基本上是调试用的

load_mat2卷积层  导入的数据是 前面文章中说的 从SRGAN-tensorflow-master 导出的中间层数据

这样可以从后面向前测试出错的地点。

先这样吧