C语言实现一、二维数组动态内存分配与释放以及图像的线性插值放大与优化

1.1前言

1.本文是博主本着虚心学习的态度与大家交流，博文难免会有错误之处，希望大家指正；

2.本文是针对对C语言以及图像放大的基础讨论，如是大牛们可以直接忽略本文；

3.运行环境：由于在不同电脑配置和系统上的运行时间有差异，本程序的测试平台：电脑CPU为Intel奔腾双核E6500，主频2.93GHZ内存4GB.虚拟机为10.0版的VMware，linux系统为Fedora16

要讲程序的运行速度，还是要从计算机的底层实现为出发点，以下一个图像的两倍线性放大论证此事实。刚刚接触图像处理，要完成图像的两倍线性放大，一想到图像有长与宽，最先想到用二维数组来实现，每次插值采用时间复杂度为O(n^2)的两个for循环来实现，插几次值就OK了。做完之后，大师说这个程序还有优化的空间，因为计算机的内存时一块一维连续的空间，如果这里出发采用一维数组去实现，效果会更好，插2次值就OK，而且每次插值采用的时间复杂度为O(n)。同时涉及到一维数组及二维数组的在堆的动态内存分配，以及以一位数组、二维数组作为函数的形参，进行参数传递。

主旨: 采用隔行隔列插入，左右及上下取均值把640x480的图像放大2倍，变成1280x960的图像，测试程序运行效率时选择了稍大点的数据，效果会比较明显。

2.1插值函数参数为二维数组

紫色框的圆代表原始数据，首先上下取均值插(√)，再左右取均值插(×)，再取四个均值插(※)，最后插最后一列和最后一行。数据来源于计算机生成的伪随机数，为了方便测试该程序，改用较大分辨率2048x1536（现实没见到这种分辨率，按4:3的比例赋的值，测试用即可）程序从linux平台考过来的，格式可能会有一些乱。

源码如下：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/time.h>
typedef unsigned short dbyte;//图像每个像素点为双字节（双char型），且都大于零；char为8bit，short为16bit，用short来表示双char

#define H 1536  //表示图像分辨率的高度
#define W 2048  //表示图像分辨率的宽度

int interpolation_expansion(dbyte **original_data, dbyte **processed_data);//插值函数声明

int main(int argc, int *argv[])
{
int i, j;
dbyte **input_data, **output_data;
//内存分配
input_data = (dbyte **)malloc(H*sizeof(dbyte *));//为二维数组H行分配dbyte*内存
for(i = 0; i < H; i++)
{
input_data[i] = (dbyte *)malloc(W*sizeof(dbyte));//为每行中应放存放多少个dbyte元素分配内存
memset(input_data[i],0,W);//初始化内存
}
output_data = (dbyte **)malloc(2*H*sizeof(dbyte *));
for(i = 0; i < 2*H; i++)
{
output_data[i] = (dbyte *)malloc(2*W*sizeof(dbyte));
memset(output_data[i],0,2*W);
}
for(i = 0;i < H; i++)
{
for(j = 0; j < W; j++)
{
input_data[i][j] = rand();//数据采用伪随机数
}
}
for(i = 238; i < 241; i++)
{
for(j = 320; j < 324; j++)
printf("[%d][%d]_ %d  ",i , j, input_data[i][j]);
printf("\n");
}
struct timeval tpstart, tpend;
float timeuse;
gettimeofday(&tpstart, NULL);//获取函数调用之前的时间
interpolation_expansion(input_data, output_data);
gettimeofday(&tpend, NULL);//获取函数调用结束的时间
printf("_________________________<_________>_________________________\n");
for(i = 476; i < 481; i++)
{
for(j = 640; j < 648; j++)
printf("[%d][%d]_%d  ", i, j, output_data[i][j]);
printf("\n");
}
//计算函数调用多花费的时间，单位为秒
timeuse = 1000000*(tpend.tv_sec - tpstart.tv_sec)+      tpend.tv_usec - tpstart.tv_usec;
timeuse /= 1000000;
printf("The usetime TWO-dimensional array is %fS\n",timeuse);

//释放内存，【好像不用循环直接free(input_data)也可以，前提是需要知道第二维，我不是很确定】
for(i = 0; i < H; i++)
{
free(input_data[i]);
}
for(i = 0; i < 2*H; i++)
{
free(output_data[i]);
}
}

