• NIQE算法
千次阅读
2020-10-19 20:00:39

这个在github上可以找到源码：https://github.com/guptapraful/niqe

niqe的代码的主函数可以改动一下

import numpy as np
import scipy.misc
import scipy.io
from os.path import dirname
from os.path import join
import scipy
from PIL import Image
import numpy as np
import scipy.ndimage
import numpy as np
import scipy.special
import math
import os, random, shutil

gamma_range = np.arange(0.2, 10, 0.001)
a = scipy.special.gamma(2.0/gamma_range)
a *= a
b = scipy.special.gamma(1.0/gamma_range)
c = scipy.special.gamma(3.0/gamma_range)
prec_gammas = a/(b*c)

def aggd_features(imdata):
#flatten imdata
imdata.shape = (len(imdata.flat),)
imdata2 = imdata*imdata
left_data = imdata2[imdata<0]
right_data = imdata2[imdata>=0]
left_mean_sqrt = 0
right_mean_sqrt = 0
if len(left_data) > 0:
left_mean_sqrt = np.sqrt(np.average(left_data))
if len(right_data) > 0:
right_mean_sqrt = np.sqrt(np.average(right_data))

if right_mean_sqrt != 0:
gamma_hat = left_mean_sqrt/right_mean_sqrt
else:
gamma_hat = np.inf
#solve r-hat norm

imdata2_mean = np.mean(imdata2)
if imdata2_mean != 0:
r_hat = (np.average(np.abs(imdata))**2) / (np.average(imdata2))
else:
r_hat = np.inf
rhat_norm = r_hat * (((math.pow(gamma_hat, 3) + 1)*(gamma_hat + 1)) / math.pow(math.pow(gamma_hat, 2) + 1, 2))

#solve alpha by guessing values that minimize ro
pos = np.argmin((prec_gammas - rhat_norm)**2);
alpha = gamma_range[pos]

gam1 = scipy.special.gamma(1.0/alpha)
gam2 = scipy.special.gamma(2.0/alpha)
gam3 = scipy.special.gamma(3.0/alpha)

aggdratio = np.sqrt(gam1) / np.sqrt(gam3)
bl = aggdratio * left_mean_sqrt
br = aggdratio * right_mean_sqrt

#mean parameter
N = (br - bl)*(gam2 / gam1)#*aggdratio
return (alpha, N, bl, br, left_mean_sqrt, right_mean_sqrt)

def ggd_features(imdata):
nr_gam = 1/prec_gammas
sigma_sq = np.var(imdata)
E = np.mean(np.abs(imdata))
rho = sigma_sq/E**2
pos = np.argmin(np.abs(nr_gam - rho));
return gamma_range[pos], sigma_sq

def paired_product(new_im):
shift1 = np.roll(new_im.copy(), 1, axis=1)
shift2 = np.roll(new_im.copy(), 1, axis=0)
shift3 = np.roll(np.roll(new_im.copy(), 1, axis=0), 1, axis=1)
shift4 = np.roll(np.roll(new_im.copy(), 1, axis=0), -1, axis=1)

H_img = shift1 * new_im
V_img = shift2 * new_im
D1_img = shift3 * new_im
D2_img = shift4 * new_im

return (H_img, V_img, D1_img, D2_img)

def gen_gauss_window(lw, sigma):
sd = np.float32(sigma)
lw = int(lw)
weights = [0.0] * (2 * lw + 1)
weights[lw] = 1.0
sum = 1.0
sd *= sd
for ii in range(1, lw + 1):
tmp = np.exp(-0.5 * np.float32(ii * ii) / sd)
weights[lw + ii] = tmp
weights[lw - ii] = tmp
sum += 2.0 * tmp
for ii in range(2 * lw + 1):
weights[ii] /= sum
return weights

def compute_image_mscn_transform(image, C=1, avg_window=None, extend_mode='constant'):
if avg_window is None:
avg_window = gen_gauss_window(3, 7.0/6.0)
assert len(np.shape(image)) == 2
h, w = np.shape(image)
mu_image = np.zeros((h, w), dtype=np.float32)
var_image = np.zeros((h, w), dtype=np.float32)
image = np.array(image).astype('float32')
scipy.ndimage.correlate1d(image, avg_window, 0, mu_image, mode=extend_mode)
scipy.ndimage.correlate1d(mu_image, avg_window, 1, mu_image, mode=extend_mode)
scipy.ndimage.correlate1d(image**2, avg_window, 0, var_image, mode=extend_mode)
scipy.ndimage.correlate1d(var_image, avg_window, 1, var_image, mode=extend_mode)
var_image = np.sqrt(np.abs(var_image - mu_image**2))
return (image - mu_image)/(var_image + C), var_image, mu_image

