Python编程：图像增强-CSDN博客

本文链接：https://blog.csdn.net/WaitingHereFor/article/details/148866118

图像增强

图像增强是数字图像处理中的重要技术，旨在改善图像质量或突出图像中的有用信息，为后续的分析和处理提供更好的基础。

空间域图像增强

灰度变换定义

灰度变换是一种点处理（point processing）操作，可表示为：

s = T(r)

其中：

r：输入图像像素的原始灰度值（通常范围[0,L-1]，如8位图像为[0,255]）
s：变换后的输出灰度值
T：灰度变换函数

核心特性

单像素操作：输出值仅取决于对应位置的输入值
无邻域信息：不依赖周围像素值
可逆性：部分变换存在逆变换

1. 线性变换

(1) 基本形式

s = a·r + b
a：控制对比度（斜率）

a>1：对比度增强

0<a<1：对比度降低

a<0：明暗反转

b：控制亮度（截距）

b>0：亮度增加

b<0：亮度降低

(2) 对比度拉伸

def contrast_stretch(img, r1, r2, s1, s2):
    """分段线性变换"""
    # 构建查找表
    lut = np.zeros(256, dtype=np.uint8)
    for i in range(256):
        if i < r1:
            lut[i] = s1/r1 * i
        elif i < r2:
            lut[i] = (s2-s1)/(r2-r1) * (i-r1) + s1
        else:
            lut[i] = (255-s2)/(255-r2) * (i-r2) + s2
    return cv2.LUT(img, lut)

(3) 灰度级切片

突出特定范围：

s = max_intensity,  if a ≤ r ≤ b
    r,            otherwise

屏蔽其他区域：

s = max_intensity,  if a ≤ r ≤ b
    0,            otherwise

2. 非线性变换

(1) 对数变换

s = c·log(1 + r)

特性：
- 压缩高灰度值区域
- 扩展低灰度值区域
应用：
- 显示傅里叶频谱
- 增强暗部细节

OpenCV实现：

def log_transform(img, c=42):
    return cv2.convertScaleAbs(c * np.log1p(img.astype('float32')))

(2) 幂次变换（Gamma校正）

s = c·r^γ

参数影响：
- γ<1：增强亮部细节（如X光片）
- γ>1：增强暗部细节（如低照度图像）
- c：缩放系数（通常=1）
显示器校正：
- CRT显示器固有γ≈2.2
- 需要预补偿：γ≈0.45

OpenCV实现：

def gamma_correction(img, gamma=1.5):
    inv_gamma = 1.0 / gamma
    table = np.array([((i / 255.0) ** inv_gamma) * 255 
                    for i in np.arange(0, 256)]).astype("uint8")
    return cv2.LUT(img, table)

(3) 指数变换

s = c·(e^r - 1)

与对数变换效果相反
扩展高灰度值，压缩低灰度值
适用于增强亮部细节

import cv2
import numpy as np

# 线性变换
def linear_transform(img, alpha=1.5, beta=30):
    return cv2.convertScaleAbs(img, alpha=alpha, beta=beta)

# 分段线性变换
def piecewise_linear(img, breakpoints=[(0,0), (100,60), (200,220), (255,255)]):
    x = np.arange(256)
    y = np.interp(x, [p[0] for p in breakpoints], [p[1] for p in breakpoints])
    return cv2.LUT(img, y.astype('uint8'))

# 对数变换（压缩高亮区域）
def log_transform(img, c=42):
    return cv2.convertScaleAbs(c * np.log1p(img.astype('float32')))

# 幂次变换（伽马校正）
def gamma_correction(img, gamma=1.5):
    inv_gamma = 1.0 / gamma
    table = np.array([((i / 255.0) ** inv_gamma) * 255 
                    for i in np.arange(0, 256)]).astype("uint8")
    return cv2.LUT(img, table)

直方图处理

1. 直方图均衡化

(1) 数学原理

s_k = T(r_k) = (L-1)∑_{j=0}^k p_r(r_j)

其中：

p_r(r_j)：灰度级r_j出现的概率
L：灰度级数（如256）

(2) 处理效果

