【开源项目经验】之计算PSNR

最新推荐文章于 2023-06-26 17:25:44 发布
最新推荐文章于 2023-06-26 17:25:44 发布
阅读量472 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/listener51/article/details/89320426
版权

1、计算PNSR

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <math.h> 
 

//计算MSE及PSNR
float cal_psnr(unsigned char *yuv0, unsigned char *yuv1, int stride_yuv0, int stride_yuv1, int width, int height)
{
	int i, j;
	double diff;
	double diff_sum = 0.0;
	unsigned int max_pix_value_sqd[3] = {255*255, 255*255, 255*255};
	
	for(j = 0; j < height; j++)
	{
		for (i = 0; i < width; i++)
		{
			diff = *(yuv0 + j * stride_yuv0 + i) - *(yuv1 + j * stride_yuv1 + i);
			diff_sum += diff * diff;
		}
	}
	return (float)(diff_sum  == 0.0 ? 100.0:(10.0 * log10(max_pix_value_sqd[0] * (double)((double)(width * height) / diff_sum))));
}


//src0.yuv width height src1.yuv
int main(int argc, char **argv)
{
	FILE *pYUVSrc0, *pYUVSrc1;
	FILE *pYUVDst0, *pYUVDst1;
	unsigned char *u8YUVSrc0, *u8YUVSrc1;
	
	int ret;
	int frameIdx = 0;
	int iwidth, iheight, iframeSize;
	double psnr[3] = {0.0, 0.0, 0.0};
	char dstYUVName[2][256];
	
	iwidth  = atoi(argv[2]);	//YUV文件的宽
	iheight = atoi(argv[3]);	//YUV文件的高
	iframeSize = iwidth * iheight * 3 / 2; //YUV的一帧大小

	pYUVSrc0 = fopen(argv[1], "rb"); //打开输入YUV文件1
	pYUVSrc1 = fopen(argv[4], "rb"); //打开输入YUV文件2


	u8YUVSrc0 = (unsigned char*)malloc(iframeSize * sizeof(unsigned char));
	u8YUVSrc1 = (unsigned char*)malloc(iframeSize * sizeof(unsigned char));

	sprintf(&dstYUVName[0][0], "%s%s", argv[1], "_onlyY.yuv");
	sprintf(&dstYUVName[1][0], "%s%s", argv[2], "_onlyY.yuv");

	pYUVDst0 = fopen(dstYUVName[0], "wb"); //打开输出YUV文件1
	pYUVDst1 = fopen(dstYUVName[1], "wb"); //打开输出YUV文件2

	while(1)
	{
		ret = fread(u8YUVSrc0, 1, iframeSize, pYUVSrc0);
		if(ret == 0){ //等于0，表示YUV0文件已经读完了
			break;
		} 
		ret = fread(u8YUVSrc1, 1, iframeSize, pYUVSrc1);
		if(ret == 0){ //等于0，表示YUV1文件已经读完了
			break;
		} 
		psnr[0] = cal_psnr(u8YUVSrc0, u8YUVSrc1, iwidth, iwidth, iwidth, iheight); //Y
		psnr[1] = cal_psnr(u8YUVSrc0 + iwidth * iheight, u8YUVSrc1 + iwidth * iheight, iwidth / 2, iwidth / 2, iwidth / 2, iheight / 2); //U
		psnr[2] = cal_psnr(u8YUVSrc0 + iwidth * iheight * 5 / 4, u8YUVSrc1 + iwidth * iheight * 5 / 4, iwidth / 2, iwidth / 2, iwidth / 2, iheight / 2); //V	
		
		memset(u8YUVSrc0 + iwidth * iheight, 0, iwidth * iheight / 2 * sizeof(unsigned char));
		memset(u8YUVSrc1 + iwidth * iheight, 0, iwidth * iheight / 2 * sizeof(unsigned char));
		fwrite(u8YUVSrc0, 1, iframeSize, pYUVDst0);
		fwrite(u8YUVSrc1, 1, iframeSize, pYUVDst1);
		printf("Frame Idx: %d Y-PSNR: %4.3f , U-PSNR: %4.3f, V-PSNR: %4.3f\n", frameIdx++, psnr[0],  psnr[1],  psnr[2]);
	}
	fclose(pYUVSrc0);
	fclose(pYUVSrc1);
	fclose(pYUVDst1);
	fclose(pYUVDst1);
	free(u8YUVSrc0);
	free(u8YUVSrc1);	
}