def _niqe_extract_subband_feats(mscncoefs):
# alpha_m,  = extract_ggd_features(mscncoefs)
alpha_m, N, bl, br, lsq, rsq = aggd_features(mscncoefs.copy())
pps1, pps2, pps3, pps4 = paired_product(mscncoefs)
alpha1, N1, bl1, br1, lsq1, rsq1 = aggd_features(pps1)
alpha2, N2, bl2, br2, lsq2, rsq2 = aggd_features(pps2)
alpha3, N3, bl3, br3, lsq3, rsq3 = aggd_features(pps3)
alpha4, N4, bl4, br4, lsq4, rsq4 = aggd_features(pps4)
return np.array([alpha_m, (bl+br)/2.0,
alpha1, N1, bl1, br1,  # (V)
alpha2, N2, bl2, br2,  # (H)
alpha3, N3, bl3, bl3,  # (D1)
alpha4, N4, bl4, bl4,  # (D2)
])

def get_patches_train_features(img, patch_size, stride=8):
return _get_patches_generic(img, patch_size, 1, stride)

def get_patches_test_features(img, patch_size, stride=8):
return _get_patches_generic(img, patch_size, 0, stride)

def extract_on_patches(img, patch_size):
h, w = img.shape
patch_size = np.int(patch_size)
patches = []
for j in range(0, h-patch_size+1, patch_size):
for i in range(0, w-patch_size+1, patch_size):
patch = img[j:j+patch_size, i:i+patch_size]
patches.append(patch)

patches = np.array(patches)

patch_features = []
for p in patches:
patch_features.append(_niqe_extract_subband_feats(p))
patch_features = np.array(patch_features)

return patch_features

def _get_patches_generic(img, patch_size, is_train, stride):
h, w = np.shape(img)
if h < patch_size or w < patch_size:
print("Input image is too small")
exit(0)

# ensure that the patch divides evenly into img
hoffset = (h % patch_size)
woffset = (w % patch_size)

if hoffset > 0:
img = img[:-hoffset, :]
if woffset > 0:
img = img[:, :-woffset]

img = img.astype(np.float32)
img2 = scipy.misc.imresize(img, 0.5, interp='bicubic', mode='F')

mscn1, var, mu = compute_image_mscn_transform(img)
mscn1 = mscn1.astype(np.float32)

mscn2, _, _ = compute_image_mscn_transform(img2)
mscn2 = mscn2.astype(np.float32)

feats_lvl1 = extract_on_patches(mscn1, patch_size)
feats_lvl2 = extract_on_patches(mscn2, patch_size/2)

feats = np.hstack((feats_lvl1, feats_lvl2))# feats_lvl3))

return feats

def niqe(inputImgData):

patch_size = 96
module_path = dirname(__file__)

# TODO: memoize
params = scipy.io.loadmat(join(module_path, 'data', 'niqe_image_params.mat'))
pop_mu = np.ravel(params["pop_mu"])
pop_cov = params["pop_cov"]

M, N = inputImgData.shape

# assert C == 1, "niqe called with videos containing %d channels. Please supply only the luminance channel" % (C,)
assert M > (patch_size*2+1), "niqe called with small frame size, requires > 192x192 resolution video using current training parameters"
assert N > (patch_size*2+1), "niqe called with small frame size, requires > 192x192 resolution video using current training parameters"

feats = get_patches_test_features(inputImgData, patch_size)
sample_mu = np.mean(feats, axis=0)
sample_cov = np.cov(feats.T)

X = sample_mu - pop_mu
covmat = ((pop_cov+sample_cov)/2.0)
pinvmat = scipy.linalg.pinv(covmat)
niqe_score = np.sqrt(np.dot(np.dot(X, pinvmat), X))

return niqe_score