输出图像直方图近似均匀分布
扩展动态范围
可能过度增强噪声

(3) OpenCV实现

equalized = cv2.equalizeHist(img)

2. 自适应直方图均衡化(CLAHE)

(1) 改进原理

将图像分块处理
限制对比度增强幅度（clip limit）
双线性插值消除块效应

(2) 参数说明

clip limit：典型值2.0-3.0
tile grid size：常见8x8或16x16

(3) OpenCV实现

clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
clahe_img = clahe.apply(img)

# 直方图均衡化（全局）
def hist_equalization(img):
    if len(img.shape) == 3:  # 彩色图像
        ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
        ycrcb[:,:,0] = cv2.equalizeHist(ycrcb[:,:,0])
        return cv2.cvtColor(ycrcb, cv2.COLOR_YCrCb2BGR)
    else:  # 灰度图像
        return cv2.equalizeHist(img)

# 自适应直方图均衡化（CLAHE）
def clahe_enhancement(img, clip_limit=2.0, grid_size=(8,8)):
    if len(img.shape) == 3:
        lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
        l, a, b = cv2.split(lab)
        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=grid_size)
        l = clahe.apply(l)
        lab = cv2.merge((l, a, b))
        return cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
    else:
        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=grid_size)
        return clahe.apply(img)

应用场景

1. 医学影像

需求：突出特定组织对比度
方法：分段线性变换+Gamma校正

示例：

# 突出肺部区域
def lung_enhance(img):
    # 窗宽窗位变换
    window_center = -600
    window_width = 1500
    min_val = window_center - window_width//2
    max_val = window_center + window_width//2
    img = np.clip(img, min_val, max_val)
    img = ((img - min_val) / (max_val - min_val) * 255).astype('uint8')
    # Gamma校正
    return gamma_correction(img, 0.6)

2. 工业检测

需求：增强缺陷对比度
方法：高对比度拉伸+锐化

示例：

def defect_enhance(img):
    # 高对比度线性拉伸
    img = cv2.convertScaleAbs(img, alpha=3.0, beta=-100)
    # 锐化处理
    kernel = np.array([[-1,-1,-1], 
                      [-1,9,-1],
                      [-1,-1,-1]])
    return cv2.filter2D(img, -1, kernel)

3. 低照度图像

需求：提升暗部可见性
方法：对数变换+CLAHE

示例：

def lowlight_enhance(img):
    # 对数变换
    img_log = cv2.convertScaleAbs(42 * np.log1p(img.astype('float32')))
    # CLAHE处理
    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(16,16))
    return clahe.apply(img_log)

技术选型

变换类型	适用场景	优点	缺点
线性变换	全局对比度/亮度调整	计算简单，实时性好	可能丢失细节
分段线性变换	突出特定灰度范围	灵活控制不同区域	需要手动设置分段点
对数变换	高动态范围图像显示	有效压缩高光区域	计算涉及浮点运算
Gamma校正	显示设备校正/非均匀增强	符合人眼感知特性	需要经验选择γ值
直方图均衡化	全局对比度增强	自动处理，效果明显	可能放大噪声
CLAHE	局部对比度增强	保留细节，抑制噪声	计算复杂度较高

高级主题

1. 自适应Gamma校正

def adaptive_gamma(img, gamma_min=0.3, gamma_max=1.5):
    # 基于局部亮度计算gamma值
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    local_mean = cv2.blur(gray, (25,25)) / 255.0
    gamma_map = gamma_min + (gamma_max - gamma_min) * (1 - local_mean)
    
    # 应用逐像素gamma校正
    result = np.zeros_like(img, dtype=np.float32)
    for c in range(3):
        result[:,:,c] = np.power(img[:,:,c]/255.0, gamma_map) * 255
    return np.clip(result, 0, 255).astype('uint8')

2. 基于Retinex的增强