2、YUV420上采样

/*  
* File:        scale.c  
* Description: scale YUV420 video frames with cubic, bilinear & cubic convolution interpolation algorithms  
*              highly optimized algorithm  
*/   
   
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <math.h> 
  
#define ABS(x) (x > 0 ? (x) : (-x))  
#define clip(a, min, max) (a > max ? max : (a > min ? a : min))  
#define INTEGER 1  
#define NO_CB	1//色度分量直接赋值为0
  

int gcd(int a, int b)  
{  
    if(b)   
    {  
        return gcd(b, a%b);  
    }  
    else    
    {  
        return a;  
    }  
}  
  

  
int scale(unsigned char algorithm,  
           int input_pixel_format,   
           unsigned char *pYIn, int lineY,   
           unsigned char *pCbIn, int lineCb,   
           unsigned char *pCrIn, int lineCr,   
           int srcWidth, int srcHeight,   
           int outWidth, int outHeight,  
           int output_pixel_format,   
           unsigned char *pYOut,   
           unsigned char *pCbOut,   
           unsigned char *pCrOut)  
{  
    float rx = (float)outWidth/(float)srcWidth;  
    float ry = (float)outHeight/(float)srcHeight;  
    int x = 0, y = 0;  
    int xx = 0, yy = 0;  
    int outWidth_cr = outWidth / 2;  
    int outHeight_cr = outHeight / 2;  
    int srcWidth_cr = srcWidth / 2;  
    int srcHeight_cr = srcHeight / 2;  
    float c0, c1, c2, c3;  

    unsigned char *p = NULL, *p1 = NULL;  
  
    int *C0=NULL, *C1=NULL, *C2=NULL, *C3=NULL;  
    unsigned char* pend = pYIn + lineY * srcHeight - 1;  
      
    int x_ratio = (int) (((srcWidth - 1) << 8) / outWidth);  
    int y_ratio = (int) (((srcHeight - 1) << 8) / outHeight);   
  
    // Rational ratio  
    int gcdw = gcd(outWidth, srcWidth);  
    int gcdh = gcd(outHeight, srcHeight);  
    int rx_num = outWidth/gcdw;  
    int rx_den = srcWidth/gcdw;  
    int ry_num = outHeight/gcdh;  
    int ry_den = srcHeight/gcdh;  
  
    switch(algorithm)  
    {  
        case 0:  
            // cubic  
            for(y=0; y<outHeight; y++)  
            {  
                for(x=0; x<outWidth; x++)  
                {  
                    //g(x, y) = f(x/r, y/r) = f(x*rx_den/rx_num, y*ry_den/ry_num)  
                    xx = clip((int)((float)x / rx), 0, srcWidth-1);  
                    yy = clip((int)((float)y / ry), 0, srcHeight-1);  
                    pYOut[y*outWidth+x] = pYIn[yy*lineY + xx];  
                }  
            }  
            for(y=0; y<outHeight_cr; y++)  
            {  
                for(x=0; x<outWidth_cr; x++)  
                {  
                    //g(x, y) = f(x/r, y/r) = f(x*rx_den/rx_num, y*ry_den/ry_num)  
                    xx = clip((int)((float)x / rx), 0, srcWidth_cr-1);  
                    yy = clip((int)((float)y / ry), 0, srcHeight_cr-1);  
                    pCbOut[y*outWidth_cr+x] = pCbIn[yy*lineCb + xx];  
                }  
            }  
            for(y=0; y<outHeight_cr; y++)  
            {  
                for(x=0; x<outWidth_cr; x++)  
                {  
                    //g(x, y) = f(x/r, y/r) = f(x*rx_den/rx_num, y*ry_den/ry_num)  
                    xx = clip((int)((float)x / rx), 0, srcWidth_cr-1);  
                    yy = clip((int)((float)y / ry), 0, srcHeight_cr-1);  
					pCrOut[y*outWidth_cr+x] = pCrIn[yy*lineCr + xx];  
                }  
            }  
            break;  
        case 1:  
            // bilinear  
            for(y=0; y<outHeight; y++)  
            {  
                for(x=0; x<outWidth; x++)  
                {  
                    //g(x, y) = (1-c0)(1-c2)f(xx,yy) + (1-c2)(1-c1)f(xx,yy+1) + (1-c1)(1-c3)f(xx+1,yy) + (1-c0)(1-c3)f(xx+1,yy+1)  
                    c0 = (((float)y / ry) - (int)((float)y / ry));  
                    c1 = ((int)((float)y / ry) + 1 - ((float)y / ry));  
                    c2 = (((float)x / rx) - (int)((float)x / rx));  
                    c3 = ((int)((float)x / rx) + 1 - ((float)x / rx));  
                    xx = clip((int)((float)x / rx), 0, srcWidth-1);  
                    yy = clip((int)((float)y / ry), 0, srcHeight-1);  
                    pYOut[y*outWidth+x] = (float)((1.0-c0)*(1.0-c2)*pYIn[yy*lineY+xx]   
                                                + (1.0-c1)*(1.0-c2)*pYIn[clip(yy+1,0,srcHeight-1)*lineY+xx]   
                                                + (1.0-c1)*(1.0-c3)*pYIn[yy*lineY+clip(xx,0,srcWidth-1)]  
                                                + (1.0-c0)*(1.0-c3)*pYIn[clip(yy+1,0,srcHeight-1)*lineY+clip(xx,0,srcWidth-1)]);  
                }  
            }  
            for(y=0; y<outHeight_cr; y++)  
            {  
                for(x=0; x<outWidth_cr; x++)  
                {  
                    c0 = (((float)y / ry) - (int)((float)y / ry));  
                    c1 = ((int)((float)y / ry) + 1 - ((float)y / ry));  
                    c2 = (((float)x / rx) - (int)((float)x / rx));  
                    c3 = ((int)((float)x / rx) + 1 - ((float)x / rx));  
                    xx = clip((int)((float)x / rx), 0, srcWidth_cr-1);  
                    yy = clip((int)((float)y / ry), 0, srcHeight_cr-1); 
                    pCbOut[y*outWidth_cr+x] = (float)((1.0-c0)*(1.0-c2)*pCbIn[yy*lineCb+xx]   
                                                + (1.0-c1)*(1.0-c2)*pCbIn[clip(yy+1,0,srcHeight_cr-1)*lineCb+xx]   
                                                + (1.0-c1)*(1.0-c3)*pCbIn[yy*lineCb+clip(xx,0,srcWidth_cr-1)]  
                                                + (1.0-c0)*(1.0-c3)*pCbIn[clip(yy+1,0,srcHeight_cr-1)*lineCb+clip(xx,0,srcWidth_cr-1)]); 
                }  
            }  
            for(y=0; y<outHeight_cr; y++)  
            {  
                for(x=0; x<outWidth_cr; x++)  
                {  
                    c0 = (((float)y / ry) - (int)((float)y / ry));  
                    c1 = ((int)((float)y / ry) + 1 - ((float)y / ry));  
                    c2 = (((float)x / rx) - (int)((float)x / rx));  
                    c3 = ((int)((float)x / rx) + 1 - ((float)x / rx));  
                    xx = clip((int)((float)x / rx), 0, srcWidth_cr-1);  
                    yy = clip((int)((float)y / ry), 0, srcHeight_cr-1);  
                    pCrOut[y*outWidth_cr+x] = (float)((1.0-c0)*(1.0-c2)*pCrIn[yy*lineCr+xx]   
                                                + (1.0-c1)*(1.0-c2)*pCrIn[clip(yy+1,0,srcHeight_cr-1)*lineCr+xx]   
                                                + (1.0-c1)*(1.0-c3)*pCrIn[yy*lineCr+clip(xx,0,srcWidth_cr-1)]  
                                                + (1.0-c0)*(1.0-c3)*pCrIn[clip(yy+1,0,srcHeight_cr-1)*lineCr+clip(xx,0,srcWidth_cr-1)]);  
                }  
            }  
            break;  
        default:  
            printf("Not supported scaling algorithm\n");  
            return -1;  
    }    
      
    return 0;  
}  
int main(int argc, char** argv)  
{  
    int w, h, tw, th;  
    FILE* fin=NULL, *fout=NULL;  
    unsigned char* src=NULL;  
    unsigned char* dst=NULL;  
    int algorithm = 0; 
    int frameidx = 0; 
  
    if(argc != 8)  
    {  
        printf("Usage: <%s> <in file> <out file> <src width> <src height> <target width> <target height> <algorithm>\n", argv[0]);  
        printf("Algorithm list: 0--cubic, 1--bilinear\n");  
        return -1;  
    }  
  
    fin = fopen(argv[1], "rb");  
    fout = fopen(argv[2], "wb");  
    if(!fin || !fout)  
    {  
        printf("File Open Fail!\n");  
        return -1;  
    }  
    w = atoi(argv[3]);  
    h = atoi(argv[4]);  
    tw = atoi(argv[5]);  
    th = atoi(argv[6]);  
    algorithm = atoi(argv[7]);  
    src = (unsigned char*)malloc(w*h*3/2);  
    dst = (unsigned char*)malloc(tw*th*3/2);  
    memset(dst, 0, tw*th);  
    memset(dst, 0, tw*th/2);  
   
    fseek(fin, 0, SEEK_SET);  
    while( fread(src, 1, w*h*3/2, fin)!= 0)
   {
       // scale   
       scale(algorithm, 420, src, w, src+w*h, w/2, src+w*h*5/4, w/2, w, h, tw, th, 420, dst, dst+tw*th, dst+tw*th*5/4);  
  
       fwrite(dst, 1, tw*th*3/2, fout); 
       printf("%d successful\n", frameidx++);
   }
 
    if(fin)fclose(fin);  
    if(fout)fclose(fout);  
    if(src)free(src);  
    if(dst)free(dst);  
    return 0;  
}