#
if __name__ == "__main__":
path= "F:/test1/"
tarPath='F:/test2/'
pathList=os.listdir(path)
for item in pathList:
print(item)
try:
# img = np.array(Image.open(os.path.join('F:/test1/', item)).convert('LA'))[:, :, 0]
imgOri = Image.open(os.path.join(path, item))
img = np.array(imgOri.convert('LA'))[:, :, 0]
score=niqe(img)
print(score)
if score<5:
shutil.copyfile(path + item, tarPath + item)
# scipy.misc.imsave(tarPath+str(score)+'.png', imgOri)
except Exception as e:
pass


更多相关内容
• NIQE算法代码

2017-11-10 15:18:21
NIQE算法代码 使用概率分布直接计算图片质量 使用可信赖图片生成对比模型进行比较
• 无参考图像质量指标NIQE的实现，Matlab实现。资源来自于德克萨斯大学奥斯汀分校http://live.ece.utexas.edu/research/quality/
• 它包含niqe算法的C ++代码和MATLAB代码。 MATLAB代码包含训练代码和测试代码，而C ++代码仅包含测试代码。 因此，在运行C ++测试代码时，需要导入MATLAB获取的mu.txt和cov.txt。 包含的mu.txt和cov.txt文件是通过...
• NIQE Index 最终得分 由上式即可得出最终得分，v1，∑1是一组清晰图像得到的均值向量和协方差矩阵，v2，∑2是输入的低质量图像得到的均值向量和协方差矩阵。 算法评价 1.MSCN削弱了对纹理的强弱关系依赖 ，但本质...

论文名称：Making a“Completely Blind”Image Quality Analyzer
作者：Anish Mittal, Rajiv Soundararajan, and Alan C. Bovik
年份：2013年

以下是论文的详细解析，文末我会附上论文原文与它的C++代码，在网上没找到它的C++代码所以自己写了一个，应该是独家吧哈哈，如果有其它版本记得告诉我呀。

概述

算法的大概流程是：先由一组清晰图像得出一组特征（均值向量，协方差矩阵），再用同样的方式得出低质量图像的相同特征。将这四个特征带入公式计算，本质上是计算低质量图像与清晰图像的距离。
因此，该论文的大部分篇幅都是在描述如何得到这两组特征，清晰图像和低质量图像求取特征的方式是一样的，只不过清晰图像是一组图，低质量图像是一张图。
注：图像评分与图像质量成正比。
这组清晰图像里，有多少张图像比较合适呢？论文作者做了一个实验：

由图中可以看出，选择40张图片基本救可以达到比较高的准确率了。

该算法主要分为 A~E 5个部分，下面逐一讲解。

A. Spatial Domain NSS 提取图像空间域特征

首先，像素强度归一化得到MSCN系数

该式表示高斯滤波后求局部均值和局部标准差（创建7*7高斯滤波器，标准差为7/6 ）
其中局部均值：对原始图像做高斯模糊
局部标准差：对原始图像和局部均值的差的平方做高斯模糊
具体公式为：

将式（1）由图像表示，更加直观

补充知识：为什么选用MSCN系数？

MSCN系数的优点在于因为纹理等特征而产生的区域相关性很小。如下图左侧(原始像素点)和右侧（MSCN）结果间的区别。

举个例子，左图是原图，右图为MSCN系数结果

可以看出MSCN对于纹理的强弱并没有非常强的依赖性，这样提取出来的特征更有适用性。

B. Patch Selection 筛选图像块

为什么要筛选图像块？论文中这样说：
Since humans appear to more heavily weight their judgments of image quality from the sharp image regions.
We use a simple device to preferentially select from amongst a collection of natural patches those that are richest in information and less likely to have been subjected to a limiting distortion.
因此我们的筛选标准是：边缘更锐利的，包含信息内容更丰富的。
在归一化后，筛选前，作者将图像分成大小为PxP的若干个图像块（P=96），索引为b = 1,2,3,…,B
再对每个图像块求平均方差（也就是下文提到的锐利程度）：

如何筛选呢？
作者将所有图像块的最大锐利程度的 p 倍设为阈值，其中p ∈ [0.6, 0.9]，论文中取值为 0.75。将大于阈值的图像块保留，小于阈值的图像块淘汰掉。

图中红色方框部分就表示被保留的图像块，确实包含着丰富的信息~

C. Characterizing Image Patches 求图像块特征

该部分用到GGD（广义高斯分布）和AGGD（非对称广义高斯分布）求图像块特征。
首先利用GGD（广义高斯分布）求取图像的两个特征：

利用快速匹配算法（moment-matching）得到参数α，β
论文的这一部分写到这里就结束了，因此我将进入一系列补充内容~