def retinex_enhance(img, sigma_list=[15,80,250]):
    # 多尺度Retinex算法
    img = img.astype('float32') + 1.0  # 避免log(0)
    retinex = np.zeros_like(img)
    for sigma in sigma_list:
        blurred = cv2.GaussianBlur(img, (0,0), sigma)
        retinex += np.log10(img) - np.log10(blurred)
    
    retinex = retinex / len(sigma_list)
    # 归一化到[0,255]
    for c in range(3):
        retinex[:,:,c] = cv2.normalize(retinex[:,:,c], None, 0, 255, cv2.NORM_MINMAX)
    return retinex.astype('uint8')

灰度变换作为图像处理的基础操作，其选择和应用需要结合具体场景需求。理解各类变换的数学本质和视觉效果差异，才能在实际应用中灵活组合，达到最优增强效果。

邻域运算（空间滤波）

2.1 平滑滤波

均值滤波：

用邻域内像素的平均值代替中心像素
核函数：1/(m×n)×全1矩阵
简单有效但会使边缘模糊
适用于高斯噪声去除

高斯滤波：

基于二维高斯函数构建加权平均核：
G(x,y) = (1/(2πσ²))·exp(-(x²+y²)/(2σ²))
σ控制平滑程度，σ越大模糊效果越强
具有各向同性特点，边缘保留优于均值滤波

中值滤波：

用邻域内像素的中值代替中心像素
非线性滤波，对椒盐噪声特别有效
能较好保留边缘锐度
窗口尺寸通常3×3或5×5

双边滤波：

同时考虑空间距离和灰度相似性：

BF[I]_p = 1/W_p ∑_{q∈S} G_σs(||p-q||)G_σr(|I_p-I_q|)I_q
W_p = ∑_{q∈S} G_σs(||p-q||)G_σr(|I_p-I_q|)

σs控制空间权重，σr控制灰度权重
能在平滑噪声的同时保持边缘清晰

# 均值滤波
def mean_filter(img, kernel_size=3):
    return cv2.blur(img, (kernel_size, kernel_size))

# 高斯滤波
def gaussian_filter(img, kernel_size=3, sigma=1.0):
    return cv2.GaussianBlur(img, (kernel_size, kernel_size), sigma)

# 中值滤波（去除椒盐噪声）
def median_filter(img, kernel_size=3):
    return cv2.medianBlur(img, kernel_size)

# 双边滤波（保边去噪）
def bilateral_filter(img, d=9, sigma_color=75, sigma_space=75):
    return cv2.bilateralFilter(img, d, sigma_color, sigma_space)

2.2 锐化滤波

Laplacian锐化：

基于二阶微分算子：
∇²f = ∂²f/∂x² + ∂²f/∂y² ≈ [f(x+1,y)+f(x-1,y)+f(x,y+1)+f(x,y-1)]-4f(x,y)
常用核：[[0,1,0],[1,-4,1],[0,1,0]]或[[1,1,1],[1,-8,1],[1,1,1]]
增强公式：g(x,y)=f(x,y)-k·∇²f(x,y)（k控制锐化强度）

Unsharp Masking：

对原图进行高斯模糊得到低频成分
原图减去低频成分得到高频成分
将加权的高频成分加回原图：
g(x,y) = f(x,y) + k·(f(x,y)-f̄(x,y))

阈值参数可避免增强平坦区域的噪声

Sobel边缘增强：

用Sobel算子计算水平和垂直梯度：

Gx = [[-1,0,1],[-2,0,2],[-1,0,1]]
Gy = [[-1,-2,-1],[0,0,0],[1,2,1]]

计算梯度幅值：G = √(Gx² + Gy²)
将梯度图像按比例加回原图

# Laplacian锐化
def laplacian_sharpen(img, k=1.0):
    laplacian = cv2.Laplacian(img, cv2.CV_32F)
    sharpened = img - k * laplacian
    return np.clip(sharpened, 0, 255).astype('uint8')

# Unsharp Masking（反锐化掩模）
def unsharp_mask(img, kernel_size=(5,5), sigma=1.0, amount=1.0, threshold=0):
    blurred = cv2.GaussianBlur(img, kernel_size, sigma)
    sharpened = float(amount + 1) * img - float(amount) * blurred
    sharpened = np.maximum(sharpened, np.zeros(sharpened.shape))
    sharpened = np.minimum(sharpened, 255 * np.ones(sharpened.shape))
    sharpened = sharpened.round().astype(np.uint8)
    if threshold > 0:
        low_contrast_mask = abs(img - blurred) < threshold
        np.copyto(sharpened, img, where=low_contrast_mask)
    return sharpened