摘抄网址：http://read.pudn.com/downloads505/sourcecode/graph/texture_mapping/2100905/scale.c__.htm

walkingMa
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
psnr C语言代码
08-20
标签: psnr C语言代码
计算PSNR的源代码。
lilisalo
09-01 610
#include "math.h" #include &lt;io.h&gt; #include &lt;stdio.h&gt; #include &lt;string.h&gt; int psnr_calculate(const char *raw,const char * compressed, char *filewrite, const int width_arg,const in...
PSNR的计算
fangbaolei2088的专栏
04-07 6597
2010-01-22 22:11 PSNR（Peak Signalto Noise Ratio）：峰值信噪比 峰值信噪比（PSNR），一种评价图像的客观标准。它具有局限性，PSNR是 “PeakSignaltoNoiseRatio”的缩写。peak的中文意思是顶点。而radio的意思是比率或比列的。整个意思就是到达噪音比率的顶 点信号，psnr是一般是用于最大值信号和背
计算两幅图象PSNR值
12-14
方便计算两幅图象的峰值信噪比 对去噪等很有用
c++实现差分预测编码DPCM以及PSNR的计算
weixin_45101561的博客
05-05 389
编程需要知道的知识点： 我们这次实现左向预测DPCM 对于第一列像素点，我们假设它左边的像素点值为128，先用第一列原始图像像素点的值减去128，得到当前位置的残差，再用当前位置的残差加上左边的像素点值，得到当前位置的重建图像像素点。 对于其他像素点，我们用当前位置的原始图像像素点的值减去重建图像当前位置左边那个像素点，得到当前位置的残差，再用当前位置得到的残差加上重建图像当前位置左边那个像素点的值，得到当前位置的重建图像像素点 量化 对于每一个残差像素点的量化具体实现为： 由于残差的取值范围为-255~
PSNR.rar_PSNR_psnr计算
09-19
3. **计算MSE**：遍历两幅图像的每个像素，计算像素值之差的平方，然后求平均值。 4. **计算PSNR**：根据上面的公式，利用MSE计算PSNR值。 5. **输出结果**：将计算得到的PSNR值打印到控制台或者写入文件。 **应用...
psnr.rar_PSNR_scale453_计算psnr
07-15
计算峰值信噪比，很快，很好用，啦啦啦，很棒，帮帮帮
code5_计算psnr_图像去噪_
10-02
在"code5_计算psnr_图像去噪_"这个项目中，我们聚焦于如何计算彩色图像的PSNR，并应用到图像去噪的实践中。 首先，了解PSNR的基本概念。PSNR是信号强度与噪声强度之比的对数值，通常以分贝（dB）为单位表示。公式为...
基于python和opencv实现图像拼接并计算PSNR项目源码+项目使用说明.zip
最新发布
07-24
基于python和opencv实现图像拼接并计算PSNR项目源码+项目使用说明.zip 该项目是个人毕设项目，答辩评审分达到95分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。 该资源主要针对计算机...
计算PSNR和SSIM C++代码
10-28
在提供的压缩包文件中，"计算PSNR和SSIM"可能是包含C++源代码的文件，包括图像读取、像素操作、统计计算等功能。通过阅读和理解这段代码，你可以学习到如何在实际项目中应用这些理论知识，从而提升自己的图像处理...
PSNR测评工具
12-27
PSNR测评工具，它视频编码方面支持H.264，MPEG-4和H.263。
图像PSNR及其计算（matlab实现）
05-27
图像PSNR及其计算（matlab实现版本） http://blog.csdn.net/laoxuan2011/article/details/51519062
opencv c++ mse和psnr
10-16
使用opencv 和c++ 计算图片的mse和psnr
VideoPSNR批处理
11-17
批处理计算一段yuv格式视频的PSNR质量值，可计算出每一帧和全部帧的平均PSNR值，输出在txt文档中
计算两幅图像的PSNR
04-25
能够计算前后两幅图像的PNSR，运行简单，处理方便
图像质量评估指标——PSNR介绍及计算方法
qq_50001789的博客
06-26 7831
PSNR全称为Peak Signal to Noise Ratio，即峰值信噪比，是一种评价图像的客观标准，经常用于计算两幅图像的可视化误差，如衡量原图与经过压缩后图像之间的可视化差异、生成网络生成的图像与真实图像之间的差异等等。
(python)计算图像峰值信噪比-PSNR、结构相似度-SSIM
hsdujdjrjrj的博客
11-15 4890
【代码】(python)计算图像峰值信噪比-PSNR、结构相似度-SSIM（包含计算YCbCr格式图片的PSNR）。
图像处理PSNR及其计算（OpenCV和matlab实现）
热门推荐
无机器不学习-加大码先森的分享
05-27 5万+
图像PSNR及其计算OpenCV和matlab实现 PSNR的概念 PSNR编程实现 matlab实现 第一种实现方法 第二种实现方法 OpenCV实现图像PSNR及其计算（OpenCV和matlab实现） 引言：在图像处理中，要对图像进行客观的评价，常常需要引入PSNR等概念，本文将简单介绍PSNR的定义，并给出相关的源代码。 PSNR的概念 PSNR (Peak Signal to Noi
Python计算两张图的PSNR值
weixin_43981621的博客
12-21 1万+
Python计算两张图的PSNR值     本文主要记录如何用python实现求解两张图的PSNR值。 目录Python计算两张图的PSNR值1.PSNR求解公式2.完整的PSNR求解代码3.运算结果展示4.参考文献 1.PSNR求解公式     （1）对于三通道的RGB图像 计算MSE的数学表达式是：     具体的代码为： # compute MSE mse = np.mean((img1/1.0-img2/1.0)**2)     （2）得到MSE后计算PSNR，具体数学表达式为：     具体
python计算psnr
07-09
在Python中，可以使用以下代码计算PSNR： ```python import cv2 import numpy as np def compute_psnr(original_img, compressed_img): # 读取图像 img1 = cv2.imread(original_img) img2 = cv2.imread...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值