我们从下面三个方面来进行相应的数字图像处理
一、图象噪声估计
二、图象分割
三、图像压缩及解压
一、图象噪声估计
•常见的噪声模型：
•1、高斯噪声；
•2、瑞利噪声；
•3、伽马噪声；
•4、指数分布噪声；
•5、均匀分布噪声；
•6、脉冲噪声；
图中噪声分别是：
- •a.高斯噪声分布图；
•b.瑞利噪声分布图；
•c.伽马噪声分布图；
•d.指数噪声分布图；
•e.均匀噪声分布图；
•f.脉冲噪声分布图； - 我们将用到的库函数是：
CV_EXPORTS_W void blur( InputArray src, OutputArray dst, Size ksize, Point anchor = Point(-1,-1), int borderType = BORDER_DEFAULT );（均值滤波函数）
CV_EXPORTS_W void GaussianBlur( InputArray src, OutputArray dst, Size ksize,double sigmaX, double sigmaY = 0,int borderType = BORDER_DEFAULT );（高斯滤波函数）
CV_EXPORTS_W void medianBlur( InputArray src, OutputArray dst, int ksize );（中值滤波函数）
CV_EXPORTS_W void bilateralFilter( InputArray src, OutputArray dst, int d,double sigmaColor, double sigmaSpace,int borderType = BORDER_DEFAULT );（双边滤波函数）
CV_EXPORTS_W int getOptimalDFTSize(int vecsize);（得到最佳IDFT变换尺寸函数）
CV_EXPORTS_W void dft(InputArray src, OutputArray dst, int flags = 0, int nonzeroRows = 0);(dft变换函数)
CV_EXPORTS void calcHist( const Mat* images, int nimages,const int* channels, InputArray mask,OutputArray hist, int dims, const int* histSize,const float** ranges, bool uniform = true, bool accumulate = false );(计算直方图函数)这里我们准备了五种滤波器，分别是均值滤波器，高斯滤波器，中值滤波器，双边滤波器，频域高斯滤波器（主要是滤一些周期噪声）
- 图像噪声的估计流程如下：
- 相应的程序如下：
/*均值滤波函数*/
Mat Blurefilterfunction(Mat &img)
{
namedWindow("均值滤波【效果图】", CV_WINDOW_AUTOSIZE);
Mat out;
blur(img, out,Size(7, 7)); /*这里选用7*7的内核进行均值滤波*/
imshow("均值滤波【效果图】", out);
return out;
}
/*高斯滤波函数*/
Mat GaussianBlurfilterfunction(Mat &img)
{
namedWindow("高斯滤波【效果图】", CV_WINDOW_AUTOSIZE);
Mat out;
GaussianBlur(img, out, Size(3, 3),0,0); /*这里选用3*3的内核进行高斯滤波*/
imshow("高斯滤波【效果图】", out);
return out;
}
/*中值滤波函数*/
Mat MedianBlurfilterfunction(Mat &img)
{
namedWindow("中值滤波【效果图】", CV_WINDOW_AUTOSIZE);
Mat out;
medianBlur(img, out, 7);
imshow("中值滤波【效果图】", out);
return out;
}
/*双边滤波函数*/
Mat BilateralBlurfilterfunction(Mat &img)
{
namedWindow("双边滤波【效果图】", CV_WINDOW_AUTOSIZE);
Mat out;
bilateralFilter(img, out, 25, 25 * 2, 25 / 2);
imshow("双边滤波【效果图】", out);
return out;
}
/*高斯频域低通滤波器*/
//**************************************
//频率域滤波——以高斯低通为例
//**************************************
Mat gaussianlbrf(Mat scr, float sigma);//高斯低通滤波器函数
Mat freqfilt(Mat scr, Mat blur);//频率域滤波函数
Mat FrequencyDomainGaussFiltering(Mat &input)
{
//Mat input = imread("p3-00-01.tif", CV_LOAD_IMAGE_GRAYSCALE);
int w = getOptimalDFTSize(input.cols); //获取进行dtf的最优尺寸
int h = getOptimalDFTSize(input.rows); //获取进行dtf的最优尺寸
Mat padded;
copyMakeBorder(input, padded, 0, h - input.rows, 0, w - input.cols, BORDER_CONSTANT, Scalar::all(0)); //边界填充
padded.convertTo(padded, CV_32FC1); //将图像转换为flaot型
Mat gaussianKernel = gaussianlbrf(padded, 30);//高斯低通滤波器
Mat out = freqfilt(padded, gaussianKernel);//频率域滤波
imshow("结果图 sigma=30", out);
return out;
}
//*****************高斯低通滤波器***********************
Mat gaussianlbrf(Mat scr, float sigma)
{
Mat gaussianBlur(scr.size(), CV_32FC1); //，CV_32FC1
float d0 = 2 * sigma*sigma;//高斯函数参数，越小，频率高斯滤波器越窄，滤除高频成分越多，图像就越平滑
for (int i = 0; i < scr.rows; i++)
{
for (int j = 0; j < scr.cols; j++)
{
float d = pow(float(i - scr.rows / 2), 2) + pow(float(j - scr.cols / 2), 2);//分子,计算pow必须为float型
gaussianBlur.at<float>(i, j) = expf(-d / d0);//expf为以e为底求幂（必须为float型）
}
}
imshow("高斯低通滤波器", gaussianBlur);
return gaussianBlur;
}
//*****************频率域滤波*******************
Mat freqfilt(Mat scr, Mat blur)
{
//***********************DFT*******************
Mat plane[] = { scr, Mat::zeros(scr.size() , CV_32FC1) }; //创建通道，存储dft后的实部与虚部（CV_32F，必须为单通道数）
Mat complexIm;
merge(plane, 2, complexIm);//合并通道 （把两个矩阵合并为一个2通道的Mat类容器）
dft(complexIm, complexIm);//进行傅立叶变换，结果保存在自身
//***************中心化********************
split(complexIm, plane);//分离通道（数组分离）
int cx = plane[0].cols / 2; int cy = plane[0].rows / 2;//以下的操作是移动图像 (零频移到中心)
Mat part1_r(plane[0], Rect(0, 0, cx, cy)); //元素坐标表示为(cx,cy)
Mat part2_r(plane[0], Rect(cx, 0, cx, cy));
Mat part3_r(plane[0], Rect(0, cy, cx, cy));
Mat part4_r(plane[0], Rect(cx, cy, cx, cy));
Mat temp;
part1_r.copyTo(temp); //左上与右下交换位置(实部)
part4_r.copyTo(part1_r);
temp.copyTo(part4_r);
part2_r.copyTo(temp); //右上与左下交换位置(实部)
part3_r.copyTo(part2_r);
temp.copyTo(part3_r);
Mat part1_i(plane[1], Rect(0, 0, cx, cy)); //元素坐标(cx,cy)
Mat part2_i(plane[1], Rect(cx, 0, cx, cy));
Mat part3_i(plane[1], Rect(0, cy, cx, cy));
Mat part4_i(plane[1], Rect(cx, cy, cx, cy));
part1_i.copyTo(temp); //左上与右下交换位置(虚部)
part4_i.copyTo(part1_i);
temp.copyTo(part4_i);
part2_i.copyTo(temp); //右上与左下交换位置(虚部)
part3_i.copyTo(part2_i);
temp.copyTo(part3_i);
//*****************滤波器函数与DFT结果的乘积****************
Mat blur_r, blur_i, BLUR;
multiply(plane[0], blur, blur_r); //滤波（实部与滤波器模板对应元素相乘）
multiply(plane[1], blur, blur_i);//滤波（虚部与滤波器模板对应元素相乘）
Mat plane1[] = { blur_r, blur_i };
merge(plane1, 2, BLUR);//实部与虚部合并
//*********************得到原图频谱图***********************************
magnitude(plane[0], plane[1], plane[0]);//获取幅度图像，0通道为实部通道，1为虚部，因为二维傅立叶变换结果是复数
plane[0] += Scalar::all(1); //傅立叶变o换后的图片不好分析，进行对数处理，结果比较好看
log(plane[0], plane[0]); // float型的灰度空间为[0，1])
normalize(plane[0], plane[0], 1, 0, CV_MINMAX); //归一化便于显示
imshow("原图像频谱图", plane[0]);
idft(BLUR, BLUR); //idft结果也为复数
split(BLUR, plane);//分离通道，主要获取通道
magnitude(plane[0], plane[1], plane[0]); //求幅值(模)
normalize(plane[0], plane[0], 1, 0, CV_MINMAX); //归一化便于显示
return plane[0];//返回参数
}
/*绘制直方图函数*/
void Drawing_one_dimensionalhistogram(Mat &img)
{
/*输入图像转化为灰度图像*/
//cvtColor(img, img, CV_BGR2GRAY);
/*定义变量*/
MatND dstHist;
int dims = 1;
float hranges[] = { 0,255 };
const float *ranges[] = { hranges }; /*这里需要为const类型*/
int size = 256;
int channels = 0;
/*计算图像的直方图*/
calcHist(&img, 1, &channels, Mat(), dstHist, dims, &size, ranges);
int scale = 1;
Mat dstImage(size * scale, size, CV_8U, Scalar(0));
/*获取最大值和最小值*/
double minValue = 0;
double maxValue = 0;
minMaxLoc(dstHist, &minValue, &maxValue, 0, 0);
/*绘制出直方图*/
int hpt = saturate_cast<int>(0.9 * size);
for (int i = 0; i < 256; i++)
{
float binValue = dstHist.at<float>(i);
int realValue = saturate_cast<int>(binValue * hpt / maxValue);
rectangle(dstImage, Point(i*scale, size - 1), Point((i + 1)*scale - 1, size - realValue), Scalar(255));
}
imshow("图像的一维直方图", dstImage);
}例如下列图片的直方图：
- 从上到下分别为瑞利噪声（周期噪声），高斯噪声，均匀噪声（周期噪声）
- 首先我们先对瑞利噪声在空域滤波，效果图如下：
- 频域滤波，效果图如下：
- 对于高斯噪声，我们只需要对其高斯滤波即可，但是这里需要进行相应的参数调节，效果图如下：
- 最后一个均匀噪声，也属于周期噪声的一种，这里我们需要对其在频域滤波，效果图如下：
- 二、图象分割
- 大津分割流程图：
- 我们使用到的库函数为：
CV_EXPORTS_W double threshold( InputArray src, OutputArray dst,double thresh, double maxval, int type );（阀值化函数）相应的程序如下：
/*计算大津分割的阈值*/
int OtsuAlgThreshold(const Mat image)
{
if (image.channels() != 1)
{
cout << "Please input Gray-image!" << endl;
return 0;
}
int T = 0; //Otsu算法阈值
double varValue = 0; //类间方差中间值保存
double w0 = 0; //前景像素点数所占比例
double w1 = 0; //背景像素点数所占比例
double u0 = 0; //前景平均灰度
double u1 = 0; //背景平均灰度
double Histogram[256] = { 0 }; //灰度直方图，下标是灰度值，保存内容是灰度值对应的像素点总数
int Histogram1[256] = { 0 };
uchar *data = image.data;
double totalNum = image.rows*image.cols; //像素总数
//计算灰度直方图分布，Histogram数组下标是灰度值，保存内容是灰度值对应像素点数
for (int i = 0; i < image.rows; i++) //为表述清晰，并没有把rows和cols单独提出来
{
for (int j = 0; j < image.cols; j++)
{
Histogram[data[i*image.step + j]]++;
Histogram1[data[i*image.step + j]]++;
}
}
//***********画出图像直方图********************************
Mat image1(255, 255, CV_8UC3);
for (int i = 0; i < 255; i++)
{
Histogram1[i] = Histogram1[i] % 200;
line(image1, Point(i, 235), Point(i, 235 - Histogram1[i]), Scalar(255, 0, 0), 1, 8, 0);
if (i % 50 == 0)
{
char ch[255];
sprintf_s(ch, "%d", i);
string str = ch;
putText(image1, str, Point(i, 250), 1, 1, Scalar(0, 0, 255));
}
}
//***********画出图像直方图********************************
for (int i = 0; i < 255; i++)
{
//每次遍历之前初始化各变量
w1 = 0;
u1 = 0;
w0 = 0;
u0 = 0;
//***********背景各分量值计算**************************
for (int j = 0; j <= i; j++) //背景部分各值计算
{
w1 += Histogram[j]; //背景部分像素点总数
u1 += j * Histogram[j]; //背景部分像素总灰度和
}
if (w1 == 0) //背景部分像素点数为0时退出
{
break;
}
u1 = u1 / w1; //背景像素平均灰度
w1 = w1 / totalNum; // 背景部分像素点数所占比例
//***********背景各分量值计算**************************
//***********前景各分量值计算**************************
for (int k = i + 1; k < 255; k++)
{
w0 += Histogram[k]; //前景部分像素点总数
u0 += k * Histogram[k]; //前景部分像素总灰度和
}
if (w0 == 0) //前景部分像素点数为0时退出
{
break;
}
u0 = u0 / w0; //前景像素平均灰度
w0 = w0 / totalNum; // 前景部分像素点数所占比例
//***********前景各分量值计算**************************
//***********类间方差计算******************************
double varValueI = w0 * w1*(u1 - u0)*(u1 - u0); //当前类间方差计算
if (varValue < varValueI)
{
varValue = varValueI;
T = i;
}
}
//画出以T为阈值的分割线
line(image1, Point(T, 235), Point(T, 0), Scalar(0, 0, 255), 2, 8);
imshow("直方图", image1);
return T;
}
//***************Otsu算法通过求类间方差极大值求自适应阈值*****************
Mat Otsusegmentation(Mat &img)
{
cvtColor(img, img, CV_RGB2GRAY);
Mat imageOutput;
Mat imageOtsu;
int thresholdValue = OtsuAlgThreshold(img);
cout << "类间方差为： " << thresholdValue << endl;
threshold(img, imageOutput, thresholdValue, 255, CV_THRESH_BINARY);
threshold(img, imageOtsu, 0, 255, CV_THRESH_OTSU); //Opencv Otsu算法;
imshow("大津分割【效果图】", imageOutput);
imshow("Opencv Otsu【效果图】", imageOtsu);
return imageOutput;
}首先我们先计算一张图片的阈值，得到其最小类方差：
- 然后进行相应的阈值值化操作：
- 图像分割还有一种称为交互式分割，这里我们直接使用库函数：
CV_EXPORTS_W void grabCut( InputArray img, InputOutputArray mask, Rect rect， InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode = GC_EVAL );
img:待分割的源图像，必须是8位3通道（CV_8UC3）图像，在处理的过程中不会被修改；
mask：掩码图像，大小和原图像一致。可以有如下几种取值： GC_BGD（=0），背景； GC_FGD（=1），前景； GC_PR_BGD（=2），可能的背景； GC_PR_FGD（=3），可能的前景。
rect:用于限定需要进行分割的图像范围，只有该矩形窗口内的图像部分才被处理；
bgdModel:背景模型，如果为null，函数内部会自动创建一个bgdModel；
fgdModel:前景模型，如果为null，函数内部会自动创建一个fgdModel；
iterCount:迭代次数，必须大于0；
mode:用于指示grabCut函数进行什么操作。可以有如下几种选择： GC_INIT_WITH_RECT（=0），用矩形窗初始化GrabCut； GC_INIT_WITH_MASK（=1），用掩码图像初始化GrabCut； GC_EVAL（=2），执行分割。代码如下：
/*grath_cut*/
void grathcutfunctiong(Mat &img)
{
Mat bgModel, fgModel, mask;
Rect rect;
rect.x = 50;
rect.y = 45;
rect.width = img.cols - (rect.x << 1);
rect.height = img.rows - (rect.y << 1);
rectangle(img, rect, Scalar(0, 0, 255), 3, 8, 0);//用矩形画矩形窗
//循环执行3次，这个可以自己设置
grabCut(img, mask, rect, bgModel, fgModel, 3, GC_INIT_WITH_RECT);
compare(mask, GC_PR_FGD, mask, CMP_EQ);
Mat foreground(img.size(), CV_8UC3, Scalar(255, 255, 255));
img.copyTo(foreground, mask);
imshow("foreground", foreground);
}相应的效果图如下：
- 这里再附一个分水岭算法的代码，有兴趣的可以试一试：
Mat g_maskImage, g_scrImage;
Point prevPt(-1, -1);
static void ShowHelpText();
static void on_Mouse(int event, int x, int y, int flags, void*);
/*分水岭算法*/
void Watershedfunction(Mat &g_scrImage)
{
/*初始化掩膜和灰度图*/
Mat scrImage, grayImage;
grayImage.copyTo(scrImage);
cvtColor(g_scrImage, g_maskImage, COLOR_BGR2GRAY);
cvtColor(g_maskImage, grayImage, COLOR_GRAY2BGR);
g_maskImage = Scalar::all(0);
/*设置鼠标回调函数*/
setMouseCallback(WINDOW_NAME, on_Mouse, 0);
/*轮询按键，进行处理*/
while (1)
{
/*获取键值*/
int c = waitKey(0);
/*若按键值为ESC时，退出*/
if ((char)c == 27)
{
break;
}
/*若按键值为2时，恢复原图*/
if ((char)c == '2')
{
g_maskImage = Scalar::all(0);
scrImage.copyTo(g_scrImage);
imshow("image",g_scrImage);
}
/*若按键值为1或者空格，则进行处理*/
if ((char)c == '1' || (char)c == ' ')
{
/*定义一些参数*/
int i, j, compCount = 0;
vector<vector<Point>> contours;
vector<Vec4i> hierarchy;
/*寻找轮廓*/
findContours(g_maskImage, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
/*轮廓为空时的处理*/
if (contours.empty())
continue;
/*复制掩膜*/
Mat maskImage(g_maskImage.size(), CV_32S);
maskImage = Scalar::all(0);
/*循环绘制出轮廓*/
for (int index = 0; index > 0; index = hierarchy[index][0], compCount++)
drawContours(maskImage, contours, index, Scalar::all(compCount + 1), -1, 8, hierarchy, INT_FAST16_MAX);
/*compCount为0时的处理*/
if (compCount == 0)
continue;
/*生成随机颜色*/
vector<Vec3b> colorTab;
for (i = 0; i < compCount; i++)
{
int b = theRNG().uniform(0, 255);
int g = theRNG().uniform(0, 255);
int r = theRNG().uniform(0, 255);
colorTab.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
}
/*计算处理时间并输出到窗口中*/
double dTime = (double)getTickCount();
watershed(scrImage, maskImage);
dTime = (double)getTickCount() - dTime;
printf("\t处理时间 = %gms\n",dTime*1000./getTickFrequency());
/*双层循环，将分水岭图像遍历存入watershedImage中*/
Mat watershedImage(maskImage.size(), CV_8UC3);
for(i=0;i<maskImage.rows;i++)
for (j = 0; j < maskImage.cols; j++)
{
int index = maskImage.at<int>(i, j);
if (index == -1)
watershedImage.at<Vec3b>(i, j) = Vec3b(255, 255, 255);
else if (index <= 0 || index > compCount)
watershedImage.at<Vec3b>(i, j) = Vec3b(0, 0, 0);
else
watershedImage.at<Vec3b>(i, j) = colorTab[index - 1];
}
watershedImage = watershedImage * 0.5 + grayImage * 0.5;
imshow("watershed transform",watershedImage);
}
}
}
static void on_Mouse(int event, int x, int y, int flags, void *)
{
/*处理鼠标不在窗口中的情况*/
if (x < 0 || x >= g_scrImage.cols || y < 0 || y >= g_maskImage.rows)
return;
/*数理鼠标左键相关信息*/
if (event == EVENT_LBUTTONUP || !(flags & EVENT_FLAG_LBUTTON))
prevPt = Point(-1, -1);
else if (event == EVENT_LBUTTONDOWN)
prevPt = Point(x, y);
/*鼠标左键按下并移动，绘制出白色线条*/
else if (event == EVENT_MOUSEMOVE && (flags & EVENT_FLAG_LBUTTON))
{
Point pt(x, y);
if (prevPt.x < 0)
prevPt = pt;
line(g_maskImage, prevPt, pt, Scalar::all(255), 5, 8, 0);
line(g_scrImage, prevPt, pt, Scalar::all(255), 5, 8, 0);
prevPt = pt;
imshow(WINDOW_NAME,g_scrImage);
}
}三、图像压缩及解压
- （1）、霍夫曼编码压缩图片：
- 其流程图如下：
- 代码如下：
/*哈夫曼编码*/
//几个全局变量，存放读入图像的位图数据、宽、高、颜色表及每像素所占位数(比特)
//此处定义全局变量主要为了后面的图像数据访问及图像存储作准备
unsigned char *pBmpBuf;//读入图像数据的指针
int bmpWidth;//图像的宽
int bmpHeight;//图像的高
int imgSpace;//图像所需空间
RGBQUAD *pColorTable;//颜色表指针
int biBitCount;//图像类型
char str[100];//文件名称
int Num[300];//各灰度值出现的次数
float Feq[300];//各灰度值出现的频率
unsigned char *lpBuf;//指向图像像素的指针
unsigned char *m_pDib;//存放打开文件的DIB
int NodeNum; //Huffman树总节点个数
int NodeStart; //Huffman树起始节点
struct Node
{ //Huffman树节点
int color; //记录叶子节点的灰度值（非叶子节点为 -1）
int lson, rson; //节点的左右儿子（若没有则为 -1）
int num; //节点的数值（编码依据）
int mark; //记录节点是否被用过(用过为1，没用过为0)
}node[600];
char CodeStr[300][300]; //记录编码值
int CodeLen[300]; //编码长度
bool ImgInf[8000000]; //图像信息
int InfLen; //图像信息长度
/***********************************************************************
* 函数名称：
* readBmp()
*
*函数参数：
* char *bmpName -文件名字及路径
*
*返回值：
* 0为失败,1为成功
*
*说明：给定一个图像文件名及其路径，读图像的位图数据、宽、高、颜色表及每像素
* 位数等数据进内存,存放在相应的全局变量中
***********************************************************************/
bool readBmp(char *bmpName)
{
//二进制读方式打开指定的图像文件
FILE *fp = fopen(bmpName, "rb");
if (fp == 0)
{
printf("未找到指定文件！\n");
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
if (biBitCount == 8)
{
//申请颜色表所需要的空间，读颜色表进内存
pColorTable = new RGBQUAD[256];
fread(pColorTable, sizeof(RGBQUAD), 256, fp);
}
//申请位图数据所需要的空间，读位图数据进内存
pBmpBuf = new unsigned char[lineByte * bmpHeight];
fread(pBmpBuf, 1, lineByte * bmpHeight, fp);
//关闭文件
fclose(fp);
return 1;
}
/***********************************************************************
保存信息
***********************************************************************/
//二进制转十进制
int Change2to10(int pos)
{
int i, j, two = 1;
j = 0;
for (i = pos + 7; i >= pos; i--)
{
j += two * ImgInf[i];
two *= 2;
}
return j;
}
//保存Huffman编码树
int saveInfo(char *writePath, int lineByte)
{
int i, j ;
FILE *fout;
fout = fopen(writePath, "w");
fprintf(fout, "%d %d %d\n", NodeStart, NodeNum, InfLen);//输出起始节点、节点总数、图像所占空间
for (i = 0; i < NodeNum; i++)
{ //输出Huffman树
fprintf(fout, "%d %d %d\n", node[i].color, node[i].lson, node[i].rson);
}
fclose(fout);
return 0;
}
//保存文件
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;
//待存储图像数据每行字节数为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是图像文件前三个部分所需空间之和
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, InfLen / 8, 1, fp);
//关闭文件
fclose(fp);
return 1;
}
/*********************
Huffman编码图像解码
*********************/
//读入编码图像
bool readHuffman(char *Name)
{
int i;
char NameStr[100];
//读取Huffman编码信息和编码树
strcpy(NameStr, Name);
strcat(NameStr, ".bpt");
FILE *fin = fopen(NameStr, "r");
if (fin == 0)
{
printf("未找到指定文件！\n");
return 0;
}
fscanf(fin, "%d %d %d", &NodeStart, &NodeNum, &InfLen);
//printf("%d %d %d\n",NodeStart,NodeNum,InfLen);
for (i = 0; i < NodeNum; i++)
{
fscanf(fin, "%d %d %d", &node[i].color, &node[i].lson, &node[i].rson);
}
//二进制读方式打开指定的图像文件
strcpy(NameStr, Name);
strcat(NameStr, ".bhd");
FILE *fp = fopen(NameStr, "rb");
if (fp == 0)
{
printf("未找到指定文件！\n");
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
if (biBitCount == 8) {
//申请颜色表所需要的空间，读颜色表进内存
pColorTable = new RGBQUAD[256];
fread(pColorTable, sizeof(RGBQUAD), 256, fp);
}
//申请位图数据所需要的空间，读位图数据进内存
pBmpBuf = new unsigned char[lineByte * bmpHeight];
fread(pBmpBuf, 1, InfLen / 8, fp);
//关闭文件
fclose(fp);
return 1;
}
void HuffmanDecode()
{
//获取编码信息
int i, j, tmp;
int lineByte = (bmpWidth * biBitCount / 8 + 3) / 4 * 4;
for (i = 0; i < InfLen / 8; i++)
{
j = i * 8 + 7;
tmp = *(pBmpBuf + i);
while (tmp > 0)
{
ImgInf[j] = tmp % 2;
tmp /= 2;
j--;
}
}
//解码
int p = NodeStart; //遍历指针位置
j = 0;
i = 0;
do
{
if (node[p].color >= 0)
{
*(pBmpBuf + j) = node[p].color;
j++;
p = NodeStart;
}
if (ImgInf[i] == 1)
p = node[p].lson;
else if (ImgInf[i] == 0)
p = node[p].rson;
i++;
} while (i <= InfLen);
}
/*********************
Huffman编码
*********************/
//Huffman编码初始化
void HuffmanCodeInit()
{
int i;
for (i = 0; i < 256; i++)//灰度值记录清零
Num[i] = 0;
//初始化哈夫曼树
for (i = 0; i < 600; i++)
{
node[i].color = -1;
node[i].lson = node[i].rson = -1;
node[i].num = -1;
node[i].mark = 0;
}
NodeNum = 0;
}
//深搜遍历Huffman树获取编码值
char CodeTmp[300];
void dfs(int pos, int len)
{
//遍历左儿子
if (node[pos].lson != -1)
{
CodeTmp[len] = '1';
dfs(node[pos].lson, len + 1);
}
else
{
if (node[pos].color != -1)
{
CodeLen[node[pos].color] = len;
CodeTmp[len] = '\0';
strcpy(CodeStr[node[pos].color], CodeTmp);
}
}
//遍历右儿子
if (node[pos].lson != -1)
{
CodeTmp[len] = '0';
dfs(node[pos].rson, len + 1);
}
else {
if (node[pos].color != -1)
{
CodeLen[node[pos].color] = len;
CodeTmp[len] = '\0';
strcpy(CodeStr[node[pos].color], CodeTmp);
}
}
}
//寻找值最小的节点
int MinNode()
{
int i, j = -1;
for (i = 0; i < NodeNum; i++)
if (!node[i].mark)
if (j == -1 || node[i].num < node[j].num)
j = i;
if (j != -1)
{
NodeStart = j;
node[j].mark = 1;
}
return j;
}
//编码主函数
void HuffmanCode()
{
int i, j, k, a, b;
for (i = 0; i < 256; i++)
{//创建初始节点
Feq[i] = (float)Num[i] / (float)(bmpHeight * bmpWidth);//计算灰度值频率
if (Num[i] > 0)
{
node[NodeNum].color = i;
node[NodeNum].num = Num[i];
node[NodeNum].lson = node[NodeNum].rson = -1; //叶子节点无左右儿子
NodeNum++;
}
}
while (1)
{ //找到两个值最小的节点，合并成为新的节点
a = MinNode();
if (a == -1)
break;
b = MinNode();
if (b == -1)
break;
//构建新节点
node[NodeNum].color = -1;
node[NodeNum].num = node[a].num + node[b].num;
node[NodeNum].lson = a;
node[NodeNum].rson = b;
NodeNum++;
}
//根据建好的Huffman树编码(深搜实现)
dfs(NodeStart, 0);
//屏幕输出编码
int sum = 0;
printf("Huffman编码信息如下：\n");
for (i = 0; i < 256; i++)
if (Num[i] > 0)
{
sum += CodeLen[i] * Num[i];
printf("灰度值：%3d 频率: %f 码长: %2d 编码: %s\n",i,Feq[i],CodeLen[i],CodeStr[i]);
}
printf("原始总码长：%d\n",bmpWidth * bmpHeight * 8);
printf("Huffman编码总码长：%d\n",sum);
printf("压缩比：%.3f : 1\n",(float)(bmpWidth * bmpHeight * 8) / (float)sum);
for (i = 0; i < 256; i++)
if (Num[i] > 0)
{
sum += CodeLen[i] * Num[i];
}
//记录图像信息
InfLen = 0;
int lineByte = (bmpWidth * biBitCount / 8 + 3) / 4 * 4;
for (i = 0; i < bmpHeight; i++)
for (j = 0; j < bmpWidth; j++)
{
lpBuf = (unsigned char *)pBmpBuf + lineByte * i + j;
for (k = 0; k < CodeLen[*(lpBuf)]; k++)
{
ImgInf[InfLen++] = (int)(CodeStr[*(lpBuf)][k] - '0');
}
}
//再编码数据
j = 0;
for (i = 0; i < InfLen;)
{
*(pBmpBuf + j) = Change2to10(i);
i += 8;
j++;
}
}
/******************************
主函数
******************************/
void Huffmanfunction()
{
int ord;//命令
char c;
int i, j;
clock_t start, finish;
int total_time;
// CString str;
while (1)
{
printf("本程序提供以下功能\n\n\t1.256色灰度BMP图像Huffman编码\n\t2.Huffman编码BMP文件解码\n\t3.退出\n\n请选择需要执行的命令:");
scanf("%d%c", &ord, &c);
if (ord == 1)
{
printf("\n---256色灰度BMP图像Huffman编码---\n");
printf("\n请输入要编码图像名称：");
scanf("%s", str);
//读入指定BMP文件进内存
char readPath[100];
strcpy(readPath, str);
strcat(readPath, ".bmp");
if (readBmp(readPath))
{
int lineByte = (bmpWidth * biBitCount / 8 + 3) / 4 * 4;
if (biBitCount == 8)
{
//编码初始化
HuffmanCodeInit();
//计算每个灰度值出现的次数
for (i = 0; i < bmpHeight; i++)
for (j = 0; j < bmpWidth; j++)
{
lpBuf = (unsigned char *)pBmpBuf + lineByte * i + j;
Num[*(lpBuf)] += 1;
}
//调用编码
start = clock();
HuffmanCode();
finish = clock();
total_time = (finish - start);
printf("识别一张耗时： %d毫秒", total_time);
//将图像数据存盘
char writePath[100];
//保存编码后的bmp
strcpy(writePath, str);
strcat(writePath, "_Huffman.bhd");
saveBmp(writePath, pBmpBuf, bmpWidth, bmpHeight, biBitCount, pColorTable);
//保存Huffman编码信息和编码树
strcpy(writePath, str);
strcat(writePath, "_Huffman.bpt");
saveInfo(writePath, lineByte);
printf("\n编码完成!编码信息保存在 %s_Huffman 文件中\n\n", str);
}
else
{
printf("本程序只支持256色BMP编码！\n");
}
//清除缓冲区，pBmpBuf和pColorTable是全局变量，在文件读入时申请的空间
delete[]pBmpBuf;
if (biBitCount == 8)
delete[]pColorTable;
}
printf("\n-----------------------------------------------\n\n\n");
}
else if (ord == 2)
{
printf("\n---Huffman编码BMP文件解码---\n");
printf("\n请输入要解码文件名称：");
scanf("%s", str);
//编码解码初始化
HuffmanCodeInit();
if (readHuffman(str))
{ //读取文件
HuffmanDecode(); //Huffman解码
//将图像数据存盘
char writePath[100];
//保存解码后的bmp
strcpy(writePath, str);
strcat(writePath, "_Decode.bmp");
InfLen = bmpWidth * bmpHeight * 8;
saveBmp(writePath, pBmpBuf, bmpWidth, bmpHeight, biBitCount, pColorTable);
system(writePath);
printf("\n解码完成!保存为 %s_Decode.bmp\n\n", str);
}
printf("\n-----------------------------------------------\n\n\n");
}
else if (ord == 3)
break;
}
}- 效果图如下：
- （2）、使用DCT变换进行图像压缩
- 其流程图如下：
- 代码如下：
/*DCT压缩*/
void blkproc_DCT(Mat); //功能等同于Matlab的blkproc函数（blkproc(I,[8 8],'P1*x*P2',g,g')），用于对图像做8*8分块DCT
Mat blkproc_IDCT(Mat); //功能等同于Matlab的blkproc函数（blkproc(I,[8 8],'P1*x*P2',g',g)），用于做8*8分块DCT逆变换，恢复原始图像
void regionalCoding(Mat); //区域编码函数，功能等同于Matlab的blkproc函数（blkproc(I1,[8 8],'P1.*x',a)）
void thresholdCoding(Mat); //阈值编码函数，功能等同于Matlab的blkproc函数（blkproc(I1,[8 8],'P1.*x',a)）
double get_medianNum(Mat &); //获取矩阵的中值，用于阈值编码
void ImageCompression_DCT(Mat &ucharImg)
{
//Mat ucharImg = imread("3.jpg", 0); //以灰度图的形式读入原始的图像
//imshow("srcImg", ucharImg);
Mat doubleImg,OrignalImg;
OrignalImg = ucharImg.clone();
ucharImg.convertTo(doubleImg, CV_64F); //将原始图像转换成double类型的图像，方便后面的8*8分块DCT变换
blkproc_DCT(doubleImg); //对原图片做8*8分块DCT变换
//分别进行区域编码和阈值编码
Mat doubleImgRegion, doubleImgThreshold;
doubleImgRegion = doubleImg.clone();
doubleImgThreshold = doubleImg.clone();
regionalCoding(doubleImgRegion); //对DCT变换后的系数进行区域编码
thresholdCoding(doubleImgThreshold); //对DCT变换后的系数进行阈值编码
//进行逆DCT变换
Mat ucharImgRegion, ucharImgThreshold, differenceimage;
ucharImgRegion = blkproc_IDCT(doubleImgRegion);
//namedWindow("RegionalCoding", CV_WINDOW_AUTOSIZE);
imshow("RegionalCoding", ucharImgRegion);
ucharImgThreshold = blkproc_IDCT(doubleImgThreshold);
//namedWindow("ThresholdCoding", CV_WINDOW_AUTOSIZE);
imshow("ThresholdCoding", ucharImgThreshold);
absdiff(ucharImgRegion, OrignalImg, differenceimage);
imshow("两幅图像的差值",differenceimage);
}
void blkproc_DCT(Mat doubleImgTmp)
{
Mat ucharImgTmp;
Mat DCTMat = Mat(8, 8, CV_64FC1); //用于DCT变换的8*8的矩阵
Mat DCTMatT; //DCTMat矩阵的转置
Mat ROIMat = Mat(8, 8, CV_64FC1); //用于分块处理的时候在原图像上面移动
double a = 0, q; //DCT变换的系数
for (int i = 0; i < DCTMat.rows; i++)
{
for (int j = 0; j < DCTMat.cols; j++)
{
if (i == 0)
{
a = pow(1.0 / DCTMat.rows, 0.5);
}
else
{
a = pow(2.0 / DCTMat.rows, 0.5);
}
q = ((2 * j + 1)*i*M_PI) / (2 * DCTMat.rows);
DCTMat.at<double>(i, j) = a * cos(q);
}
}
DCTMatT = DCTMat.t();
//ROIMat在doubleImgTmp以8为步长移动，达到与Matlab中的分块处理函数blkproc相同的效果
//此程序中，若图片的高或者宽不是8的整数倍的话，最后的不足8的部分不进行处理
int rNum = doubleImgTmp.rows / 8;
int cNum = doubleImgTmp.cols / 8;
for (int i = 0; i < rNum; i++)
{
for (int j = 0; j < cNum; j++)
{
ROIMat = doubleImgTmp(Rect(j * 8, i * 8, 8, 8));
ROIMat = DCTMat * ROIMat*DCTMatT;
}
}
doubleImgTmp.convertTo(ucharImgTmp, CV_8U);
imshow("DCTImg", ucharImgTmp);
}
Mat blkproc_IDCT(Mat doubleImgTmp)
{
//与blkproc_DCT几乎一样，唯一的差别在于：ROIMat = DCTMatT*ROIMat*DCTMat（转置矩阵DCTMatT和DCTMat交换了位置）
Mat ucharImgTmp;
Mat DCTMat = Mat(8, 8, CV_64FC1);
Mat DCTMatT;
Mat ROIMat = Mat(8, 8, CV_64FC1);
double a = 0, q;
for (int i = 0; i < DCTMat.rows; i++)
{
for (int j = 0; j < DCTMat.cols; j++)
{
if (i == 0)
{
a = pow(1.0 / DCTMat.rows, 0.5);
}
else
{
a = pow(2.0 / DCTMat.rows, 0.5);
}
q = ((2 * j + 1)*i*M_PI) / (2 * DCTMat.rows);
DCTMat.at<double>(i, j) = a * cos(q);
}
}
DCTMatT = DCTMat.t();
int rNum = doubleImgTmp.rows / 8;
int cNum = doubleImgTmp.cols / 8;
for (int i = 0; i < rNum; i++)
{
for (int j = 0; j < cNum; j++)
{
ROIMat = doubleImgTmp(Rect(j * 8, i * 8, 8, 8));
ROIMat = DCTMatT * ROIMat*DCTMat;
}
}
doubleImgTmp.convertTo(ucharImgTmp, CV_8U);
return ucharImgTmp;
}
void regionalCoding(Mat doubleImgTmp)
{
int rNum = doubleImgTmp.rows / 8;
int cNum = doubleImgTmp.cols / 8;
Mat ucharImgTmp;
Mat ROIMat = Mat(8, 8, CV_64FC1); //用于分块处理的时候在原图像上面移动
for (int i = 0; i < rNum; i++)
{
for (int j = 0; j < cNum; j++)
{
ROIMat = doubleImgTmp(Rect(j * 8, i * 8, 8, 8));
for (int r = 0; r < ROIMat.rows; r++)
{
for (int c = 0; c < ROIMat.cols; c++)
{
//8*8块中，后四行置0
if (r > 4)
{
ROIMat.at<double>(r, c) = 0.0;
}
}
}
}
}
doubleImgTmp.convertTo(ucharImgTmp, CV_8U);
imshow("regionalCodingImg", ucharImgTmp);
}
void thresholdCoding(Mat doubleImgTmp)
{
int rNum = doubleImgTmp.rows / 8;
int cNum = doubleImgTmp.cols / 8;
double medianNumTmp = 0;
Mat ucharImgTmp;
Mat ROIMat = Mat(8, 8, CV_64FC1); //用于分块处理的时候在原图像上面移动
for (int i = 0; i < rNum; i++)
{
for (int j = 0; j < cNum; j++)
{
ROIMat = doubleImgTmp(Rect(j * 8, i * 8, 8, 8));
medianNumTmp = get_medianNum(ROIMat);
for (int r = 0; r < ROIMat.rows; r++)
{
for (int c = 0; c < ROIMat.cols; c++)
{
if (abs(ROIMat.at<double>(r, c)) < 0)
{
ROIMat.at<double>(r, c) = 0;
}
}
}
}
}
doubleImgTmp.convertTo(ucharImgTmp, CV_8U);
imshow("thresholdCodingImg", ucharImgTmp);
}
double get_medianNum(Mat & imageROI) //获取矩阵的中值
{
vector<double> vectorTemp;
double tmpPixelValue = 0;
for (int i = 0; i < imageROI.rows; i++) //将感兴趣区域矩阵拉成一个向量
{
for (int j = 0; j < imageROI.cols; j++)
{
vectorTemp.push_back(abs(imageROI.at<double>(i, j)));
}
}
for (int i = 0; i < vectorTemp.size() / 2; i++) //进行排序
{
for (int j = i + 1; j < vectorTemp.size(); j++)
{
if (vectorTemp.at(i) > vectorTemp.at(j))
{
double temp;
temp = vectorTemp.at(i);
vectorTemp.at(i) = vectorTemp.at(j);
vectorTemp.at(j) = temp;
}
}
}
return vectorTemp.at(vectorTemp.size() / 2 - 1); //返回中值
}效果图如下：
- （3）、图像JPEG的压缩：
- 所用到的库函数：
CV_EXPORTS_W Mat imdecode( InputArray buf, int flags );程序如下：
/*JPEG图片压缩*/
double getPSNR(Mat& src1, Mat& src2, int bb = 0);
void ImageCompression_JPEG(Mat &src)
{
//Mat src = imread("lena.png");
cout << "origin image size: " << src.dataend - src.datastart << endl;
cout << "height: " << src.rows << endl << "width: " << src.cols << endl << "depth: " << src.channels() << endl;
cout << "height*width*depth: " << src.rows*src.cols*src.channels() << endl << endl;
//(1) jpeg compression
vector<uchar> buff;//buffer for coding
vector<int> param = vector<int>(2);
param[0] = CV_IMWRITE_JPEG_QUALITY;
param[1] = 1;//default(95) 0-100
imencode(".jpg", src, buff, param);
cout << "coded file size(jpg): " << buff.size() << endl;//fit buff size automatically.
Mat jpegimage = imdecode(Mat(buff), CV_LOAD_IMAGE_COLOR);
//(2) png compression
param[0] = CV_IMWRITE_PNG_COMPRESSION;
param[1] = 8;//default(3) 0-9.
imencode(".png", src, buff, param);
cout << "coded file size(png): " << buff.size() << endl;
Mat pngimage = imdecode(Mat(buff), CV_LOAD_IMAGE_COLOR);
//(3) intaractive jpeg compression
char name[64];
namedWindow("jpg");
int q = 95;
createTrackbar("quality", "jpg", &q, 100);
int key = 0;
while (key != 'q')
{
param[0] = CV_IMWRITE_JPEG_QUALITY;
param[1] = q;
imencode(".jpg", src, buff, param);
Mat show = imdecode(Mat(buff), CV_LOAD_IMAGE_COLOR);
double psnr = getPSNR(src, show);//get PSNR
double bpp = 8.0*buff.size() / (show.size().area());//bit/pixe;
sprintf_s(name, "quality:%03d, %.1fdB, %.2fbpp", q, psnr, bpp);
putText(show, name, Point(15, 50), FONT_HERSHEY_SIMPLEX, 1, CV_RGB(255, 255, 255), 2);
imshow("jpg", show);
key = waitKey(33);
if (key == 's')
{
//(4) data writing
sprintf_s(name, "q%03d_%.2fbpp.png", q, bpp);
imwrite(name, show);
sprintf_s(name, "q%03d_%.2fbpp.jpg", q, bpp);
param[0] = CV_IMWRITE_JPEG_QUALITY;
param[1] = q;
imwrite(name, src, param);;
}
}
}
double getPSNR(Mat& src1, Mat& src2, int bb)
{
int i, j;
double sse, mse, psnr;
sse = 0.0;
Mat s1, s2;
cvtColor(src1, s1, CV_BGR2GRAY);
cvtColor(src2, s2, CV_BGR2GRAY);
int count = 0;
for (j = bb; j < s1.rows - bb; j++)
{
uchar* d = s1.ptr(j);
uchar* s = s2.ptr(j);
for (i = bb; i < s1.cols - bb; i++)
{
sse += ((d[i] - s[i])*(d[i] - s[i]));
count++;
}
}
if (sse == 0.0 || count == 0)
{
return 0;
}
else
{
mse = sse / (double)(count);
psnr = 10.0*log10((255 * 255) / mse);
return psnr;
}
}效果图如下：
- 主函数如下：
#pragma warning(disable:4996)
#include "opencv2/opencv.hpp"
#include "opencv2/core/core.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "iostream"
#include "fstream"
#include "regex"
#include "string.h"
#include "time.h"
#include "Windows.h"
#include "math.h"
#include "stdio.h"
#define WINDOW_NAME "(【程序窗口1】)"
#define MAX_CHARS 256//最大字符数
#define MAX_SIZE 1000000
#define M_PI 3.141592653
using namespace cv;
using namespace std;
const double EPS = 1e-12;
const double PI = 3.141592653;
class tmpNode
{
public:
unsigned char uch;//取值范围是0~255，用来表示一个8位的字符
unsigned long freq = 0;//字符出现的频率
};
int main()
{
//Mat img = imread("3.jpg", CV_LOAD_IMAGE_GRAYSCALE);
//Mat img = imread("3.jpg", 1);
//Mat img = imread("3.jpg",0);
//Mat img = imread("1.jpg");
//
//Mat img_1 = imread("p3-01-00_Huffman_Decode.bmp");
//Mat differenceimage;
//absdiff(img, img_1, differenceimage);
/*if (img.empty())
{
std::cout << "图片读取失败！" << "\n";
return -1;
}*/
//namedWindow("【原始图像】", CV_WINDOW_AUTOSIZE);
//imshow("【原始图像】", img);
//namedWindow("【压缩后解码图像】", CV_WINDOW_AUTOSIZE);
//imshow("【压缩后解码图像】", img_1);
/*计算直方图判断噪声并且选择相应的滤波器进行滤波*/
//Mat dstImage = GaussianBlurfilterfunction(img);
//Mat dstImage = Blurefilterfunction(img);
//Mat dstImage = MedianBlurfilterfunction(img);
//Mat dstImage = BilateralBlurfilterfunction(img);
//Mat dstImage = Inversefiltering(img);
//namedWindow("【逆滤波图像】", CV_WINDOW_AUTOSIZE);
//imshow("【逆滤波图像】", dstImage);
//Mat img1 = img.clone();
//Drawing_one_dimensionalhistogram(img1);
//Otsusegmentation(img);
//Graphcutfunction(img);
//Watershedfunction(img);
//ImageCompression();
//ImageCompression_DCT(img);
//ImageCompression_JPEG(img);
//Huffmanfunction();
//Mat dstImg = FrequencyDomainGaussFiltering(img);
//Drawing_one_dimensionalhistogram(dstImg);
//grathcutfunctiong(img);
//namedWindow("【原始图像】", CV_WINDOW_AUTOSIZE);
//imshow("【原始图像】", img);
//namedWindow("【差值图像】", CV_WINDOW_AUTOSIZE);
//imshow("【差值图像】", differenceimage);
waitKey(0);
//destroyAllWindows();
return 0;
}完。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