# Sobel边缘增强
def sobel_enhance(img, ksize=3, scale=1.0):
    sobelx = cv2.Sobel(img, cv2.CV_32F, 1, 0, ksize=ksize)
    sobely = cv2.Sobel(img, cv2.CV_32F, 0, 1, ksize=ksize)
    magnitude = cv2.magnitude(sobelx, sobely)
    enhanced = cv2.addWeighted(img, 1.0, magnitude, scale, 0)
    return np.clip(enhanced, 0, 255).astype('uint8')

频率域图像增强

1. 傅里叶变换增强

基本流程：

对图像进行二维离散傅里叶变换(DFT)
将低频成分（图像中心）移到频谱中心
设计频域滤波器H(u,v)
应用滤波器：G(u,v) = F(u,v)·H(u,v)
反变换回空间域

高通滤波：

理想高通滤波器：

H(u,v) = 0  if D(u,v) ≤ D0
         1  if D(u,v) > D0

巴特沃斯高通滤波器：
H(u,v) = 1/[1 + (D0/D(u,v))^(2n)]
高斯高通滤波器：
H(u,v) = 1 - exp(-D²(u,v)/(2D0²))
其中D(u,v)是点(u,v)到中心的距离，D0是截止频率

def frequency_domain_enhancement(img, radius=30, boost=1.5):
    # 转换为灰度
    if len(img.shape) == 3:
        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 傅里叶变换
    dft = cv2.dft(np.float32(img), flags=cv2.DFT_COMPLEX_OUTPUT)
    dft_shift = np.fft.fftshift(dft)
    
    # 创建高通滤波器
    rows, cols = img.shape
    crow, ccol = rows//2, cols//2
    mask = np.ones((rows, cols, 2), np.uint8)
    cv2.circle(mask, (ccol, crow), radius, (0,0), -1)
    
    # 应用滤波器并增强高频
    fshift = dft_shift * (1 + boost * mask)
    
    # 逆变换
    f_ishift = np.fft.ifftshift(fshift)
    img_back = cv2.idft(f_ishift)
    img_back = cv2.magnitude(img_back[:,:,0], img_back[:,:,1])
    
    # 归一化
    cv2.normalize(img_back, img_back, 0, 255, cv2.NORM_MINMAX)
    return img_back.astype('uint8')

2. 同态滤波（同时增强暗部和抑制亮部）

成像模型：

将图像视为照度分量i(x,y)和反射分量r(x,y)的乘积：
f(x,y) = i(x,y)·r(x,y)
照度分量：低频，缓慢变化
反射分量：高频，快速变化（包含细节）

处理步骤：

取对数：ln f(x,y) = ln i(x,y) + ln r(x,y)
傅里叶变换：F{ln f(x,y)} = F{ln i(x,y)} + F{ln r(x,y)}
频域滤波：H(u,v)·F{ln f(x,y)}
反傅里叶变换
取指数得到增强后图像

滤波器设计：

典型传递函数：

H(u,v) = (γH - γL)[1 - exp(-c·D²(u,v)/D0²)] + γL

γL < 1压缩低频（照度），γH > 1增强高频（反射）
c控制过渡带陡度

def homomorphic_filter(img, gamma_l=0.5, gamma_h=2.0, c=1, d0=30):
    if len(img.shape) == 3:
        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 对数变换
    img_log = np.log1p(img.astype('float32'))
    
    # 傅里叶变换
    dft = cv2.dft(img_log, flags=cv2.DFT_COMPLEX_OUTPUT)
    dft_shift = np.fft.fftshift(dft)
    
    # 创建同态滤波器
    rows, cols = img.shape
    crow, ccol = rows//2, cols//2
    H = np.zeros((rows, cols, 2), dtype=np.float32)
    for u in range(rows):
        for v in range(cols):
            d = np.sqrt((u - crow)**2 + (v - ccol)**2)
            H[u,v] = (gamma_h - gamma_l) * (1 - np.exp(-c * (d**2 / d0**2))) + gamma_l
    
    # 应用滤波器
    filtered = dft_shift * H
    
    # 逆变换
    f_ishift = np.fft.ifftshift(filtered)
    img_back = cv2.idft(f_ishift)
    img_back = cv2.magnitude(img_back[:,:,0], img_back[:,:,1])
    
    # 指数变换
    img_exp = np.expm1(img_back)
    cv2.normalize(img_exp, img_exp, 0, 255, cv2.NORM_MINMAX)
    return img_exp.astype('uint8')

