一、Evaluator.py全部代码（可正常调用）
import numpy as np
import cv2
import sklearn.metrics as skm
from scipy.signal import convolve2d
import math
from skimage.metrics import structural_similarity as ssim
def image_read_cv2(path, mode='RGB'):
img_BGR = cv2.imread(path).astype('float32')
assert mode == 'RGB' or mode == 'GRAY' or mode == 'YCrCb', 'mode error'
if mode == 'RGB':
img = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2RGB)
elif mode == 'GRAY':
img = np.round(cv2.cvtColor(img_BGR, cv2.COLOR_BGR2GRAY))
elif mode == 'YCrCb':
img = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2YCrCb)
return img
class Evaluator():
@classmethod
def input_check(cls, imgF, imgA=None, imgB=None):
if imgA is None:
assert type(imgF) == np.ndarray, 'type error'
assert len(imgF.shape) == 2, 'dimension error'
else:
assert type(imgF) == type(imgA) == type(imgB) == np.ndarray, 'type error'
assert imgF.shape == imgA.shape == imgB.shape, 'shape error'
assert len(imgF.shape) == 2, 'dimension error'
@classmethod
def EN(cls, img): # entropy
cls.input_check(img)
a = np.uint8(np.round(img)).flatten()
h = np.bincount(a) / a.shape[0]
return -sum(h * np.log2(h + (h == 0)))
@classmethod
def SD(cls, img):
cls.input_check(img)
return np.std(img)
@classmethod
def SF(cls, img):
cls.input_check(img)
return np.sqrt(np.mean((img[:, 1:] - img[:, :-1]) ** 2) + np.mean((img[1:, :] - img[:-1, :]) ** 2))
@classmethod
def AG(cls, img): # Average gradient
cls.input_check(img)
Gx, Gy = np.zeros_like(img), np.zeros_like(img)
Gx[:, 0] = img[:, 1] - img[:, 0]
Gx[:, -1] = img[:, -1] - img[:, -2]
Gx[:, 1:-1] = (img[:, 2:] - img[:, :-2]) / 2
Gy[0, :] = img[1, :] - img[0, :]
Gy[-1, :] = img[-1, :] - img[-2, :]
Gy[1:-1, :] = (img[2:, :] - img[:-2, :]) / 2
return np.mean(np.sqrt((Gx ** 2 + Gy ** 2) / 2))
@classmethod
def MI(cls, image_F, image_A, image_B):
cls.input_check(image_F, image_A, image_B)
return skm.mutual_info_score(image_F.flatten(), image_A.flatten()) + skm.mutual_info_score(image_F.flatten(),
image_B.flatten())
@classmethod
def MSE(cls, image_F, image_A, image_B): # MSE
cls.input_check(image_F, image_A, image_B)
return (np.mean((image_A - image_F) ** 2) + np.mean((image_B - image_F) ** 2)) / 2
@classmethod
def CC(cls, image_F, image_A, image_B):
cls.input_check(image_F, image_A, image_B)
rAF = np.sum((image_A - np.mean(image_A)) * (image_F - np.mean(image_F))) / np.sqrt(
(np.sum((image_A - np.mean(image_A)) ** 2)) * (np.sum((image_F - np.mean(image_F)) ** 2)))
rBF = np.sum((image_B - np.mean(image_B)) * (image_F - np.mean(image_F))) / np.sqrt(
(np.sum((image_B - np.mean(image_B)) ** 2)) * (np.sum((image_F - np.mean(image_F)) ** 2)))
return (rAF + rBF) / 2
@classmethod
def PSNR(cls, image_F, image_A, image_B):
cls.input_check(image_F, image_A, image_B)
return 10 * np.log10(np.max(image_F) ** 2 / cls.MSE(image_F, image_A, image_B))
@classmethod
def SCD(cls, image_F, image_A, image_B): # The sum of the correlations of differences
cls.input_check(image_F, image_A, image_B)
imgF_A = image_F - image_A
imgF_B = image_F - image_B
corr1 = np.sum((image_A - np.mean(image_A)) * (imgF_B - np.mean(imgF_B))) / np.sqrt(
(np.sum((image_A - np.mean(image_A)) ** 2)) * (np.sum((imgF_B - np.mean(imgF_B)) ** 2)))
corr2 = np.sum((image_B - np.mean(image_B)) * (imgF_A - np.mean(imgF_A))) / np.sqrt(
(np.sum((image_B - np.mean(image_B)) ** 2)) * (np.sum((imgF_A - np.mean(imgF_A)) ** 2)))
return corr1 + corr2
@classmethod
def VIFF(cls, image_F, image_A, image_B):
cls.input_check(image_F, image_A, image_B)
return cls.compare_viff(image_A, image_F)+cls.compare_viff(image_B, image_F)
@classmethod
def compare_viff(cls,ref, dist): # viff of a pair of pictures
sigma_nsq = 2
eps = 1e-10
num = 0.0
den = 0.0
for scale in range(1, 5):
N = 2 ** (4 - scale + 1) + 1
sd = N / 5.0
# Create a Gaussian kernel as MATLAB's
m, n = [(ss - 1.) / 2. for ss in (N, N)]
y, x = np.ogrid[-m:m + 1, -n:n + 1]
h = np.exp(-(x * x + y * y) / (2. * sd * sd))
h[h < np.finfo(h.dtype).eps * h.max()] = 0
sumh = h.sum()
if sumh != 0:
win = h / sumh
if scale > 1:
ref = convolve2d(ref, np.rot90(win, 2), mode='valid')
dist = convolve2d(dist, np.rot90(win, 2), mode='valid')
ref = ref[::2, ::2]
dist = dist[::2, ::2]
mu1 = convolve2d(ref, np.rot90(win, 2), mode='valid')
mu2 = convolve2d(dist, np.rot90(win, 2), mode='valid')
mu1_sq = mu1 * mu1
mu2_sq = mu2 * mu2
mu1_mu2 = mu1 * mu2
sigma1_sq = convolve2d(ref * ref, np.rot90(win, 2), mode='valid') - mu1_sq
sigma2_sq = convolve2d(dist * dist, np.rot90(win, 2), mode='valid') - mu2_sq
sigma12 = convolve2d(ref * dist, np.rot90(win, 2), mode='valid') - mu1_mu2
sigma1_sq[sigma1_sq < 0] = 0
sigma2_sq[sigma2_sq < 0] = 0
g = sigma12 / (sigma1_sq + eps)
sv_sq = sigma2_sq - g * sigma12
g[sigma1_sq < eps] = 0
sv_sq[sigma1_sq < eps] = sigma2_sq[sigma1_sq < eps]
sigma1_sq[sigma1_sq < eps] = 0
g[sigma2_sq < eps] = 0
sv_sq[sigma2_sq < eps] = 0
sv_sq[g < 0] = sigma2_sq[g < 0]
g[g < 0] = 0
sv_sq[sv_sq <= eps] = eps
num += np.sum(np.log10(1 + g * g * sigma1_sq / (sv_sq + sigma_nsq)))
den += np.sum(np.log10(1 + sigma1_sq / sigma_nsq))
vifp = num / den
if np.isnan(vifp):
return 1.0
else:
return vifp
@classmethod
def Qabf(cls, image_F, image_A, image_B):
cls.input_check(image_F, image_A, image_B)
gA, aA = cls.Qabf_getArray(image_A)
gB, aB = cls.Qabf_getArray(image_B)
gF, aF = cls.Qabf_getArray(image_F)
QAF = cls.Qabf_getQabf(aA, gA, aF, gF)
QBF = cls.Qabf_getQabf(aB, gB, aF, gF)
# 计算QABF
deno = np.sum(gA + gB)
nume = np.sum(np.multiply(QAF, gA) + np.multiply(QBF, gB))
return nume / deno
@classmethod
def Qabf_getArray(cls,img):
# Sobel Operator Sobel
h1 = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]]).astype(np.float32)
h2 = np.array([[0, 1, 2], [-1, 0, 1], [-2, -1, 0]]).astype(np.float32)
h3 = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]).astype(np.float32)
SAx = convolve2d(img, h3, mode='same')
SAy = convolve2d(img, h1, mode='same')
gA = np.sqrt(np.multiply(SAx, SAx) + np.multiply(SAy, SAy))
aA = np.zeros_like(img)
aA[SAx == 0] = math.pi / 2
aA[SAx != 0]=np.arctan(SAy[SAx != 0] / SAx[SAx != 0])
return gA, aA
@classmethod
def Qabf_getQabf(cls,aA, gA, aF, gF):
L = 1
Tg = 0.9994
kg = -15
Dg = 0.5
Ta = 0.9879
ka = -22
Da = 0.8
GAF,AAF,QgAF,QaAF,QAF = np.zeros_like(aA),np.zeros_like(aA),np.zeros_like(aA),np.zeros_like(aA),np.zeros_like(aA)
GAF[gA>gF]=gF[gA>gF]/gA[gA>gF]
GAF[gA == gF] = gF[gA == gF]
GAF[gA <gF] = gA[gA<gF]/gF[gA<gF]
AAF = 1 - np.abs(aA - aF) / (math.pi / 2)
QgAF = Tg / (1 + np.exp(kg * (GAF - Dg)))
QaAF = Ta / (1 + np.exp(ka * (AAF - Da)))
QAF = QgAF* QaAF
return QAF
# @classmethod
# def SSIM(cls, image_F, image_A, image_B):
# cls.input_check(image_F, image_A, image_B)
# return ssim(image_F,image_A)+ssim(image_F,image_B)
@classmethod
def SSIM(cls,image_F, image_A, image_B):
# 假设图像已经归一化并且在 [0, 1] 范围内
data_range = 1.0 # 如果您的图像有不同的范围，请更新这个值
cls.input_check(image_F, image_A, image_B)
# 计算 image_F 和 image_A，以及 image_F 和 image_B 之间的 SSIM
ssim_score_A = ssim(image_F, image_A, data_range=data_range)
ssim_score_B = ssim(image_F, image_B, data_range=data_range)
# 返回 SSIM 的平均值
return (ssim_score_A + ssim_score_B) / 2
def VIFF(image_F, image_A, image_B):
refA=image_A
refB=image_B
dist=image_F
sigma_nsq = 2
eps = 1e-10
numA = 0.0
denA = 0.0
numB = 0.0
denB = 0.0
for scale in range(1, 5):
N = 2 ** (4 - scale + 1) + 1
sd = N / 5.0
# Create a Gaussian kernel as MATLAB's
m, n = [(ss - 1.) / 2. for ss in (N, N)]
y, x = np.ogrid[-m:m + 1, -n:n + 1]
h = np.exp(-(x * x + y * y) / (2. * sd * sd))
h[h < np.finfo(h.dtype).eps * h.max()] = 0
sumh = h.sum()
if sumh != 0:
win = h / sumh
if scale > 1:
refA = convolve2d(refA, np.rot90(win, 2), mode='valid')
refB = convolve2d(refB, np.rot90(win, 2), mode='valid')
dist = convolve2d(dist, np.rot90(win, 2), mode='valid')
refA = refA[::2, ::2]
refB = refB[::2, ::2]
dist = dist[::2, ::2]
mu1A = convolve2d(refA, np.rot90(win, 2), mode='valid')
mu1B = convolve2d(refB, np.rot90(win, 2), mode='valid')
mu2 = convolve2d(dist, np.rot90(win, 2), mode='valid')
mu1_sq_A = mu1A * mu1A
mu1_sq_B = mu1B * mu1B
mu2_sq = mu2 * mu2
mu1A_mu2 = mu1A * mu2
mu1B_mu2 = mu1B * mu2
sigma1A_sq = convolve2d(refA * refA, np.rot90(win, 2), mode='valid') - mu1_sq_A
sigma1B_sq = convolve2d(refB * refB, np.rot90(win, 2), mode='valid') - mu1_sq_B
sigma2_sq = convolve2d(dist * dist, np.rot90(win, 2), mode='valid') - mu2_sq
sigma12_A = convolve2d(refA * dist, np.rot90(win, 2), mode='valid') - mu1A_mu2
sigma12_B = convolve2d(refB * dist, np.rot90(win, 2), mode='valid') - mu1B_mu2
sigma1A_sq[sigma1A_sq < 0] = 0
sigma1B_sq[sigma1B_sq < 0] = 0
sigma2_sq[sigma2_sq < 0] = 0
gA = sigma12_A / (sigma1A_sq + eps)
gB = sigma12_B / (sigma1B_sq + eps)
sv_sq_A = sigma2_sq - gA * sigma12_A
sv_sq_B = sigma2_sq - gB * sigma12_B
gA[sigma1A_sq < eps] = 0
gB[sigma1B_sq < eps] = 0
sv_sq_A[sigma1A_sq < eps] = sigma2_sq[sigma1A_sq < eps]
sv_sq_B[sigma1B_sq < eps] = sigma2_sq[sigma1B_sq < eps]
sigma1A_sq[sigma1A_sq < eps] = 0
sigma1B_sq[sigma1B_sq < eps] = 0
gA[sigma2_sq < eps] = 0
gB[sigma2_sq < eps] = 0
sv_sq_A[sigma2_sq < eps] = 0
sv_sq_B[sigma2_sq < eps] = 0
sv_sq_A[gA < 0] = sigma2_sq[gA < 0]
sv_sq_B[gB < 0] = sigma2_sq[gB < 0]
gA[gA < 0] = 0
gB[gB < 0] = 0
sv_sq_A[sv_sq_A <= eps] = eps
sv_sq_B[sv_sq_B <= eps] = eps
numA += np.sum(np.log10(1 + gA * gA * sigma1A_sq / (sv_sq_A + sigma_nsq)))
numB += np.sum(np.log10(1 + gB * gB * sigma1B_sq / (sv_sq_B + sigma_nsq)))
denA += np.sum(np.log10(1 + sigma1A_sq / sigma_nsq))
denB += np.sum(np.log10(1 + sigma1B_sq / sigma_nsq))
vifpA = numA / denA
vifpB =numB / denB
if np.isnan(vifpA):
vifpA=1
if np.isnan(vifpB):
vifpB = 1
return vifpA+vifpB
1.图像读取函数image_read_cv2():
函数image_read_cv2():
def image_read_cv2(path, mode='RGB'):
img_BGR = cv2.imread(path).astype('float32')
assert mode == 'RGB' or mode == 'GRAY' or mode == 'YCrCb', 'mode error'
if mode == 'RGB':
img = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2RGB)
elif mode == 'GRAY':
img = np.round(cv2.cvtColor(img_BGR, cv2.COLOR_BGR2GRAY))
elif mode == 'YCrCb':
img = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2YCrCb)
return img将读入的图像全部转化为单通道的灰度图像。
2.输入图像格式检查函数input_check():
函数input_check():
@classmethod
def input_check(cls, imgF, imgA=None, imgB=None):
if imgA is None:
assert type(imgF) == np.ndarray, 'type error'
assert len(imgF.shape) == 2, 'dimension error'
else:
assert type(imgF) == type(imgA) == type(imgB) == np.ndarray, 'type error'
assert imgF.shape == imgA.shape == imgB.shape, 'shape error'
assert len(imgF.shape) == 2, 'dimension error'定义了一个类方法（classmethod）input_check，也就是说在类的其他方法中可以通过cls.input_check()直接调用这个方法。该函数主要的作用是检查输入图像的格式。
如果imgA为None：
- 确保
imgF的类型是numpy.ndarray（NumPy数组），如果不是，抛出一个类型错误的异常。 - 确认
imgF的维度是2（二维数组），如果不是，抛出一个维度错误的异常。
如果imgA不为None：
- 确保
imgF、imgA和imgB的类型都是numpy.ndarray，如果不是，抛出一个类型错误的异常。 - 确保
imgF、imgA和imgB的形状相同，如果不是，抛出一个形状错误的异常。 - 再次确认
imgF的维度是2。
二、图像评价指标（12种）
1. EN（信息熵 Entropy）
信息熵主要是度量图像包含信息量多少的一个客观评价指标,a表示灰度值，P(a)表示灰度概率分布:
信息熵越高表示融合图像的信息量越丰富，质量越好。
代码如下：（只检查融合图像）
def EN(cls, img): # entropy
cls.input_check(img)
a = np.uint8(np.round(img)).flatten()
h = np.bincount(a) / a.shape[0]
return -sum(h * np.log2(h + (h == 0)))a = np.uint8(np.round(img)).flatten(): np.round():对括号中的内容进行四舍五入的操作。不会改变原数组，而是返回一个新的数组，除非你明确地将结果赋值给原数组的一个元素。然后将新的数组转换为整数（np.uint8 表示无符号8位整数）。最后使用.flatten将其展平为一维数组。
h = np.bincount(a) / a.shape[0]: 使用 np.bincount 函数计算数组 a 中每个整数值出现的次数，并除以总像素数 a.shape[0]，得到每个整数值的概率分布 h。
return -sum(h * np.log2(h + (h == 0))): 最后，函数计算熵。根据信息论，熵（H）定义为每个可能状态（这里对应每个整数值）的概率（h）乘以以自然对数为底的负对数（-np.log2），然后求和。+ (h == 0) 是为了避免对0取对数，因为自然对数的底数不能为0，所以这里用一个小技巧处理概率为0的情况。
2. SD（标准差 standard Deviation）
是一种衡量数据集中数据分布或离散程度的统计量。在图像处理中，标准差通常用来评价图像的对比度和清晰度，因此也可以用来评价融合图像的质量。
-
对比度评价：标准差反映了图像像素值的变化范围，对比度高的图像通常具有较大的标准差。因此，通过比较融合图像和原始图像的标准差，可以评价融合后图像的对比度是否有所提高或降低。
-
清晰度评价：清晰的图像通常具有较高的对比度，因此标准差也可以间接反映图像的清晰度。融合图像的标准差较高可能表示图像边缘清晰，细节丰富。
所以融合图像的SD越大越好吗？（NO）
并不是，
具体来说，SD的大小与融合图像的对比度、清晰度和一致性程度存在一定的关联，但并不是越大越好。
-
对比度： SD的大小与融合图像的对比度有一定的正相关关系，即SD越大，对比度可能也会越高。但是，过高的对比度可能导致图像过亮或过暗，影响观察体验。因此，在融合图像时需要根据具体应用场景来寻找适合的对比度。
-
清晰度： SD的大小与融合图像的清晰度也有一定的正相关关系，即SD越大，图像细节可能也会更加清晰。但是，过高的SD可能导致图像出现过多噪声或失真，影响观察体验。因此，在融合图像时需要根据具体应用场景来寻找适合的清晰度。
-
一致性： SD的大小与融合图像的一致性程度没有明确的相关关系，因此SD的大小并不能直接反映融合图像的一致性。
综上所述，SD的大小并不是融合图像的绝对评价指标，而是需要根据具体应用场景和其他图像质量评价指标来进行综合评价。在某些情况下，SD的大小可能会提示融合图像的质量有所提高，但是过高的SD也可能导致图像质量下降。因此，在融合图像时需要谨慎地考虑SD的大小，并结合其他指标进行综合评价。
代码如下：（只检查融合图像）
def SD(cls, img):
cls.input_check(img)
return np.std(img)3. SF（空间频率 Spatial Frequency）
空间频率（Spatial Frequency）反映图像灰度的变化率,空间频率越大表示图像越清晰，融合图像质量越好。其计算公式如下：
代码如下：（只检查融合图像）
def SF(cls, img):
cls.input_check(img)
return np.sqrt(np.mean((img[:, 1:] - img[:, :-1]) ** 2) + np.mean((img[1:, :] - img[:-1, :]) ** 2))
4. AG（平均梯度 Average Gradient ）
平均梯度（Average Gradient）可以用于衡量融合图像的清晰程度，可以认为平均梯度越大，图像清晰度越好，融合质量越好。计算公式如下：
其中H表示融合图像，M与N分别表示图像的高和宽。
def AG(cls, img): # Average gradient
cls.input_check(img)
Gx, Gy = np.zeros_like(img), np.zeros_like(img)
Gx[:, 0] = img[:, 1] - img[:, 0]
Gx[:, -1] = img[:, -1] - img[:, -2]
Gx[:, 1:-1] = (img[:, 2:] - img[:, :-2]) / 2
Gy[0, :] = img[1, :] - img[0, :]
Gy[-1, :] = img[-1, :] - img[-2, :]
Gy[1:-1, :] = (img[2:, :] - img[:-2, :]) / 2
return np.mean(np.sqrt((Gx ** 2 + Gy ** 2) / 2))5.MI（互信息 Mutual Information）
可度量两幅图像之间的相似程度，即融合图像获取了原图像信息量的多少。互信息越大，表示融合图像保留更多源图像信息，质量越好。互信息是根据图像的信息熵H(A)和联合信息熵H(A,B)：
代码如下：（计算三幅图片的）
def MI(cls, image_F, image_A, image_B):
cls.input_check(image_F, image_A, image_B)
return skm.mutual_info_score(image_F.flatten(), image_A.flatten()) + skm.mutual_info_score(image_F.flatten(),
image_B.flatten())使用了 skm.mutual_info_score 函数来计算互信息，这个函数来自于 sklearn.metrics 模块，用于评估两个离散或连续随机变量之间的互信息。
最后的结果是融合图像和可见光图像的互信息加上融合图像和红外图像的互信息。
6.MSE（均方误差 Mean Square Error）
反映的是变量间的差异程度，是一种基于像素误差的图像质量客观评价指标，用于衡量融合图像和理想参考图像之间的差异，MSE越小，表示融合图像质量越好。
均方根误差(Root Mean Square Error)是一个翻译空间细节信息的评价指标，公式如下：
归一化均方根误差（normalized root mean square error）就是将RMSE的值变成(0,1)之间。
代码如下：（越小越好，输入三幅图片）
def MSE(cls, image_F, image_A, image_B): # MSE
cls.input_check(image_F, image_A, image_B)
return (np.mean((image_A - image_F) ** 2) + np.mean((image_B - image_F) ** 2)) / 2
计算了图像 image_A 与图像 image_F 之间的均方误差，以及图像 image_B 与图像 image_F 之间的均方误差，然后将这两个均方误差值相加并除以2取平均，最终返回这个平均值作为结果。这里使用了 np.mean 函数来计算均值，** 表示乘方操作，即计算差的平方。均方误差用于评估两幅图像之间的差异程度，值越小表示两幅图像越相似。
7.CC（相关系数 Correlation Coefficient）
CC 是一种用于衡量图像之间相关性的指标，通常用于评估图像的相似性或质量。
相关系数用于衡量两个变量之间的线性关系强度，取值范围为[-1, 1]，值为1表示完全正相关，值为-1表示完全负相关，值为0表示无相关性。
代码如下：（越接近1越好，输入三幅图片）
def CC(cls, image_F, image_A, image_B):
cls.input_check(image_F, image_A, image_B)
rAF = np.sum((image_A - np.mean(image_A)) * (image_F - np.mean(image_F))) / np.sqrt(
(np.sum((image_A - np.mean(image_A)) ** 2)) * (np.sum((image_F - np.mean(image_F)) ** 2)))
rBF = np.sum((image_B - np.mean(image_B)) * (image_F - np.mean(image_F))) / np.sqrt(
(np.sum((image_B - np.mean(image_B)) ** 2)) * (np.sum((image_F - np.mean(image_F)) ** 2)))
return (rAF + rBF) / 2计算了图像 image_A 与图像 image_F 之间的相关系数 rAF。相关系数用于衡量两个变量之间的线性关系强度，取值范围为[-1, 1]，值为1表示完全正相关，值为-1表示完全负相关，值为0表示无相关性。这里使用了 np.sum 函数来计算总和，np.mean 函数来计算均值，** 表示乘方操作。
计算了图像 image_B 与图像 image_F 之间的相关系数 rBF，同样使用了类似的计算方法。
最后返回了图像 image_A 与图像 image_F 之间的相关系数 rAF 和图像 image_B 与图像 image_F 之间的相关系数 rBF 的平均值作为最终结果。这里假设两个相关系数具有相同的权重，因此取平均值。
8.PSNR（峰值信噪比 Peak signal to noise ration）
用于衡量图像有效信息与噪声之间的比率，能够反映图像是否失真。
Z表示理想参考图像灰度最大值与最小值之差，通常为255。PSNR的值越大，表示融合图像的质量越好。
代码如下：（越大越好，输入三幅图片）
def PSNR(cls, image_F, image_A, image_B):
cls.input_check(image_F, image_A, image_B)
return 10 * np.log10(np.max(image_F) ** 2 / cls.MSE(image_F, image_A, image_B))
直接用img_F的z的平方除以之前就算好的MSE。
9.SCD（差异相关和 Sum of the Correlations of Differences）
代码如下：（（-1,1）表示相关性，所以最好是正相关，也就是接近1）
@classmethod
def corr2(a, b):
a = a - np.mean(a)
b = b - np.mean(b)
r = np.sum(a * b) / np.sqrt(np.sum(a * a) * np.sum(b * b))
return r
@classmethod
def SCD(cls, image_F, image_A, image_B): # The sum of the correlations of differences
cls.input_check(image_F, image_A, image_B)
r = cls.corr2(image_F - image_B, image_A) + cls.corr2(image_F - image_A, image_B)
return r这段代码中的SCD方法计算了两幅原始图像image_A和image_B分别与融合后的图像image_F的差值图像之间的相关性之和。具体来说，它首先调用corr2方法计算了image_F - image_B与image_A之间的相关性，然后计算了image_F - image_A与image_B之间的相关性，最后将这两个相关性值相加得到最终的SCD值。
在图像融合领域中，SCD值可以用来评估融合后的图像与原始图像之间的结构相似性，即差异相关和。通过计算差值图像之间的相关性，可以评估融合后图像的质量，以及融合过程中保留了多少原始图像的结构信息。
因此，这段代码中的SCD方法实际上是在计算图像融合质量的一个指标，通过分析差值图像之间的相关性来评估融合效果。
10.VIFF（视觉保真度 The visual information fidelity for fusion）
是基于视觉信息保真度提出的衡量融合图像质量的指标，由于太复杂了，详见A new image fusion performance metric based on visual information fidelity。VIFF的值越大，表示融合图像质量越好。
代码如下：（越接近1越好，输入三张图片）
@classmethod
def VIFF(cls, image_F, image_A, image_B):
cls.input_check(image_F, image_A, image_B)
return cls.compare_viff(image_A, image_F)+cls.compare_viff(image_B, image_F)
@classmethod
def compare_viff(cls,ref, dist): # viff of a pair of pictures
sigma_nsq = 2
eps = 1e-10
num = 0.0
den = 0.0
for scale in range(1, 5):
N = 2 ** (4 - scale + 1) + 1
sd = N / 5.0
# Create a Gaussian kernel as MATLAB's
m, n = [(ss - 1.) / 2. for ss in (N, N)]
y, x = np.ogrid[-m:m + 1, -n:n + 1]
h = np.exp(-(x * x + y * y) / (2. * sd * sd))
h[h < np.finfo(h.dtype).eps * h.max()] = 0
sumh = h.sum()
if sumh != 0:
win = h / sumh
if scale > 1:
ref = convolve2d(ref, np.rot90(win, 2), mode='valid')
dist = convolve2d(dist, np.rot90(win, 2), mode='valid')
ref = ref[::2, ::2]
dist = dist[::2, ::2]
mu1 = convolve2d(ref, np.rot90(win, 2), mode='valid')
mu2 = convolve2d(dist, np.rot90(win, 2), mode='valid')
mu1_sq = mu1 * mu1
mu2_sq = mu2 * mu2
mu1_mu2 = mu1 * mu2
sigma1_sq = convolve2d(ref * ref, np.rot90(win, 2), mode='valid') - mu1_sq
sigma2_sq = convolve2d(dist * dist, np.rot90(win, 2), mode='valid') - mu2_sq
sigma12 = convolve2d(ref * dist, np.rot90(win, 2), mode='valid') - mu1_mu2
sigma1_sq[sigma1_sq < 0] = 0
sigma2_sq[sigma2_sq < 0] = 0
g = sigma12 / (sigma1_sq + eps)
sv_sq = sigma2_sq - g * sigma12
g[sigma1_sq < eps] = 0
sv_sq[sigma1_sq < eps] = sigma2_sq[sigma1_sq < eps]
sigma1_sq[sigma1_sq < eps] = 0
g[sigma2_sq < eps] = 0
sv_sq[sigma2_sq < eps] = 0
sv_sq[g < 0] = sigma2_sq[g < 0]
g[g < 0] = 0
sv_sq[sv_sq <= eps] = eps
num += np.sum(np.log10(1 + g * g * sigma1_sq / (sv_sq + sigma_nsq)))
den += np.sum(np.log10(1 + sigma1_sq / sigma_nsq))
vifp = num / den
if np.isnan(vifp):
return 1.0
else:
return vifp这段代码定义了一个类方法VIFF，用于计算两个图像（image_F和image_A或image_B）之间的视觉信息量（Visual Information Fidelity，简称VIFF）。VIFF是一种图像质量评估方法，用于比较两幅图像的相似性。
-
@classmethod注解表明这是一个类方法，可以直接通过类名调用，而不需要实例化对象。 -
cls.input_check(image_F, image_A, image_B)：是用于检查输入图像的尺寸和类型是否正确，确保可以进行后续计算。 -
compare_viff(ref, dist)是一个内部函数，计算两个图像（ref和dist）的VIFF值： a.sigma_nsq和eps是常数，分别用于计算中的稳定性和避免除以零。 b. 通过循环（for scale in range(1, 5)）对图像进行不同尺度的低通滤波（Gaussian kernel），这有助于减少噪声影响。 c. 计算每个尺度下的均值（mu1, mu2）、均值的平方（mu1_sq, mu2_sq）、协方差（sigma12）、方差（sigma1_sq, sigma2_sq）。 d. 计算相关系数（g），并根据sigma_nsq和eps进行调整。 e. 计算VIFF值（vifp），即信息增益（num）除以信息冗余（den）。 f. 如果计算出的VIFF值是NaN，返回1.0（可能是为了处理异常情况），否则返回计算出的VIFF值。
总的来说，这段代码是用于评估两个图像之间在不同尺度下相似性的算法，结果范围在0到1之间，1表示完全相同，0表示完全不同。
11.Qabf（Quality Assessment Based on Fusion）
Qabf是一种新颖的融合图像客观非参考质量评估指标，得到Qabf的算法利用局部度量来估计来自输入的显着信息在融合图像中的表现程度，Qabf的值越高，表示融合图像的质量越好。计算公式如下：
详细可见见论文A new quality metric for image fusion
代码如下：（越大越好，输入三幅图片）
@classmethod
def Qabf(cls, image_F, image_A, image_B):
cls.input_check(image_F, image_A, image_B)
gA, aA = cls.Qabf_getArray(image_A)
gB, aB = cls.Qabf_getArray(image_B)
gF, aF = cls.Qabf_getArray(image_F)
QAF = cls.Qabf_getQabf(aA, gA, aF, gF)
QBF = cls.Qabf_getQabf(aB, gB, aF, gF)
# 计算QABF
deno = np.sum(gA + gB)
nume = np.sum(np.multiply(QAF, gA) + np.multiply(QBF, gB))
return nume / deno
@classmethod
def Qabf_getArray(cls,img):
# Sobel Operator Sobel
h1 = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]]).astype(np.float32)
h2 = np.array([[0, 1, 2], [-1, 0, 1], [-2, -1, 0]]).astype(np.float32)
h3 = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]).astype(np.float32)
SAx = convolve2d(img, h3, mode='same')
SAy = convolve2d(img, h1, mode='same')
gA = np.sqrt(np.multiply(SAx, SAx) + np.multiply(SAy, SAy))
aA = np.zeros_like(img)
aA[SAx == 0] = math.pi / 2
aA[SAx != 0]=np.arctan(SAy[SAx != 0] / SAx[SAx != 0])
return gA, aA
@classmethod
def Qabf_getQabf(cls,aA, gA, aF, gF):
L = 1
Tg = 0.9994
kg = -15
Dg = 0.5
Ta = 0.9879
ka = -22
Da = 0.8
GAF,AAF,QgAF,QaAF,QAF = np.zeros_like(aA),np.zeros_like(aA),np.zeros_like(aA),np.zeros_like(aA),np.zeros_like(aA)
GAF[gA>gF]=gF[gA>gF]/gA[gA>gF]
GAF[gA == gF] = gF[gA == gF]
GAF[gA <gF] = gA[gA<gF]/gF[gA<gF]
AAF = 1 - np.abs(aA - aF) / (math.pi / 2)
QgAF = Tg / (1 + np.exp(kg * (GAF - Dg)))
QaAF = Ta / (1 + np.exp(ka * (AAF - Da)))
QAF = QgAF* QaAF
return QAF-
Qabf方法接收三个输入图像（image_F,image_A,image_B），首先进行输入检查，然后分别计算每个图像的梯度（gA,gB,gF）和方向（aA,aB,aF）。 -
Qabf_getArray方法使用Sobel算子计算图像的梯度和方向。Sobel算子用于检测图像边缘，h1,h2, 和h3是用于计算x和y方向导数的滤波器。然后计算梯度的模（gA和gB），以及方向（aA和aB）。 -
Qabf_getQabf方法计算Qabf值。它涉及到以下几个关键计算：L,Tg,kg,Dg,Ta,ka, 和Da是预设的参数，用于调整Qabf的计算。GAF是融合梯度的调整，根据gA和gF的大小关系进行调整，以确保融合后的梯度不会过大或过小。AAF是角度差的调整，考虑了输入图像A和融合图像F的方向差异。QgAF和QaAF分别是基于梯度和角度调整的Q值。- 最终通过
QAF = QgAF * QaAF计算出融合图像的Qabf值。
-
QAF是返回的结果，表示输入图像A在融合图像F中的表现程度，值越高，表明融合质量越好。
12.SSIM（结构相似性指标 Structural Similarity Index Measure, SSIM ）
是一种用于比较两幅图像相似度的指标，它考虑了亮度、对比度和结构三个方面的信息。
SSIM值的范围在[-1, 1]之间，值越接近1表示两幅图像越相似，值越接近-1表示两幅图像越不相似，值为0表示两幅图像完全不同。
SSIM指标的计算基于以下三个因素：
- 亮度相似性（Luminance Similarity）：衡量图像的亮度信息是否一致。
- 对比度相似性（Contrast Similarity）：衡量图像的对比度信息是否一致。
- 结构相似性（Structure Similarity）：衡量图像的结构信息是否一致。
其次就是MSSIM，这个很容易理解就是源图像A与融合图像F的SSIM与源图像B与融合图像F的SSIM的平均值。
其次是多层级结构相似性(Multiscale structural similarity),简写为MS-SSIM。MS-SSIM能更好地与人眼视觉系统的视觉感知相一致，并且在一定的尺度下，评价效果优于SSIM，公式如下：
代码如下：（越接近1越好，输入三幅图像）
@classmethod
def SSIM(cls, image_F, image_A, image_B):
cls.input_check(image_F, image_A, image_B)
return ssim(image_F,image_A)+ssim(image_F,image_B)
参考：图像融合质量评价方法MSSIM、MS-SSIM、FS、Qmi、Qabf与VIFF（三）-CSDN博客
图像融合质量评价方法AG、SF、STD、MI与NMI（二）_nmi图像-CSDN博客
图像融合评估指标Python版_图像融合评价指标python-CSDN博客
![BUUCTF [极客大挑战 2019]EasySQL 1](https://img-blog.csdnimg.cn/direct/d5f64a03a0f44d1e96c8de9d38765f2e.png)
