• 利用保存好的图片进行PSNR测试


    from util_ import calc_psnr_and_ssim
    import torch
    import numpy as np
    from glob import glob #import glob是错的
    import os
    from PIL import Image
    from torchvision import transforms
    # path = './data/test/MIDDLEBURY/'
    # file_list = sorted(glob(os.path.join(path,'*L.png')))
    # file_list_ref= sorted(glob(os.path.join(path,'*R.png')))
    # for i in range(len(file_list)):
    #     print(file_list[i])
    #     print(file_list_ref[i])
    #
    trans = transforms.Compose([
        # transforms.Resize((256, 256)),
        transforms.ToTensor(),
        # transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
    ])
    psnr_list = []
    
    ssim_list = []
    # sr_list = sorted(glob(
    #             os.path.join('/home/cl/DRN_zxy/DRN-master/experiments/results/epoch800/%s/x4'%datasets[j],'*L.*')))
    # hr_list = sorted(glob(
    #             os.path.join('/home/cl/DRN_zxy/DRN-master/srdata/benchmark/%s/HR'%datasets[j],'*L.*')))
    sr_list = sorted(glob(
                os.path.join('/root/userfolder/SRNTT-master/SRNTT-master/SR','*.png')))
    
    hr_list = sorted(glob(
                os.path.join('/root/userfolder/SRNTT-master/SRNTT-master/data/test/Set13','*.png')))
    
    for i in range(len(hr_list)):
    
        path_sr = sr_list[i]
        path_hr = hr_list[i]
        print(path_sr)
        print(path_hr)
        SR_left = Image.open(path_sr).convert('RGB')
    
        HR_left = Image.open(path_hr).convert('RGB')
    
        SR_left = trans(SR_left)
        HR_left = trans(HR_left)
        # print('SR',SR_left)
        # print('HR',HR_left)
        SR_left = torch.unsqueeze(SR_left,0)
    
        HR_left = torch.unsqueeze(HR_left, 0)
        psnr, ssim  = calc_psnr_and_ssim(SR_left.detach(), HR_left.detach())
        print(psnr,ssim)
        # SR_left = torch.unsqueeze(SR_left,0)
    
    
    
        # HR_left = torch.unsqueeze(HR_left, 0)
    
        psnr_list.append(psnr)
    
        ssim_list.append(ssim)
    # print( 'mean psnr:',float(np.array(psnr_list).mean()))
    # print( 'mean ssim:',float(np.array(ssim_list).mean()))
    print( 'mean psnr:',float(np.array(psnr_list).mean()))
    print( 'mean ssim:',float(np.array(ssim_list).mean()))
    import math
    import numpy as np
    import logging
    import cv2
    import os
    import shutil
    
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    def calc_psnr(img1, img2):
        ### args:
        # img1: [h, w, c], range [0, 255]
        # img2: [h, w, c], range [0, 255]
        diff = (img1 - img2) / 255.0
        diff[:, :, 0] = diff[:, :, 0] * 65.738 / 256.0
        diff[:, :, 1] = diff[:, :, 1] * 129.057 / 256.0
        diff[:, :, 2] = diff[:, :, 2] * 25.064 / 256.0
    
        diff = np.sum(diff, axis=2)
        mse = np.mean(np.power(diff, 2))
        return -10 * math.log10(mse)
    
    
    def calc_ssim(img1, img2):
        def ssim(img1, img2):
            C1 = (0.01 * 255) ** 2
            C2 = (0.03 * 255) ** 2
    
            img1 = img1.astype(np.float64)
            img2 = img2.astype(np.float64)
            kernel = cv2.getGaussianKernel(11, 1.5)
            window = np.outer(kernel, kernel.transpose())
    
            mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5]  # valid
            mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5]
            mu1_sq = mu1 ** 2
            mu2_sq = mu2 ** 2
            mu1_mu2 = mu1 * mu2
            sigma1_sq = cv2.filter2D(img1 ** 2, -1, window)[5:-5, 5:-5] - mu1_sq
            sigma2_sq = cv2.filter2D(img2 ** 2, -1, window)[5:-5, 5:-5] - mu2_sq
            sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2
    
            ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) *
                                                                    (sigma1_sq + sigma2_sq + C2))
            return ssim_map.mean()
    
        ### args:
        # img1: [h, w, c], range [0, 255]
        # img2: [h, w, c], range [0, 255]
        # the same outputs as MATLAB's
        border = 0
        img1_y = np.dot(img1, [65.738, 129.057, 25.064]) / 256.0 + 16.0
        img2_y = np.dot(img2, [65.738, 129.057, 25.064]) / 256.0 + 16.0
        if not img1.shape == img2.shape:
            raise ValueError('Input images must have the same dimensions.')
        h, w = img1.shape[:2]
        img1_y = img1_y[border:h - border, border:w - border]
        img2_y = img2_y[border:h - border, border:w - border]
    
        if img1_y.ndim == 2:
            return ssim(img1_y, img2_y)
        elif img1.ndim == 3:
            if img1.shape[2] == 3:
                ssims = []
                for i in range(3):
                    ssims.append(ssim(img1, img2))
                return np.array(ssims).mean()
            elif img1.shape[2] == 1:
                return ssim(np.squeeze(img1), np.squeeze(img2))
        else:
            raise ValueError('Wrong input image dimensions.')
    
    
    def calc_psnr_and_ssim(sr, hr):
        ### args:
        # sr: pytorch tensor, range [-1, 1]
        # hr: pytorch tensor, range [-1, 1]
    
        ### prepare data
        # sr = (sr + 1.) * 127.5
        # hr = (hr + 1.) * 127.5
        sr = sr*255.
        hr = hr*255.
        if (sr.size() != hr.size()):
            h_min = min(sr.size(2), hr.size(2))
            w_min = min(sr.size(3), hr.size(3))
            sr = sr[:, :, :h_min, :w_min]
            hr = hr[:, :, :h_min, :w_min]
    
        img1 = np.transpose(sr.squeeze().round().cpu().numpy(), (1, 2, 0))
        img2 = np.transpose(hr.squeeze().round().cpu().numpy(), (1, 2, 0))
    
        psnr = calc_psnr(img1, img2)
        ssim = calc_ssim(img1, img2)
    
        return psnr, ssim

    具体的计算方式可以自己选择,方法统一就好

  • 相关阅读:
    图像切割之(五)活动轮廓模型之Snake模型简单介绍
    拓扑排序的原理及事实上现
    理解class.forName()
    Java中StringBuilder的清空方法比較
    Java实现BASE64编解码
    KMP算法具体解释(贴链接)
    基于PCM2912a的USB声卡设计
    51. 腾讯面试题:一个二叉树,中序遍历,找一个节点的后一个节点
    Handler和HandlerThread
    Nuget-QRCode:jquery-qrcode
  • 原文地址:https://www.cnblogs.com/tingtin/p/14771690.html
Copyright © 2020-2023  润新知