彩色图像增强

1. 色彩空间转换增强

HSV空间增强：

在HSV空间处理各分量：
- 色调(H)：通常保持不变
- 饱和度(S)：增强可提高色彩鲜艳度
- 明度(V)：可应用灰度图像增强方法
适合单独调整色彩饱和度和亮度

LAB空间增强：

L分量表示亮度，与颜色信息分离
A分量(绿-红轴)和B分量(蓝-黄轴)
对L分量增强不会影响颜色信息
特别适合需要保持色彩真实性的增强

def color_space_enhancement(img):
    # 转换到HSV空间增强饱和度
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    hsv[:,:,1] = cv2.equalizeHist(hsv[:,:,1])
    enhanced = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
    
    # 转换到LAB空间增强亮度
    lab = cv2.cvtColor(enhanced, cv2.COLOR_BGR2LAB)
    lab[:,:,0] = clahe_enhancement(lab[:,:,0])
    enhanced = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
    
    return enhanced

2. 白平衡算法

灰度世界假设：

认为整幅图像的平均反射是无色的(R=G=B)
计算各通道均值，调整至相等
数学表达：
```
R' = R * k/avgR
G' = G * k/avgG
B' = B * k/avgB
```
其中k通常取(avgR+avgG+avgB)/3

完美反射体假设：

寻找图像中最亮的像素点（假设为白色）
以这些点的RGB均值作为白点参考
对各通道进行比例缩放

对存在镜面反射的场景效果较好

def gray_world_white_balance(img):
    # 灰度世界假设
    b, g, r = cv2.split(img)
    avg_b = np.mean(b)
    avg_g = np.mean(g)
    avg_r = np.mean(r)
    
    # 计算增益
    avg_gray = (avg_b + avg_g + avg_r) / 3
    scale_b = avg_gray / avg_b
    scale_g = avg_gray / avg_g
    scale_r = avg_gray / avg_r
    
    # 应用增益
    b = cv2.convertScaleAbs(b, alpha=scale_b)
    g = cv2.convertScaleAbs(g, alpha=scale_g)
    r = cv2.convertScaleAbs(r, alpha=scale_r)
    
    return cv2.merge([b, g, r])

def perfect_reflection_white_balance(img, percentage=0.05):
    # 完美反射假设
    b, g, r = cv2.split(img)
    
    def channel_balance(channel):
        # 计算直方图
        hist, _ = np.histogram(channel, 256, [0, 256])
        # 找到最亮的percentage%像素
        sum_ = 0
        threshold = 0
        total_pixels = img.shape[0] * img.shape[1]
        for i in range(255, 0, -1):
            sum_ += hist[i]
            if sum_ > total_pixels * percentage:
                threshold = i
                break
        # 线性拉伸
        channel = np.clip(channel * (255.0 / threshold), 0, 255)
        return channel.astype('uint8')
    
    b = channel_balance(b)
    g = channel_balance(g)
    r = channel_balance(r)
    
    return cv2.merge([b, g, r])

基于深度学习的图像增强

1. CNN-based增强

常见网络结构：

编码器-解码器结构（如U-Net）
残差学习：学习残差映射H(x)=F(x)+x
注意力机制：聚焦重要区域
多尺度处理：捕获不同粒度特征

损失函数：

像素级损失：L1/L2损失
感知损失：基于VGG等网络的特征匹配
对抗损失：GAN框架中的判别器损失
色彩一致性损失：保持色彩自然性