int interpolation_expansion(dbyte **original_data, dbyte **processed_data)//插值函数的原型
{
int i, j;
int last_line = 2*H -1;
int last_column = 2*W -1;
short tmp_data;

//set values for expansion array 把原来图片的像素点数据插入到需要放大的图片上（下标[偶数][偶数]标示○）
for(i = 0;i < H; i++)
{
for(j = 0; j < W; j++)
{
processed_data[2*i][2*j] = original_data[i][j];
}
}

//insert values into that subscript is odd line caculating by up number and down number用已知值进行上下取均值插入(下标[偶数][奇数]标示√)
for(i = 1; i < 2*(H-1); i += 2)//height_line
{
for(j = 0;j < 2*W; j += 2)//width_column
{

processed_data[i][j] =  (processed_data[i-1][j] +  processed_data[i+1][j])/2;
}
}

//insert values into that subscript is odd column caculating by left number and right number左右取均值插入(下标[奇][偶]标示×)
for(i = 0; i < 2*H; i += 2)//height_line
{
for(j = 1;j < 2*(W-1); j += 2)//width_column
{

processed_data[i][j] =  (processed_data[i][j-1] +  processed_data[i][j+1])/2;
}
}

//insert values into that both weight and height are odd numbers 对周围四个取均值（下标[奇][奇]标示※）
for(i = 1; i < 2*(H-1); i += 2)//height_line
{
for(j = 1; j < 2*(W-1); j += 2)
{
processed_data[i][j] = (processed_data[i-1][j-1] + processed_data[i-1][j+1] + processed_data[i+1][j-1] + processed_data[i+1][j+1])/4;

}
}
//insert values into the last line and column对最后一行和最后一列进行插值
for(i = 0; i< 2*H-1; i++)//insert values into last colum
{
if((tmp_data = 2*processed_data[i][last_column-1]-processed_data[i][last_column-2])>0)
{
processed_data[i][last_column] = tmp_data;
}
else
{
processed_data[i][last_column] = processed_data[i][last_column-1];
}
}
for(j = 0; j< 2*W-1; j++)//insert values into last line
{

if((tmp_data = 2*processed_data[last_line-1][j] - processed_data[last_line-2][j]) > 0)
{
processed_data[last_line][j] = tmp_data;
}else
{
processed_data[last_line][j] = processed_data[last_line-1][j];
}
}
processed_data[last_line][last_column] = (processed_data[last_line-1][last_column] + processed_data[last_line][last_column-1] + processed_data[last_line-1][last_column-1])/3;
return 1;
}

本段程序实现了函数形参为二维数组的传递，以及二维数组在堆的动态内存分配。我当初直接为二维数组在栈上分配空间，也就是指定死二维数组的行和列，但是当分辨率较高时，在linux编译能通过，但是运行遇到段错误（吐核），如下



目前也没有找到其根本原因，后面用二维数组的动态内存分配解决了这个问题……

2.2程序的测试结果

截取的数据为放大前、后图片中间的某块数据，平均运行时间为0.098260秒

3.1插值函数参数为一维数组

紫色框的圆代表原始数据，2个for循环实现，首先左右取均值插值(×)，再上下取均值插值(√)；也可以在插值子函数里实现动态内存，但是为了方便管理，尽量在主函数分配，谁用谁分配和释放，只需要调用函数接口即可。

源码如下：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/time.h>

typedef unsigned short dbyte;
#define M 1536  //原始图片高度
#define N 2048  //原始图片宽度
#define H 3072    //height  放大2倍图片的高度
#define W 4096   //weight  放大2倍图片的宽度

dbyte* insert_values(dbyte *original_data, dbyte *processed_data);

