def vif(sources, estimated, image_size, permutation): estimated_copy = np.copy(estimated) sources_copy = np.copy(sources) estimated1, estimated2 = unflatten(estimated_copy, image_size) source1, source2 = unflatten(sources_copy, image_size) if permutation: vif1 = vifp(source1, estimated2) vif2 = vifp(source2, estimated1) else: vif1 = vifp(source1, estimated1) vif2 = vifp(source2, estimated2) return vif1, vif2
def image_quality_evaluation(sr_filename: str, hr_filename: str, device: torch.device = "cpu"): """Image quality evaluation function. Args: sr_filename (str): Image file name after super resolution. hr_filename (str): Original high resolution image file name. device (optional, torch.device): Selection of data processing equipment in PyTorch. (Default: ``cpu``). Returns: If the `simple` variable is set to ``False`` return `mse, rmse, psnr, ssim, msssim, niqe, sam, vifp, lpips`, else return `psnr, ssim`. """ # Reference sources from `https://github.com/richzhang/PerceptualSimilarity` lpips_loss = lpips.LPIPS(net="vgg", verbose=False).to(device) # Evaluate performance sr = cv2.imread(sr_filename) hr = cv2.imread(hr_filename) # For LPIPS evaluation sr_tensor = opencv2tensor(sr, device) hr_tensor = opencv2tensor(hr, device) # Complete estimate. mse_value = mse(sr, hr) rmse_value = rmse(sr, hr) psnr_value = psnr(sr, hr) ssim_value = ssim(sr, hr) msssim_value = msssim(sr, hr) niqe_value = niqe(sr_filename) sam_value = sam(sr, hr) vifp_value = vifp(sr, hr) lpips_value = lpips_loss(sr_tensor, hr_tensor) return mse_value, rmse_value, psnr_value, ssim_value, msssim_value, niqe_value, sam_value, vifp_value, lpips_value
def uqi_vif(path_true, path_pred): UQI = [] VIF = [] names = [] index = 1 files = list(glob(path_true + '/*.jpg')) + list(glob(path_true + '/*.png')) for fn in sorted(files): name = basename(str(fn)) names.append(name) img_gt = (imread(str(fn)) / 255.0).astype(np.float32) img_pred = (imread(path_pred + '/' + basename(str(fn))) / 255.0).astype(np.float32) img_gt = rgb2gray(img_gt) img_pred = rgb2gray(img_pred) UQI.append(uqi(img_gt, img_pred)) VIF.append(vifp(img_gt, img_pred)) if np.mod(index, 100) == 0: print( str(index) + ' images processed', "UQI: %.4f" % round(np.mean(UQI), 4), "VIF: %.4f" % round(np.mean(VIF), 4), ) index += 1 UQI = np.mean(UQI) VIF = np.mean(VIF) return UQI, VIF
def metrics(rec,ref): ssim = np.zeros(rec.shape[0]) psnr = np.zeros(rec.shape[0]) vif = np.zeros(rec.shape[0]) for ii in range(rec.shape[0]): data_range = np.maximum(ref[ii].max(),rec[ii].max()) - np.minimum(ref[ii].min(),rec[ii].min()) ssim[ii] = structural_similarity(ref[ii],rec[ii],data_range= data_range) psnr[ii] = peak_signal_noise_ratio(ref[ii],rec[ii],data_range= data_range) vif[ii] = vifp(ref[ii],rec[ii],sigma_nsq = 0.4) return ssim,psnr,vif
def get_metrics(compression_model: BaseModel, original_image: np.ndarray) -> Dict[str, float]: compressed_image = compression_model.compress(original_image) decompressed_image = compression_model.decompress(compressed_image) return { "mse": mse(original_image, decompressed_image), "ssim": ssim(original_image, decompressed_image)[0], "vif-p": vifp(original_image, decompressed_image), "psnr-b": psnrb(original_image, decompressed_image), "psnr": psnr(original_image, decompressed_image), "original_image_size": asizeof.asizeof(original_image), "compressed_image_size": asizeof.asizeof(compressed_image), "compression_ratio": asizeof.asizeof(compressed_image) / asizeof.asizeof(original_image) }
def mm(y1): t1, t2, t3, t4, t5, t6 = [], [], [], [], [], [] for i in range(32): t1.append(uqi(batch2[i + y1], d2[i + y1])) t2.append(mse(batch2[i + y1], d2[i + y1])) #t3.append(rmse(batch2[i],d2[i])) t6.append(vifp(batch2[i + y1], d2[i + y1])) #print("Structural Similarity Index (SSIM) is %0.3f" % np.mean(f)) # Good #print("Universal Quality Image Index (UQI) is %0.3f" % np.mean(t1)) # Good #print("Mean Squared Error (MSE) is %0.3f" % np.mean(t2) ) # Good #print("Visual Information Fidelity (VIF) is %0.3f" % np.mean(t6) ) # Good #print("Root Mean Sqaured Error (RMSE) is %0.3f" % np.mean(t3)) # Good #print("Spatial Correlation Coefficient (SCC) is %0.3f" % np.mean(t4) ) #print("Spectral Angle Mapper (SAM) is %0.3f" % np.mean(t5) ) return (np.mean(t1), np.mean(t2), np.mean(t6))
def metrics(rec, ref): ssim = np.zeros(rec.shape[0]) psnr = np.zeros(rec.shape[0]) vif = np.zeros(rec.shape[0]) for ii in range(rec.shape[0]): ssim[ii] = structural_similarity(ref[ii], rec[ii], data_range=(ref[ii].max() - ref[ii].min())) psnr[ii] = peak_signal_noise_ratio(ref[ii], rec[ii], data_range=(ref[ii].max() - ref[ii].min())) vif[ii] = vifp(ref[ii], rec[ii]) return ssim, psnr, vif
def obtain_similarity_metrics(GT_img, distorted_img): # MEAN SQUARED ERROR mse_value = mse(GT_img, distorted_img) # STRUCTURAL SIMILARITY ssim_value = ssim(GT_img, distorted_img) # PEAK SIGNAL TO NOISE RATIO psnr_value = psnr(GT_img, distorted_img) # ROOT MEAN SQUARED ERROR rmse_value = rmse(GT_img, distorted_img) # VISUAL INFORMATION FIDELITY vif_value = vifp(GT_img, distorted_img) # UNIVERSAL IMAGE QUALITY INDEX uqi_value = uqi(GT_img, distorted_img) # MULTI-SCALE STRUCTURAL SIMILARITY INDEX msssim_value = msssim(GT_img, distorted_img) # PSNR-HVS-M & PSNR-HVS p_hvs_m, p_hvs = psnrhmam.color_psnrhma(GT_img, distorted_img) return mse_value, ssim_value, psnr_value, rmse_value, vif_value, uqi_value, msssim_value, p_hvs_m, p_hvs
#Universal image quality index """calculates universal image quality index (uqi). :param GT: first (original) input image. :param P: second (deformed) input image. :param ws: sliding window size (default = 8). :returns: float -- uqi value. """ UQI_img = full_ref.uqi(ref_img, img, ws=8) print("UQI: universal image quality index = ", UQI_img) ############################################################################## #Pixel Based Visual Information Fidelity (vif-p) """calculates Pixel Based Visual Information Fidelity (vif-p). :param GT: first (original) input image. :param P: second (deformed) input image. :param sigma_nsq: variance of the visual noise (default = 2) :returns: float -- vif-p value. """ VIFP_img = full_ref.vifp(ref_img, img, sigma_nsq=2) print("VIFP: Pixel Based Visual Information Fidelity = ", VIFP_img)
def calc_vif(img1, img2): return vifp(img1, img2)
# imageio.imsave("truth/t_"+imageNameList[i],trImg) bestImage = deepcopy(trImg) maxPsnr = 0 maxSsim = 0 maxVif = 0 maxfit = -1000 for iteration in range(1): outputImage, fitval = bmoIE(truthName, popSize, maxIter) truthImage = cv2.imread(truthName, 0) psnrval = cv2.PSNR(truthImage, outputImage) psnrval /= 100 ssimval = ssim(truthImage, outputImage) vifval = vifp(truthImage, outputImage) print(iteration, psnrval, ssimval, vifval, int((psnrval + ssimval + vifval) * 100)) total = psnrval + ssimval + vifval if total > maxfit: maxfit = total maxPsnr = psnrval maxSsim = ssimval maxVif = vifval bestImage = deepcopy(outputImage) averagePsnr += maxPsnr averageSsim += maxSsim averageVif += maxVif print(i + 1, averagePsnr, averageSsim, averageVif)
out_img_cb = cb.resize(out_image_y.size, Image.BICUBIC) out_img_cr = cr.resize(out_image_y.size, Image.BICUBIC) out_img = Image.merge("YCbCr", [out_image_y, out_img_cb, out_img_cr]).convert("RGB") # before converting the result in RGB out_img.save(f"result/{filename}") # Evaluate performance src_img = cv2.imread(f"result/{filename}") dst_img = cv2.imread(f"{target}/{filename}") total_mse_value += mse(src_img, dst_img) total_rmse_value += rmse(src_img, dst_img) total_psnr_value += psnr(src_img, dst_img) total_ssim_value += ssim(src_img, dst_img) total_ms_ssim_value += msssim(src_img, dst_img) total_niqe_value += cal_niqe(f"result/{filename}") total_sam_value += sam(src_img, dst_img) total_vif_value += vifp(src_img, dst_img) total_file += 1 print(f"Avg MSE: {total_mse_value / total_file:.2f}\n" f"Avg RMSE: {total_rmse_value / total_file:.2f}\n" f"Avg PSNR: {total_psnr_value / total_file:.2f}\n" f"Avg SSIM: {total_ssim_value / total_file:.4f}\n" f"Avg MS-SSIM: {total_ms_ssim_value / total_file:.4f}\n" f"Avg NIQE: {total_niqe_value / total_file:.2f}\n" f"Avg SAM: {total_sam_value / total_file:.4f}\n" f"Avg VIF: {total_vif_value / total_file:.4f}")
print("uqi: ", uqi) psnr = psnr(img1, img2) print("psnr: ", psnr) ssim = ssim(img1, img2) print("ssim: ", ssim) mse = mse(img1, img2) print("mse: ", mse) rmse_sw = rmse_sw(img1, img2) # print("rmse_sw: ", rmse_sw) ergas = ergas(img1, img2) print("ergas: ", ergas) scc = scc(img1, img2) print("scc: ", scc) rase = rase(img1, img2) print("ergas: ", rase) sam = sam(img1, img2) print("sam: ", sam) msssim = msssim(img1, img2) print("msssim: ", msssim) vifp = vifp(img1, img2) print("vifp: ", vifp)
def compute_VIF(self): """ Compute Visual Information Fidelity between two images """ self.VIF = vifp(self.I1, self.I2) return ()
mse_list = [] vif_list = [] msssim_list = [] for i in total_files: f_name = str(i).split('.')[0] img_clean = cv2.imread(clean_dir + str(f_name) + '.jpg') img_pred = cv2.imread(result_dir + str(f_name) + '.png') uq = uqi(img_clean, img_pred) uqi_list.append(uq) ms = mse(img_clean, img_pred) mse_list.append(ms) vi = vifp(img_clean, img_pred) vif_list.append(vi) mss = msssim(img_clean, img_pred) msssim_list.append(mss) cnt += 1 print('Mean Our UQI ' + str(np.mean(uqi_list))) print('Mean Our MSE ' + str(np.mean(mse_list))) print('Mean Our VIF ' + str(np.mean(vif_list))) print('Mean Our MSSSIM ' + str(np.mean(msssim_list))) print(str(cnt) + '\n') # msssim_list=[]
def bbox_vifp(gt, pred): """ Compute Structural Similarity Index Metric (SSIM). """ size = 100 gt = resize(gt, (size, size)) pred = resize(pred, gt.shape) return vifp(gt, pred)
def vif_func(gt, target, data_range): # noqa from sewar.full_ref import vifp return vifp(gt, target, sigma_nsq=0.4)
#save os.makedirs("test_data/fake_visible", exist_ok = True) cv2.imwrite("test_data/fake_visible/" + vis_path , fake_A[0][:,:,::-1] * 255) totol_metric_dict_matched = {"mse":0.0,"rmse":0.0,"uqi":0.0,"ssim":0.0,"psnr":0.0,"psnrb":0.0,"vifp":0.0} #参数指标 true_path = "test_data/visible" fake_path = "test_data/fake_visiblee" lenth = len(os.listdir(true_path)) for true_name,fake_name in zip(os.listdir(true_path),os.listdir(fake_path)): true = cv2.imread(os.path.join(true_path,true_name)) fake = cv2.imread(os.path.join(fake_path,fake_name)) metric_dict_matched = {"mse":mse(fake,true),"rmse":rmse(fake,true),"uqi":uqi(fake,true),"ssim":ssim(fake,true)[0] \ ,"psnr":psnr(fake,true),"psnrb":psnrb(fake,true),"vifp":vifp(fake,true)} for key,value in metric_dict_matched.items(): totol_metric_dict_matched[key] = totol_metric_dict_matched[key]+value for key,value in totol_metric_dict_matched.items(): totol_metric_dict_matched[key] /= lenth print(totol_metric_dict_matched) #path = ["train_data/" + method + "_infrared","train_data/" + method + "_visible"] path = [true_path,fake_path] fid_value = fid.calculate_fid_given_paths(path, inception_path = None, low_profile=False) print("FID: ", fid_value) print("done")
# cv2.imwrite("truthDIBCO/t_"+imageNameList[i],trImg) bestImage = deepcopy(trImg) maxPsnr = 0 maxSsim = 0 maxVif = 0 maxfit = -1000 for iteration in range(10): outputImage,fitval = bmoIE(truthName,popSize,maxIter) truthImage = cv2.imread(truthName,0) psnrval = cv2.PSNR(outputImage,truthImage) ssimval = ssim(outputImage,truthImage) vifval = vifp(outputImage,truthImage) #print(iteration,psnrval,ssimval,vifval,int((psnrval+ssimval+vifval)*100)) # print(psnrval, ssimval, vifval) # continue if (psnrval+ssimval+vifval)>maxfit: maxfit = psnrval+ssimval+vifval maxPsnr = psnrval maxSsim = ssimval maxVif = vifval bestImage = deepcopy(outputImage) # cv2.imshow(str(iteration+1),bestImage) print(maxPsnr, maxSsim, maxVif) # averagePsnr += maxPsnr
plt.show() plt.draw() fig1.savefig(res + '/plot_before.png') cv2.imwrite(res + '/after.jpg', gr) ax = plt.hist(gr.ravel(), 256, [0, 256]) fig2 = plt.gcf() plt.show() plt.draw() fig2.savefig(res + '/plot_after.png') # b=np.ones(len(uniq)) # ck = np.column_stack([best_sol, b]) # vif = [variance_inflation_factor(ck, i) for i in range(ck.shape[1])] vif[img_no - 1] = vifp(source, gr) psnr[img_no - 1] = PSNR(source, gr) ssim_val[img_no - 1] = ssim(source, gr) ######### the parameter values ########## print("psnr = " + str(psnr[img_no - 1])) print("vif = " + str(vif[img_no - 1])) print("ssim = " + str(ssim_val[img_no - 1])) file1 = open( "D:/Project/Image Enhancement/results/DA_Nt_del_h_obj_30/results.txt", "a") file1.write(str(img_no).zfill(2) + ". \n\n") file1.write("psnr = " + str(psnr[img_no - 1]) + "\n") file1.write("vif = " + str(vif[img_no - 1]) + "\n") file1.write("ssim = " + str(ssim_val[img_no - 1]) + "\n\n\n")
# Evaluate performance src_img = cv2.imread("sr.png") dst_img = cv2.imread("hr.png") # Reference sources from `https://github.com/richzhang/PerceptualSimilarity` lpips_loss = lpips.LPIPS(net="vgg").to(device) mse_value = mse(src_img, dst_img) rmse_value = rmse(src_img, dst_img) psnr_value = psnr(src_img, dst_img) ssim_value = ssim(src_img, dst_img) ms_ssim_value = msssim(src_img, dst_img) # 30.00+000j niqe_value = cal_niqe("sr.png") sam_value = sam(src_img, dst_img) vif_value = vifp(src_img, dst_img) lpips_value = lpips_loss(sr, hr) print("\n") print("====================== Performance summary ======================") print( f"MSE: {mse_value:.2f}\n" f"RMSE: {rmse_value:.2f}\n" f"PSNR: {psnr_value:.2f}\n" f"SSIM: {ssim_value[0]:.4f}\n" f"MS-SSIM: {ms_ssim_value.real:.4f}\n" f"NIQE: {niqe_value:.2f}\n" f"SAM: {sam_value:.4f}\n" f"VIF: {vif_value:.4f}\n" f"LPIPS: {lpips_value.item():.4f}\n" f"Use time: {(end_time - start_time) * 1000:.2f}ms/{(end_time - start_time):.4f}s."
# ## VIF for recon images and refine images vif_recon = [] vif_refine = [] for gtp in gt_paths: recon_p = gtp.replace(gt_folder, recon_folder).replace('gt', 'rec') refine_p = gtp.replace(gt_folder, refine_folder).replace('gt', 'ref') gt_img = io.imread(gtp) gt_img = gt_img[:, :, np.newaxis] / 255 recon_img = io.imread(recon_p) recon_img = recon_img[:, :, np.newaxis] / 255 refine_img = io.imread(refine_p) refine_img = refine_img[:, :, np.newaxis] / 255 vif_recon.append(vifp(gt_img, recon_img)) vif_refine.append(vifp(gt_img, refine_img)) # ## recon print('Folder {} Recon GAN VIF: {:.4}({:.2})'.format(root_folder, np.mean(vif_recon), np.std(vif_recon))) # ## refine print('Folder {} Refine GAN VIF: {:.4}({:.2})'.format(root_folder, np.mean(vif_refine), np.std(vif_refine))) np.savez_compressed(join(root_folder, 'vif.npz'), recon=vif_recon, refine=vif_refine)