2. GAN-based增强

基本框架：

生成器G：学习从低质量到高质量的映射
判别器D：区分生成图像和真实高质量图像

目标函数：

min_G max_D E[logD(x)] + E[log(1-D(G(z)))]

先进变体：

CycleGAN：无需成对数据的域转换
- 添加循环一致性损失：||G(F(x))-x|| + ||F(G(y))-y||
ESRGAN：增强型超分辨率GAN
- 使用RRDB（残差中的残差密集块）
- 引入感知损失和相对判别器

1. 使用预训练模型

import torch
import torchvision.transforms as transforms
from PIL import Image

def enhance_with_pretrained(img_path, model_path):
    # 加载图像
    img = Image.open(img_path).convert('RGB')
    
    # 预处理
    transform = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                           std=[0.229, 0.224, 0.225])
    ])
    img_t = transform(img).unsqueeze(0)
    
    # 加载模型
    model = torch.load(model_path)
    model.eval()
    
    # 推理
    with torch.no_grad():
        enhanced_t = model(img_t)
    
    # 后处理
    enhanced_t = enhanced_t.squeeze(0).cpu()
    enhanced_img = transforms.ToPILImage()(enhanced_t)
    
    return enhanced_img

2. 基于GAN的图像增强

def gan_enhancement(img_path, generator_path):
    # 这里以CycleGAN为例
    from cyclegan import Generator  # 假设有CycleGAN的实现
    
    # 初始化生成器
    generator = Generator()
    generator.load_state_dict(torch.load(generator_path))
    generator.eval()
    
    # 加载并预处理图像
    img = Image.open(img_path).convert('RGB')
    transform = transforms.Compose([
        transforms.Resize(256),
        transforms.ToTensor(),
        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    ])
    img_t = transform(img).unsqueeze(0)
    
    # 生成增强图像
    with torch.no_grad():
        enhanced_t = generator(img_t)
    
    # 反归一化并转换为PIL图像
    enhanced_t = enhanced_t.squeeze(0).cpu() * 0.5 + 0.5
    enhanced_img = transforms.ToPILImage()(enhanced_t)
    
    return enhanced_img

图像增强评估指标

1. 客观评价指标

PSNR（峰值信噪比）：

PSNR = 10·log10(MAX²/MSE)
MSE = 1/(mn)∑[I(i,j)-K(i,j)]²

MAX为最大像素值（如255）
计算简单但对人眼感知匹配不佳

SSIM（结构相似性）：

从亮度、对比度、结构三方面比较：

SSIM(x,y) = [l(x,y)]^α · [c(x,y)]^β · [s(x,y)]^γ
l(x,y) = (2μxμy + C1)/(μx² + μy² + C1)
c(x,y) = (2σxσy + C2)/(σx² + σy² + C2)
s(x,y) = (σxy + C3)/(σxσy + C3)

更符合人类视觉系统特性

def calculate_psnr(img1, img2):
    # 峰值信噪比
    mse = np.mean((img1 - img2) ** 2)
    if mse == 0:
        return float('inf')
    max_pixel = 255.0
    psnr = 20 * np.log10(max_pixel / np.sqrt(mse))
    return psnr

def calculate_ssim(img1, img2):
    # 结构相似性
    from skimage.metrics import structural_similarity as ssim
    if len(img1.shape) == 3:
        return ssim(img1, img2, multichannel=True)
    else:
        return ssim(img1, img2)

2. 无参考图像质量评估

BRISQUE：

提取 MSCN（均值减除对比度归一化）系数
计算 MSCN 系数的广义高斯分布参数
在图像块上计算这些特征
使用SVR模型预测质量分数

NIQE：

在自然图像库上提取特征（MSCN参数）
构建多元高斯(MVG)模型作为"自然"参考
计算测试图像特征与参考MVG的距离
距离越大表示质量越差

def calculate_brisque(img):
    # 盲/无参考图像空间质量评估器
    import brisque  # 需要安装brisque包
    return brisque.score(img)

def calculate_niqe(img):
    # 自然图像质量评估
    from skimage.metrics import niqe
    return niqe(img)