补充内容：为什么选用GGD求特征？

GGD的特点是在其模型中可以发现数据的非正常分布，在图像质量评估中，因为各种distortion的影响，都会导致GGD分布曲线的变形，比如

图中可以看出不同的distortion对分布结果产生的影响。

补充内容：怎么得到参数α，β？

广义高斯分布定义如下：

GGD有两个参数：参数α控制着分布的“形状”，即衰减的速度，σ控制着方差。
算法核心：

具体过程：
1）给出候选的α：设定α的查找区间，如[0.2:0.001:10]即α在(0.2,10)区间范围每隔0.001取值。
2）将所有α代入下式计算ρ(α)

3）设R为ρ(α)的估计值

其中

4）计算所有ρ(α)与步骤3得出估计值R的距离，选取距离最小对应的α即为所求。
5）最后得出
其次利用AGGD（非对称广义高斯分布）求取图像块的16个特征：
在提取特征之前，为了加入相邻像素间的关联信息，选取了4个方向分别计算MSCN：

注：图中左下角写错了，应该是（i+1,j-1)
四个方向的计算公式为

对于每个方向MSCN系数进行以下计算：

依然利用快速匹配算法（moment-matching）得到特征参数
第四个特征参数（均值：the mean of the distribution）通过下式计算：

论文中该部分的内容到这里也就结束啦，因此下面有一系列补充内容。

补充内容：为什么选用AGGD求特征？

AGGG的作用：更好的拟合distortion image产生的非对称高斯分布
拟合结果：

因为不同的distortion会使得AGGD产生不同的左右非对称现象，AGGD的pair parameters能更好的拟合出这种现象。

补充内容：怎么得到以上三个参数？

非对称广义高斯分布定义如下：

仔细阅读红线部分→因此我在实现时，利用AGGD的计算方法求GGD，将AGGD的βl,βr的均值，即为GGD的β。
AGGD共有三个参数，α、σl​、σr。α控制着分布的“形状”，σl​、σr控制左右两边的扩散程度。
算法核心：

具体步骤：
1）给出候选的α：设定α的查找区间，如[0.2:0.001:10]
2）将所有α代入下式计算ρ(α)：

3）估计

4）估计

5）估计r

其中

6）设R为ρ(α)的估计量

7）计算所得的ρ(α)与步骤5估计的R的距离，选取距离最小对应的α即为所求
8）最后

以上，GGD得到2个特征参数，AGGD的4个MSCN系数各得到4个特征参数，共2+4*4=18个特征参数，进行以上步骤后再对原图像做0.5倍下采样，再提取一次特征，因此，共得到36个特征参数。
下面对前18个特征参数进行总结

需要注意的是，我的补充内容里的符号与论文中的并不完全一致（因为是直接截图来的），输出参数也与论文中的不完全一致，于是我总结了一下。

因此特征总结图中的方差就相当于论文中的β，然而由公式（如GGD具体过程中的5））可以看出β是由方差得到的，因此，问题不大。

D. Multivariate Gaussian Model 多元高斯模型

拟合高斯模型（MVG）：
输入每张清晰图像的特征参数，得到式（9），对（9）做最大似然估计得到该模型的均值向量、协方差矩阵：v，∑
注1：这个模型是由一组清晰图像得到的，用来计算低质量图像与它的距离。
注2：采用高斯分布来处理这些特征有一个基本前提是假设这里所涉及的特征在真实的图像中所反映的也是服从高斯分布的，关于这一点这里没有证明而是假定这是一个事实。
注3：然而在实现时，无论是MATLAB版本还是c++版本，都没做最大似然估计，也没有建立该模型，而是直接求所有清晰图像的均值向量、协方差矩阵的平均值。

E. NIQE Index 最终得分

由上式即可得出最终得分，v1，∑1是一组清晰图像得到的均值向量和协方差矩阵，v2，∑2是输入的低质量图像得到的均值向量和协方差矩阵。

算法评价

1.MSCN削弱了对纹理的强弱关系依赖 ，但本质还是根据纹理进行评价。
2.最好用同一设备、在同一环境下先测出一组足够清晰的图作为groundtruth，且亮度不能过大。（因为我在实验时发现亮度过大准确率明显降低。）
3.该算法仅采用空间域的特征，有一定局限性。比如严格按照patch的分割方式获得一系列patch，如果将不同patch在空间上的位置进行对调，这样每一个patch都还能符合该算法的要求，但是很显然那是个马赛克状的退化图像。