int main(int argc, int *argv[])
{
int i, count;
//内存分配
dbyte *original_data = (dbyte *)malloc(M*N*sizeof(dbyte));
dbyte *processed_data = (dbyte *)malloc(W*H*sizeof(dbyte));
if(original_data == NULL)
{
printf("please allocate the input memery again!\n");
}

if(processed_data == NULL)
{
printf("please allocate the output memery again!\n");
}
//初始化内存为零
memset(original_data,0,M*N);
memset(processed_data,0,W*H);

//the test program as the follows.
//set original data
for(i  = 0; i < N*M; i++)
{
original_data[i] = rand();
}

//printf have not be to insert
for(i = 238*N + 320, count = 1; i < 324 + 241* N; )
{
printf(" %d__%ld   ",i, original_data[i]);
if(count%4 == 0)
{
count = 1;
i += (N-3);
printf("\n");
}else{
count++;
i++;
}
}
printf("______________*****************_____________________________*****************__________\n");

struct timeval tpstart, tpend;
float timeuse;
gettimeofday(&tpstart, NULL);
insert_values(original_data,processed_data);//use of the function
gettimeofday(&tpend, NULL);

//printf insert have been down
for(i = 476*W + 640, count = 1; i < 648 + 481* W; )
{
printf(" %d__%ld   ", i, processed_data[i]);
if(count%8 == 0)
{
count = 1;
i += (W-7);
printf("\n");
}else{
count++;
i++;
}
}
timeuse = 1000000*(tpend.tv_sec - tpstart.tv_sec)+ tpend.tv_usec - tpstart.tv_usec;
timeuse /= 1000000;
printf("The  usetime of One-dimensional array is %fS\n",timeuse);
free(processed_data);
free(original_data);
}

dbyte* insert_values(dbyte *original_data, dbyte *processed_data)//The value of return can be define by yourself
{
int i, j;
short tmp;
//set_values from original_data to the processed_data
for(i = j = 0; i<W*(H-1); i += 2, j++)//i为循环要放大的图像，步长为2（隔列插入），j用来循环遍历原始数据
{
if((i!= 0) && (i%W) == 0)//判断是否把一个W宽度的数据插完，真就跳W个数据继续插值，注意：如果不添加i!=0，当i=0，只判断i%W==0，最开始的W个数据时没有的
{
i += W;
}
processed_data[i] = original_data[j];
}

//insert_values into the line caculating by left number and right number 左右均值插值
for(i = 1;i < W*(H-1); i += 2)
{
if((i+1)%W == 0)//最后一列的插值方法，图像由左向右延伸
{
if((tmp = processed_data[i-1]*2-processed_data[i-2]) > 0) //如果中间值的2倍大于两边值之和，就插2倍中间值减去已知的值
{
processed_data[i] = tmp;
}
else{
processed_data[i] = processed_data[i-1];//如果需要插的值是小于零的，直接复制前一个像素点数据
}
i += W;
}
else
{
processed_data[i] = (processed_data[i-1] + processed_data[i+1])/2;

}
}

//insert_values into the line caculating by up number and down number
for(i = W; i < W*H; i++)
{
if(i < W*(H-1))
{
processed_data[i] = (processed_data[i-W] + processed_data[i+W])/2;
if((i+1)%W == 0)
{
i += W;
}
}else//最后一行的插值方法，图像由上向下延伸
{
if((tmp = processed_data[i-W]*2-processed_data[i-2*W]) > 0)
{
processed_data[i] = tmp;
}else{
processed_data[i] = processed_data[i-W];
}
}
}
return processed_data;
}

3.2一维数组程序的测试结果

截取的数据为放大前、后图片中间的某块数据，平均运行时间为0.081015秒

4.1结论

(0.098260-0.081015)=0.17245秒

0.17245/0.09826*100=17.55%,效率提高了百分之17.55。可能有的人觉得没有必要，毕竟现在的CPU处理速度已经相当快了。但如果是在嵌入式设备上就不一定了，毕竟嵌入式设备的资源都是有限的，所以很宝贵，充分利用它才是王道。