最后附上论文原文、C++代码、MATLAB代码的GitHub地址：
原文、C++ code、MATLAB code

展开全文
• 在德克萨斯大学图像质量评价(Natural image quality evaluator,NIQE) 算法中, 无需利用人眼评分的失真图像进行训练在计算其局部MSCN 归一化图像后, 根据局部活性选择部分图像块作为训练数据, 以广义高斯模型拟合得到...

在德克萨斯大学图像质量评价(Natural image quality evaluator, NIQE) 算法中, 无需利用人眼评分的失真图像进行训练在计算其局部MSCN 归一化图像后, 根据局部活性选择部分图像块作为训练数据, 以广义高斯模型拟合得到模型参数作为特征, 采用多变量高斯模型描述这些特征, 评价过程中利用待评价图像特征模型参数与预先建立的模型参数之间的距离来确定图像质量

NIQE质评价模型
NIQE质量评价模型不需要原始图像的主现评价分数，其在原始图像库中提取图像特征，再利用多元高斯( multivariate Gaussian. MYG)模型进行建模
图像像素归一化
通过分离力一化方法计算一幅图像的归一化亮度。假设亮度图像为I（i.j）则其分离归一化计算公式如下:

I（i.j）=I（i.j）-u（i.j）/ o（ i.j）+C

以上各式中:
i和j为空域系数，且iel,2,**,M. jel,2,"",N,其中M和N分别为图像的高度和宽度:
C为常数;
w为圆形对称的高斯权重函数，且
w={w.|k=-3,2..,3,1=3-,...3}.

显著图像块的特征提取
1 )将图像分为Px P尺寸的图像块，计算图像块b局部的平均方差161.

式中o为局部图像块的平均方差。
选取o>T的图像块作为特征显著图像块，T取最大局部方差的0.6~0.9倍。
2 )对特征显著图像块的归一化系数利用广义高斯分布模型( generalized Caussian distribution, GGD )进行拟合，采用快速匹配法"估计归一化后的广义高斯分布参数(a, o' )
3)对4个相邻系数乘积用非对称广义高斯分布模型asymmetric gencralized Gaussian distribution,AGGD)?进行拟合，然后采用快速匹现达得到16个相邻系数参数在两个尺度下提取图像统计特征，共有(2+16)X 2=36个特征

图像质量计算
首先，将提取的36个特征采用拟合MVG模型计
算参数v和∑，其中，为均值，∑为方差矩阵。MVG模
型的公式如下:

式中: (x，x...x是提取的图像特征，v和工可利
用最大似然估计法得到。
其次，
提取失真图像统计特征，进行MVG模型
拟合得到(v',∑')，通过计算失真图像与自然图像拟
合参数之间的距离来衡量图像质量，具体的计算公
式如下:

式中:v1 v2' ∑1∑2分别为自然图像和失真图像的MVG
模型均值和方差矩阵，这些参数的值越大，表明图
像的质量越差。

展开全文
• 新的模型称之为NIQE(Natural Image Quality Evaluator),这个模型的设计思路是基于构建一系列的用于衡量图像质量的特征，并且将这些特征用于拟合一个多元的高斯模型，这些特征是从一些简单并且高度规则的自然景观中...

一、无参考图像质量评价NIQE简介

理论知识参考：通用型无参考图像质量评价算法综述

二、部分源代码

function  [mu_prisparam cov_prisparam]  = estimatemodelparam(folderpath,...
blocksizerow,blocksizecol,blockrowoverlap,blockcoloverlap,sh_th)

% Input
% folderpath      - Folder containing the pristine images
% blocksizerow    - Height of the blocks in to which image is divided
% blocksizecol    - Width of the blocks in to which image is divided
% blockrowoverlap - Amount of vertical overlap between blocks
% blockcoloverlap - Amount of horizontal overlap between blocks
% sh_th           - The sharpness threshold level
%Output
%mu_prisparam  - mean of multivariate Gaussian model
%cov_prisparam - covariance of multivariate Gaussian model

% Example call

%[mu_prisparam cov_prisparam] = estimatemodelparam('pristine',96,96,0,0,0.75);

%----------------------------------------------------------------
% Find the names of images in the folder
current = pwd;
cd(sprintf('%s',folderpath))
names        = ls;
names        = names(3:end,:);%
cd(current)
% ---------------------------------------------------------------
%Number of features
% 18 features at each scale
featnum      = 18;
% ---------------------------------------------------------------
% Make the directory for storing the features
mkdir(sprintf('local_risquee_prisfeatures'))
% ---------------------------------------------------------------
% Compute pristine image features
for itr = 1:size(names,1)
itr
if(size(im,3)==3)
im               = rgb2gray(im);
end
im               = double(im);
[row col]        = size(im);
block_rownum     = floor(row/blocksizerow);
block_colnum     = floor(col/blocksizecol);
im               = im(1:block_rownum*blocksizerow, ...
1:block_colnum*blocksizecol);
window           = fspecial('gaussian',7,7/6);
window           = window/sum(sum(window));
scalenum         = 2;
warning('off')

feat = [];

for itr_scale = 1:scalenum

mu                       = imfilter(im,window,'replicate');
mu_sq                    = mu.*mu;
sigma                    = sqrt(abs(imfilter(im.*im,window,'replicate') - mu_sq));
structdis                = (im-mu)./(sigma+1);

feat_scale               = blkproc(structdis,[blocksizerow/itr_scale blocksizecol/itr_scale], ...
[blockrowoverlap/itr_scale blockcoloverlap/itr_scale], ...
@computefeature);
feat_scale               = reshape(feat_scale,[featnum ....
size(feat_scale,1)*size(feat_scale,2)/featnum]);
feat_scale               = feat_scale';

if(itr_scale == 1)
sharpness                = blkproc(sigma,[blocksizerow blocksizecol], ...
[blockrowoverlap blockcoloverlap],@computemean);
sharpness                = sharpness(:);
end

feat                     = [feat feat_scale];

im =imresize(im,0.5);

end
function  quality = computequality(im,blocksizerow,blocksizecol,...
blockrowoverlap,blockcoloverlap,mu_prisparam,cov_prisparam)

% Input1
% im              - Image whose quality needs to be computed
% blocksizerow    - Height of the blocks in to which image is divided
% blocksizecol    - Width of the blocks in to which image is divided
% blockrowoverlap - Amount of vertical overlap between blocks
% blockcoloverlap - Amount of horizontal overlap between blocks
% mu_prisparam    - mean of multivariate Gaussian model
% cov_prisparam   - covariance of multivariate Gaussian model

% For good performance, it is advisable to use make the multivariate Gaussian model
% using same size patches as the distorted image is divided in to

% Output
%quality      - Quality of the input distorted image

% Example call
%quality = computequality(im,96,96,0,0,mu_prisparam,cov_prisparam)

% ---------------------------------------------------------------
%Number of features
% 18 features at each scale
featnum      = 18;
%----------------------------------------------------------------
%Compute features
if(size(im,3)==3)
im               = rgb2gray(im);
end
im               = double(im);
[row col]        = size(im);
block_rownum     = floor(row/blocksizerow);
block_colnum     = floor(col/blocksizecol);

im               = im(1:block_rownum*blocksizerow,1:block_colnum*blocksizecol);
[row col]        = size(im);
block_rownum     = floor(row/blocksizerow);
block_colnum     = floor(col/blocksizecol);
im               = im(1:block_rownum*blocksizerow, ...
1:block_colnum*blocksizecol);
window           = fspecial('gaussian',7,7/6);
window           = window/sum(sum(window));
scalenum         = 2;
warning('off')

feat             = [];



四、matlab版本及参考文献

1 matlab版本
2014a

2 参考文献
[1] 蔡利梅.MATLAB图像处理——理论、算法与实例分析[M].清华大学出版社，2020.
[2]杨丹,赵海滨,龙哲.MATLAB图像处理实例详解[M].清华大学出版社，2013.
[3]周品.MATLAB图像处理与图形用户界面设计[M].清华大学出版社，2013.
[4]刘成龙.精通MATLAB图像处理[M].清华大学出版社，2015.

展开全文
• NIQE算法代码，代码以matlab实现。对算法的理解还是非常有帮助的。
• 在对国内外文献进行广泛调研的基础上，从评价算法原理和性能比较两个方面，系统综述了BIQI、DIIVINE、BLIINDS、BLIINDS-II、BRISQUE、NIQE和GRNN等当前性能较优的几种无参考图像质量评价算法。介绍了各种算法的特征...
• 【图像评价】基于无参考NIQE图像质量评价matlab源码.md
• 有关设置主观测试的详细信息，请参阅建议ITU-R BT.500-13-电视图像质量主观评估方法，根据TU-R BT500.13或TU-T 913建议，已经开发了许多算法，通过与正确生成的主观数据相关，以精确的方式估计人类感知的视频质量。...
• 这种统一的方法共同量化了算法的准确性和感知质量，并将使感知驱动方法能够与针对PSNR最大化的算法竞争。 有关更多详细信息，请参见。 自我验证码 该Matlab代码为自验证集中的方法输出计算RMSE和感知分数。 快速开始...
• 3.用处：用于基于NIQE的无参考图像质量评价算法编程学习 4.指向人群：本硕博等教研学习使用 5.运行注意事项： 使用matlab2021a或者更高版本测试，运行里面的Runme_.m文件，不要直接运行子函数文件。运行时注意...
• 之前做图像质量评价的时候找的代码，现在分享给你们，语言很杂，包括matlab、C++、python都有
• 无参考图像评价指标NIQE——自然图像质量欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格...
• 视频质量评价无参考NIQE

千次阅读 2018-04-19 00:11:02
无参考图像主观评价分数的NIQE质量评价模型，NIQE算法与主观评价的相关性分析结果表明,皮尔逊相关系数为0.910 1,斯皮尔曼秩相关系数为0.946 1,平均绝对值误差为0.016 0;相较于MSE、PSNR、SSIM和MS-SSIM 4种全参考...
• 【Matlab图像评价】无参考NIQE图像质量评价【含源码 681期】 二、matlab版本及参考文献 1 matlab版本 2014a 2 参考文献 [1] 蔡利梅.MATLAB图像处理——理论、算法与实例分析[M].清华大学出版社，2020. [2]杨丹,赵...
• Commonly Used Denoising Dataset Kodak [Web] USC SIPI-Misc [Web] Commonly Used Image Quality Metrics PSNR (Peak Signal-to-Noise Ratio) [Wiki] [Matlab Code] [Python Code] NIQE (Naturalness Image ...
• 一种新的无参考图像质量指标 NIQE making a completely blind image quality analyzer 介绍 新的模型称之为NIQE(Natural Image Quality Evaluator),这个模型的设计思路是基于构建一系列的用于衡量图像质量的特征，...
• 首先在详细介绍SSEQ、NIQE和BIQI三种经典的无参考图像质量评价方法优缺点的基础上，提出了加权的质量评价策略以对序列图像进行自动选优。其次为了加快权重寻优的过程，提出了基于粒子群优化的PSO-WNRIQA算法。最后...
• 3.NIQE： 该算法假设无失真图像满足某种统计特性，首先对自然图像提取出自然场景统计特性，并建立多变量高斯模型（MVG）。对于失真图像同样方法得到MVG模型，计算二者距离得质量分数。 <二>块效应 1.Wang...
• 从结果来看，HiFiC算法在FID、KID、NIQE、LPIPS几种评估标准均为最优，而在MS-SSIM和PSNR标准中表现一般。 由评估标准间的差异可见，各项图像质量标准不一定是判断压缩技术的最好办法。 用户评测对比 毕竟，图像是...
• 随着此类算法在诸如自主导航和视频监视等应用中成为至关重要的组成部分，开发用于除雨的复杂算法变得越来越重要。 就重构误差和视觉质量而言，基于CNN的最新图像去雨算法已经获得了出色的性能。但是，这些...
• 图像/视频去噪算法资源集锦

千次阅读 2019-12-15 09:26:38
图像去噪是指减少数字图像中噪声...本文整理了一些去噪算法与数据集。 Denoising Algorithms Filter NLM [Web]:https://sites.google.com/site/shreyamsha/publications/image-denoising-based-on-nlfmt [Code]:htt...
• 图像和视频质量评估算法整合 http://live.ece.utexas.edu/research/Quality/index_algorithms.htm SSIM、MS-SSIM、VIFP、GMSM、GMSD 和 VMAF 新版的视听版本！ 请在此处下载，如果您使用本软件，请在任何已发表的...
• 本文结构如下： 1：多元正态分布及可视化 2：双高斯独立分布可视化 3：从零开始推导多元高斯分布 4：多元正态分布性质 5：高斯判别分析模型 6：高斯判别分析模型Demo 1： 多元正态分布及可视化 ...

...