超分辨率技术之插值算法

🌞欢迎莅临我的个人主页👈🏻这里是我专注于深度学习领域、用心分享知识精粹与智慧火花的独特角落！🍉

🌈如果大家喜欢文章，欢迎：关注🍷+点赞👍🏻+评论✍🏻+收藏🌟，如有错误敬请指正！🪐

🍓“请不要相信胜利就像山坡上的蒲公英一样唾手可得，但是请相信生活中总有美好值得我们全力以赴，哪怕粉身碎骨！”🌹

前言

超分辨率是计算机视觉领域的重要技术，旨在提高低分辨率图像的质量。它通过复杂算法从低分辨率图像中重构出高分辨率图像，在医疗影像、影视娱乐等领域有广泛应用，为图像质量提升带来新突破。

超分辨率技术分为多种：插值算法、重建技术和深度学习。本文将重点介绍插值算法的原理和应用，并简要说明三种深度学习技术和相关专业软件在超分辨率领域的应用情况！

双线性插值

原理：对目标像素点的上下和左右像素点的数值进行线性插值，取其加权托盘。
优点：比最近邻接值更平滑，过渡减弱自然。
缺点：图像的细节和边缘可能会模糊。

🍃手写实现

def bilinear_interpolation(image, scale_factor):''':param image:   输入图像:param scale_factor:    缩放因子:return:'''image = np.array(image)image = image.astype(np.float32)height, width = image.shape[:2]new_height, new_width = int(height * scale_factor), int(width * scale_factor)# 初始化新图像if len(image.shape) == 3:  # 彩色图像new_image = np.zeros((new_height, new_width, image.shape[2]), dtype=image.dtype)else:  # 灰度图像new_image = np.zeros((new_height, new_width), dtype=image.dtype)# 缩放比例row_scale = height / new_heightcol_scale = width / new_widthfor i in range(new_height):for j in range(new_width):# 找到原图像中的对应坐标src_row = i * row_scalesrc_col = j * col_scale# 计算上下和左右的整数像素位置row_top = min(int(np.floor(src_row)), height - 2)row_bottom = row_top + 1col_left = min(int(np.floor(src_col)), width - 2)col_right = col_left + 1# 计算插值的权重row_weight = src_row - row_topcol_weight = src_col - col_left# 进行插值计算if len(image.shape) == 3:  # 彩色图像for c in range(image.shape[2]):top_left = image[row_top, col_left, c]top_right = image[row_top, col_right, c]bottom_left = image[row_bottom, col_left, c]bottom_right = image[row_bottom, col_right, c]top = top_left + (top_right - top_left) * col_weightbottom = bottom_left + (bottom_right - bottom_left) * col_weightnew_image[i, j, c] = top + (bottom - top) * row_weightelse:  # 灰度图像top_left = image[row_top, col_left]top_right = image[row_top, col_right]bottom_left = image[row_bottom, col_left]bottom_right = image[row_bottom, col_right]top = top_left + (top_right - top_left) * col_weightbottom = bottom_left + (bottom_right - bottom_left) * col_weightnew_image[i, j] = top + (bottom - top) * row_weightnew_image = Image.fromarray(np.clip(new_image, 0, 255).astype(np.uint8))return new_image

🍂内置函数

# Scipy
image1 = zoom(image, (scale_factor, scale_factor, 1), order=1)
# PIL
image2 = image.resize((height*scale_factor, width*scale_factor), Image.BILINEAR)

💥完整代码

import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
from scipy.ndimage import zoom# -----------------------------------------------------#
#                       双线性插值
# ------------------------------------------------------#
def bilinear_interpolation(image, scale_factor):''':param image:   输入图像:param scale_factor:    缩放因子:return:'''image = np.array(image)image = image.astype(np.float32)height, width = image.shape[:2]new_height, new_width = int(height * scale_factor), int(width * scale_factor)# 初始化新图像if len(image.shape) == 3:  # 彩色图像new_image = np.zeros((new_height, new_width, image.shape[2]), dtype=image.dtype)else:  # 灰度图像new_image = np.zeros((new_height, new_width), dtype=image.dtype)# 缩放比例row_scale = height / new_heightcol_scale = width / new_widthfor i in range(new_height):for j in range(new_width):# 找到原图像中的对应坐标src_row = i * row_scalesrc_col = j * col_scale# 计算上下和左右的整数像素位置row_top = min(int(np.floor(src_row)), height - 2)row_bottom = row_top + 1col_left = min(int(np.floor(src_col)), width - 2)col_right = col_left + 1# 计算插值的权重row_weight = src_row - row_topcol_weight = src_col - col_left# 进行插值计算if len(image.shape) == 3:  # 彩色图像for c in range(image.shape[2]):top_left = image[row_top, col_left, c]top_right = image[row_top, col_right, c]bottom_left = image[row_bottom, col_left, c]bottom_right = image[row_bottom, col_right, c]top = top_left + (top_right - top_left) * col_weightbottom = bottom_left + (bottom_right - bottom_left) * col_weightnew_image[i, j, c] = top + (bottom - top) * row_weightelse:  # 灰度图像top_left = image[row_top, col_left]top_right = image[row_top, col_right]bottom_left = image[row_bottom, col_left]bottom_right = image[row_bottom, col_right]top = top_left + (top_right - top_left) * col_weightbottom = bottom_left + (bottom_right - bottom_left) * col_weightnew_image[i, j] = top + (bottom - top) * row_weightnew_image = Image.fromarray(np.clip(new_image, 0, 255).astype(np.uint8))return new_imageif __name__ == '__main__':path = r'test/test.jpg'scale_factor = 3image = Image.open(path).convert('RGB')height, width = image.sizeimage_bilinear = bilinear_interpolation(image, scale_factor)image1 = zoom(image, (scale_factor, scale_factor, 1), order=1)image2 = image.resize((height*scale_factor, width*scale_factor), Image.BILINEAR)plt.subplot(2, 2, 1)plt.imshow(image)plt.title("Original")plt.subplot(2, 2, 2)plt.imshow(image_bilinear)plt.title("Bilinear")plt.subplot(2, 2, 3)plt.imshow(image1)plt.title("Scipy")plt.subplot(2, 2, 4)plt.imshow(image2)plt.title("PIL")plt.show()

🍓效果展示

双三次插值

原理：基于16个端点像素（距离最近的4x4像素块）进行三次迭代方式插值计算新像素的值。
优点：相比双线性插值，生成的图像更加平滑，边缘细节更好，过渡更自然。
缺点：计算量比双线性插值大，图像可能会有一些模糊。

🍃手写实现

def cubic_weight(t):"""计算三次插值权重的函数"""a = -0.5t = abs(t)if t <= 1:return (a + 2) * (t ** 3) - (a + 3) * (t ** 2) + 1elif t <= 2:return a * (t ** 3) - 5 * a * (t ** 2) + 8 * a * t - 4 * areturn 0def bicubic_interpolation(image, scale_factor):''':param image:   输入图像:param scale_factor: 缩放因子:return: '''img_np = np.array(image)img_np = img_np.astype(np.float32)original_height, original_width = img_np.shape[:2]new_height = int(original_height * scale_factor)new_width = int(original_width * scale_factor)new_img_np = np.zeros((new_height, new_width, img_np.shape[2]), dtype=img_np.dtype)# 遍历新图像的每个像素，进行双三次插值for i in range(new_height):for j in range(new_width):# 计算原始图像中浮点坐标的位置orig_x = i / scale_factororig_y = j / scale_factor# 取整得到插值中心的整数部分和小数部分x_int = int(orig_x)y_int = int(orig_y)dx = orig_x - x_intdy = orig_y - y_int# 双三次插值的核心部分，遍历16个邻近像素for m in range(-1, 3):for n in range(-1, 3):# 获取边界处理后的坐标xm = min(max(x_int + m, 0), original_height - 1)yn = min(max(y_int + n, 0), original_width - 1)# 计算权重weight_x = cubic_weight(m - dx)weight_y = cubic_weight(n - dy)weight = weight_x * weight_y# 插值计算，按通道计算new_img_np[i, j] += img_np[xm, yn] * weightnew_img = Image.fromarray(np.clip(new_img_np, 0, 255).astype(np.uint8))return new_img

🍂内置函数

image1 = image.resize((height * scale_factor, width * scale_factor), Image.BICUBIC)

💥完整代码

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt# -----------------------------------------------------#
#                       双三次插值
# ------------------------------------------------------#
def cubic_weight(t):"""计算三次插值权重的函数"""a = -0.5t = abs(t)if t <= 1:return (a + 2) * (t ** 3) - (a + 3) * (t ** 2) + 1elif t <= 2:return a * (t ** 3) - 5 * a * (t ** 2) + 8 * a * t - 4 * areturn 0def bicubic_interpolation(image, scale_factor):''':param image:   输入图像:param scale_factor: 缩放因子:return: '''img_np = np.array(image)img_np = img_np.astype(np.float32)original_height, original_width = img_np.shape[:2]new_height = int(original_height * scale_factor)new_width = int(original_width * scale_factor)new_img_np = np.zeros((new_height, new_width, img_np.shape[2]), dtype=img_np.dtype)# 遍历新图像的每个像素，进行双三次插值for i in range(new_height):for j in range(new_width):# 计算原始图像中浮点坐标的位置orig_x = i / scale_factororig_y = j / scale_factor# 取整得到插值中心的整数部分和小数部分x_int = int(orig_x)y_int = int(orig_y)dx = orig_x - x_intdy = orig_y - y_int# 双三次插值的核心部分，遍历16个邻近像素for m in range(-1, 3):for n in range(-1, 3):# 获取边界处理后的坐标xm = min(max(x_int + m, 0), original_height - 1)yn = min(max(y_int + n, 0), original_width - 1)# 计算权重weight_x = cubic_weight(m - dx)weight_y = cubic_weight(n - dy)weight = weight_x * weight_y# 插值计算，按通道计算new_img_np[i, j] += img_np[xm, yn] * weightnew_img = Image.fromarray(np.clip(new_img_np, 0, 255).astype(np.uint8))return new_imgif __name__ == '__main__':path = r'test/test.jpg'scale_factor = 3image = Image.open(path).convert('RGB')height, width = image.sizeimage0 = bicubic_interpolation(image, scale_factor)image1 = image.resize((height * scale_factor, width * scale_factor), Image.BICUBIC)plt.subplot(1, 3, 1)plt.imshow(image)plt.title("Original")plt.subplot(1, 3, 2)plt.imshow(image0)plt.title("Bicubic")plt.subplot(1, 3, 3)plt.imshow(image1)plt.title("PIL")plt.show()

🍓效果展示

Lanczos插值

原理：利用Lanczos核函数进行插值，通常在3x3或5x5像素邻域内进行计算。该方法是对双三次插值的进一步改进。
优点：高质量的插值，能够较好地保留图像细节，减少剪辑效果。
缺点：计算复杂度较高，容易产生振铃效应（ringing artifacts）。

🍃手写实现

def lanczos_weight(x, a):"""Lanczos 核函数，计算权重"""if x == 0:return 1elif -a < x < a:return np.sinc(x) * np.sinc(x / a)else:return 0def lanczos_interpolation_custom(image, scale_factor, a=3):''':param image:   输入图像:param scale_factor: 缩放因子:param a:   Lanczos 窗宽，通常为2或3:return:'''img_np = np.array(image)img_np = img_np.astype(np.float32)# 获取原始图像的尺寸original_height, original_width = img_np.shape[:2]# 计算新图像的尺寸new_height = int(original_height * scale_factor)new_width = int(original_width * scale_factor)# 创建新的图像矩阵new_img_np = np.zeros((new_height, new_width, img_np.shape[2]), dtype=img_np.dtype)# 遍历新图像的每个像素，进行 Lanczos 插值for i in range(new_height):for j in range(new_width):# 计算原始图像中浮点坐标的位置orig_x = i / scale_factororig_y = j / scale_factor# 取整得到整数部分和小数部分x_int = int(orig_x)y_int = int(orig_y)dx = orig_x - x_intdy = orig_y - y_int# Lanczos 插值核心部分，考虑 a×a 个邻近像素total_weight = 0for m in range(-a + 1, a):for n in range(-a + 1, a):xm = min(max(x_int + m, 0), original_height - 1)yn = min(max(y_int + n, 0), original_width - 1)weight_x = lanczos_weight(m - dx, a)weight_y = lanczos_weight(n - dy, a)weight = weight_x * weight_ynew_img_np[i, j] += img_np[xm, yn] * weighttotal_weight += weight# 防止权重过小，做归一化if total_weight > 0:new_img_np[i, j] = new_img_np[i, j] / total_weightnew_img = Image.fromarray(np.clip(new_img_np, 0, 255).astype(np.uint8))return new_img

🍂内置函数

image1 = image.resize((height * scale_factor, width * scale_factor), Image.LANCZOS)

💥完整代码

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt# -----------------------------------------------------#
#                   Lanczos插值
# ------------------------------------------------------#
def lanczos_weight(x, a):"""Lanczos 核函数，计算权重"""if x == 0:return 1elif -a < x < a:return np.sinc(x) * np.sinc(x / a)else:return 0def lanczos_interpolation_custom(image, scale_factor, a=3):''':param image:   输入图像:param scale_factor: 缩放因子:param a:   Lanczos 窗宽，通常为2或3:return:'''img_np = np.array(image)img_np = img_np.astype(np.float32)original_height, original_width = img_np.shape[:2]new_height = int(original_height * scale_factor)new_width = int(original_width * scale_factor)# 创建新的图像矩阵new_img_np = np.zeros((new_height, new_width, img_np.shape[2]), dtype=img_np.dtype)# 遍历新图像的每个像素，进行 Lanczos 插值for i in range(new_height):for j in range(new_width):# 计算原始图像中浮点坐标的位置orig_x = i / scale_factororig_y = j / scale_factor# 取整得到整数部分和小数部分x_int = int(orig_x)y_int = int(orig_y)dx = orig_x - x_intdy = orig_y - y_int# Lanczos 插值核心部分，考虑 a×a 个邻近像素total_weight = 0for m in range(-a + 1, a):for n in range(-a + 1, a):xm = min(max(x_int + m, 0), original_height - 1)yn = min(max(y_int + n, 0), original_width - 1)weight_x = lanczos_weight(m - dx, a)weight_y = lanczos_weight(n - dy, a)weight = weight_x * weight_ynew_img_np[i, j] += img_np[xm, yn] * weighttotal_weight += weight# 防止权重过小，做归一化if total_weight > 0:new_img_np[i, j] = new_img_np[i, j] / total_weightnew_img = Image.fromarray(np.clip(new_img_np, 0, 255).astype(np.uint8))return new_imgif __name__ == '__main__':path = r'test/test.jpg'scale_factor = 3image = Image.open(path).convert('RGB')height, width = image.sizeimage0 = lanczos_interpolation_custom(image, scale_factor)image1 = image.resize((height * scale_factor, width * scale_factor), Image.BILINEAR)plt.subplot(1, 3, 1)plt.imshow(image)plt.title("Original")plt.subplot(1, 3, 2)plt.imshow(image0)plt.title("Lanczos")plt.subplot(1, 3, 3)plt.imshow(image1)plt.title("PIL")plt.show()

🍓效果展示

样条插值

原理：通过样条函数（如立方样条函数）进行取值，以平滑曲线形式连接已知像素点，从而计算新的像素值。
优点：生成的图像非常平滑，适合处理曲线轮廓的图像。
缺点：计算复杂，可能导致图像过度平滑，损失细节。

🍃手写实现

def cubic_spline_coefficients(x, y):''':param x: x 坐标点数组（升序排列）:param y: y 坐标点数组:return: (a, b, c, d): 分段三次多项式系数'''n = len(x) - 1  # 段数h = np.diff(x)  # 每段的长度# 构造三对角矩阵 AA = np.zeros((n + 1, n + 1))A[0, 0] = 1A[n, n] = 1for i in range(1, n):A[i, i - 1] = h[i - 1]A[i, i] = 2 * (h[i - 1] + h[i])A[i, i + 1] = h[i]# 构造右侧的向量 BB = np.zeros(n + 1)for i in range(1, n):B[i] = 3 * ((y[i + 1] - y[i]) / h[i] - (y[i] - y[i - 1]) / h[i - 1])# 求解二阶导数向量 MM = np.linalg.solve(A, B)# 计算三次样条的系数 a, b, c, da = y[:-1]b = (y[1:] - y[:-1]) / h - h * (2 * M[:-1] + M[1:]) / 3c = M[:-1]d = (M[1:] - M[:-1]) / (3 * h)return a, b, c, ddef cubic_spline_interpolation_1d(x, y, x_new):''':param x:   原始数据的 x 坐标:param y:   原始数据的 y 坐标:param x_new:   要插值的 x 坐标点:return:    插值后对应的 y 值'''a, b, c, d = cubic_spline_coefficients(x, y)n = len(x) - 1y_new = np.zeros_like(x_new)for i, x_i in enumerate(x_new):for j in range(n):if x[j] <= x_i <= x[j + 1]:dx = x_i - x[j]y_new[i] = a[j] + b[j] * dx + c[j] * dx ** 2 + d[j] * dx ** 3breakreturn y_newdef cubic_spline_interpolation_image(image, scale_factor):''':param image: 输入图像:param scale_factor:    缩放因子:return:'''image = np.array(image)image = image.astype(np.float32)height, width = image.shape[:2]# 创建原始图像的网格x = np.arange(width)y = np.arange(height)# 创建新图像的网格new_x = np.linspace(0, width - 1, int(width * scale_factor))new_y = np.linspace(0, height - 1, int(height * scale_factor))# 初始化新图像if len(image.shape) == 3:  # 彩色图像channels = image.shape[2]new_image = np.zeros((len(new_y), len(new_x), channels), dtype=image.dtype)for c in range(channels):# 对每个通道进行行和列的插值temp = np.zeros((height, len(new_x)), dtype=image.dtype)for i in range(height):temp[i, :] = cubic_spline_interpolation_1d(x, image[i, :, c], new_x)for j in range(len(new_x)):new_image[:, j, c] = cubic_spline_interpolation_1d(y, temp[:, j], new_y)else:  # 灰度图像temp = np.zeros((height, len(new_x)), dtype=image.dtype)new_image = np.zeros((len(new_y), len(new_x)), dtype=image.dtype)for i in range(height):temp[i, :] = cubic_spline_interpolation_1d(x, image[i, :], new_x)for j in range(len(new_x)):new_image[:, j] = cubic_spline_interpolation_1d(y, temp[:, j], new_y)new_image = Image.fromarray(np.clip(new_image, 0, 255).astype(np.uint8))return new_image

🍂内置函数

from scipy.interpolate import RectBivariateSplinedef spline_interpolation(image, scale_factor):''':param image: 输入图像:param scale_factor:    缩放因子:return:'''image = np.array(image)image = image.astype(np.float32)height, width = image.shape[:2]# 创建原始图像的网格x = np.arange(width)y = np.arange(height)# 创建新图像的网格new_x = np.linspace(0, width - 1, int(width * scale_factor))new_y = np.linspace(0, height - 1, int(height * scale_factor))# 初始化新图像if len(image.shape) == 3:  # 彩色图像channels = image.shape[2]new_image = np.zeros((len(new_y), len(new_x), channels), dtype=image.dtype)for c in range(channels):# 对每个通道使用 RectBivariateSpline 进行插值spline = RectBivariateSpline(y, x, image[:, :, c])new_image[:, :, c] = spline(new_y, new_x)else:  # 灰度图像spline = RectBivariateSpline(y, x, image)new_image = spline(new_y, new_x)new_image = Image.fromarray(np.clip(new_image, 0, 255).astype(np.uint8))return new_image

💥完整代码

import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import RectBivariateSpline
from PIL import Image# -----------------------------------------------------#
#                   样条插值
# ------------------------------------------------------#
# --------------------手写实现-------------------------#
def cubic_spline_coefficients(x, y):''':param x: x 坐标点数组（升序排列）:param y: y 坐标点数组:return: (a, b, c, d): 分段三次多项式系数'''n = len(x) - 1  # 段数h = np.diff(x)  # 每段的长度# 构造三对角矩阵 AA = np.zeros((n + 1, n + 1))A[0, 0] = 1A[n, n] = 1for i in range(1, n):A[i, i - 1] = h[i - 1]A[i, i] = 2 * (h[i - 1] + h[i])A[i, i + 1] = h[i]# 构造右侧的向量 BB = np.zeros(n + 1)for i in range(1, n):B[i] = 3 * ((y[i + 1] - y[i]) / h[i] - (y[i] - y[i - 1]) / h[i - 1])# 求解二阶导数向量 MM = np.linalg.solve(A, B)# 计算三次样条的系数 a, b, c, da = y[:-1]b = (y[1:] - y[:-1]) / h - h * (2 * M[:-1] + M[1:]) / 3c = M[:-1]d = (M[1:] - M[:-1]) / (3 * h)return a, b, c, ddef cubic_spline_interpolation_1d(x, y, x_new):''':param x:   原始数据的 x 坐标:param y:   原始数据的 y 坐标:param x_new:   要插值的 x 坐标点:return:    插值后对应的 y 值'''a, b, c, d = cubic_spline_coefficients(x, y)n = len(x) - 1y_new = np.zeros_like(x_new)for i, x_i in enumerate(x_new):for j in range(n):if x[j] <= x_i <= x[j + 1]:dx = x_i - x[j]y_new[i] = a[j] + b[j] * dx + c[j] * dx ** 2 + d[j] * dx ** 3breakreturn y_newdef cubic_spline_interpolation_image(image, scale_factor):''':param image: 输入图像:param scale_factor:    缩放因子:return:'''image = np.array(image)image = image.astype(np.float32)height, width = image.shape[:2]# 创建原始图像的网格x = np.arange(width)y = np.arange(height)# 创建新图像的网格new_x = np.linspace(0, width - 1, int(width * scale_factor))new_y = np.linspace(0, height - 1, int(height * scale_factor))# 初始化新图像if len(image.shape) == 3:  # 彩色图像channels = image.shape[2]new_image = np.zeros((len(new_y), len(new_x), channels), dtype=image.dtype)for c in range(channels):# 对每个通道进行行和列的插值temp = np.zeros((height, len(new_x)), dtype=image.dtype)for i in range(height):temp[i, :] = cubic_spline_interpolation_1d(x, image[i, :, c], new_x)for j in range(len(new_x)):new_image[:, j, c] = cubic_spline_interpolation_1d(y, temp[:, j], new_y)else:  # 灰度图像temp = np.zeros((height, len(new_x)), dtype=image.dtype)new_image = np.zeros((len(new_y), len(new_x)), dtype=image.dtype)for i in range(height):temp[i, :] = cubic_spline_interpolation_1d(x, image[i, :], new_x)for j in range(len(new_x)):new_image[:, j] = cubic_spline_interpolation_1d(y, temp[:, j], new_y)new_image = Image.fromarray(np.clip(new_image, 0, 255).astype(np.uint8))return new_image# --------------------------内置函数--------------------------------------#def spline_interpolation(image, scale_factor):''':param image: 输入图像:param scale_factor:    缩放因子:return:'''image = np.array(image)image = image.astype(np.float32)height, width = image.shape[:2]# 创建原始图像的网格x = np.arange(width)y = np.arange(height)# 创建新图像的网格new_x = np.linspace(0, width - 1, int(width * scale_factor))new_y = np.linspace(0, height - 1, int(height * scale_factor))# 初始化新图像if len(image.shape) == 3:  # 彩色图像channels = image.shape[2]new_image = np.zeros((len(new_y), len(new_x), channels), dtype=image.dtype)for c in range(channels):# 对每个通道使用 RectBivariateSpline 进行插值spline = RectBivariateSpline(y, x, image[:, :, c])new_image[:, :, c] = spline(new_y, new_x)else:  # 灰度图像spline = RectBivariateSpline(y, x, image)new_image = spline(new_y, new_x)new_image = Image.fromarray(np.clip(new_image, 0, 255).astype(np.uint8))return new_imageif __name__ == '__main__':path = r'test/test.jpg'scale_factor = 3image = Image.open(path).convert('RGB')height, width = image.sizeimage_spline = cubic_spline_interpolation_image(image, scale_factor)image1 = spline_interpolation(image, scale_factor)plt.subplot(1, 3, 1)plt.imshow(image)plt.title("Original")plt.subplot(1, 3, 2)plt.imshow(image_spline)plt.title("Spline")plt.subplot(1, 3, 3)plt.imshow(image1)plt.title("Scipy")plt.show()

🍓效果展示

高斯插值

原理：基于高斯分布的加权平均方法，通过赋予相邻像素不同的权重来计算新的像素值。
优点：平滑并保留一定的细节，减少噪声影响。
缺点：计算复杂度首要。

🍃手写实现

def gaussian_weight(distance, sigma):"""计算距离对应的高斯权重"""return math.exp(-(distance ** 2) / (2 * sigma ** 2))def gaussian_kernel(size, sigma):"""生成高斯核"""kernel = np.zeros((size, size))center = size // 2for i in range(size):for j in range(size):distance = np.sqrt((i - center) ** 2 + (j - center) ** 2)kernel[i, j] = gaussian_weight(distance, sigma)return kernel / np.sum(kernel)  # 归一化核def gaussian_interpolation(image, scale_factor, kernel_size=3, sigma=0.5):"""使用高斯插值对图像进行缩放"""image = np.array(image)image = image.astype(np.float32)height, width = image.shape[:2]kernel = gaussian_kernel(kernel_size, sigma)new_height, new_width = int(height * scale_factor), int(width * scale_factor)if len(image.shape) == 3:  # 彩色图像new_image = np.zeros((new_height, new_width, image.shape[2]), dtype=image.dtype)else:  # 灰度图像new_image = np.zeros((new_height, new_width), dtype=image.dtype)# 缩放比例row_scale = height / new_heightcol_scale = width / new_width# 对新图像的每个像素进行插值for i in range(new_height):for j in range(new_width):# 在原图像中找到对应的坐标src_row = i * row_scalesrc_col = j * col_scalerow_floor = int(np.floor(src_row))col_floor = int(np.floor(src_col))# 初始化加权和weighted_sum = np.zeros(image.shape[2]) if len(image.shape) == 3 else 0.0weight_total = 0.0# 遍历高斯核for m in range(kernel_size):for n in range(kernel_size):row_offset = row_floor + m - kernel_size // 2col_offset = col_floor + n - kernel_size // 2# 如果超出图像边界，跳过该点if row_offset < 0 or row_offset >= height or col_offset < 0 or col_offset >= width:continue# 加权平均weight = kernel[m, n]if len(image.shape) == 3:weighted_sum += weight * image[row_offset, col_offset, :]else:weighted_sum += weight * image[row_offset, col_offset]weight_total += weight# 归一化结果if len(image.shape) == 3:new_image[i, j, :] = weighted_sum / weight_totalelse:new_image[i, j] = weighted_sum / weight_totalnew_image = Image.fromarray(np.clip(new_image, 0, 255).astype(np.uint8))return new_image

🍂内置函数

from scipy.ndimage import gaussian_filter
image1 = gaussian_filter(image, sigma=0.5)

💥完整代码

import numpy as np
import math
import matplotlib.pyplot as plt
from scipy.ndimage import gaussian_filter
from PIL import Image# -----------------------------------------------------#
#                   高斯插值
# ------------------------------------------------------#
def gaussian_weight(distance, sigma):"""计算距离对应的高斯权重"""return math.exp(-(distance ** 2) / (2 * sigma ** 2))def gaussian_kernel(size, sigma):"""生成高斯核"""kernel = np.zeros((size, size))center = size // 2for i in range(size):for j in range(size):distance = np.sqrt((i - center) ** 2 + (j - center) ** 2)kernel[i, j] = gaussian_weight(distance, sigma)return kernel / np.sum(kernel)  # 归一化核def gaussian_interpolation(image, scale_factor, kernel_size=3, sigma=0.5):"""使用高斯插值对图像进行缩放"""image = np.array(image)image = image.astype(np.float32)height, width = image.shape[:2]kernel = gaussian_kernel(kernel_size, sigma)new_height, new_width = int(height * scale_factor), int(width * scale_factor)if len(image.shape) == 3:  # 彩色图像new_image = np.zeros((new_height, new_width, image.shape[2]), dtype=image.dtype)else:  # 灰度图像new_image = np.zeros((new_height, new_width), dtype=image.dtype)# 缩放比例row_scale = height / new_heightcol_scale = width / new_width# 对新图像的每个像素进行插值for i in range(new_height):for j in range(new_width):# 在原图像中找到对应的坐标src_row = i * row_scalesrc_col = j * col_scalerow_floor = int(np.floor(src_row))col_floor = int(np.floor(src_col))# 初始化加权和weighted_sum = np.zeros(image.shape[2]) if len(image.shape) == 3 else 0.0weight_total = 0.0# 遍历高斯核for m in range(kernel_size):for n in range(kernel_size):row_offset = row_floor + m - kernel_size // 2col_offset = col_floor + n - kernel_size // 2# 如果超出图像边界，跳过该点if row_offset < 0 or row_offset >= height or col_offset < 0 or col_offset >= width:continue# 加权平均weight = kernel[m, n]if len(image.shape) == 3:weighted_sum += weight * image[row_offset, col_offset, :]else:weighted_sum += weight * image[row_offset, col_offset]weight_total += weight# 归一化结果if len(image.shape) == 3:new_image[i, j, :] = weighted_sum / weight_totalelse:new_image[i, j] = weighted_sum / weight_totalnew_image = Image.fromarray(np.clip(new_image, 0, 255).astype(np.uint8))return new_imageif __name__ == '__main__':path = r'test/test.jpg'scale_factor = 3image = Image.open(path).convert('RGB')height, width = image.sizeimage_gaussian = gaussian_interpolation(image, scale_factor, kernel_size=3, sigma=0.5)image1 = gaussian_filter(image, sigma=0.5)plt.subplot(1, 3, 1)plt.imshow(image)plt.title("Original")plt.subplot(1, 3, 2)plt.imshow(image_gaussian)plt.title("Gaussian")plt.subplot(1, 3, 3)plt.imshow(image1)plt.title("Scipy")plt.show()

🍓效果展示

深度学习的SR技术

总体而言，基于插值的方法相对简单，在超分辨率重建中的性能往往不如基于学习的方法。因此下面我们就简单介绍3种在OpenCV基于深度学习的超分辨率模型实践方法吧。

1️⃣安装opencv和contrib模块

contrib模块是SR接口代码所在的位置，我们需要使用的接口或模块称为dnn_superres（dnn代表深度神经网络；superres代表超分辨率）

pip install opencv-python
pip install opencv-contrib-python

2️⃣模型下载

当前在OpenCV主要支持4中不同的SR模型，它们都可以按2、3和4的比例放大图像，但是在准确性、大小和速度上各部相同。

EDSR：目前表现最好的模型。然而，它也是参数量最大的模型，因此具有最大的文件大小和最慢的推理。

下载链接：https://github.com/Saafke/EDSR_Tensorflow/tree/master/models

ESPCN：相对较小的模型，具有快速和良好的推理能力，可以进行实时视频放大（取决于图像大小）。

下载链接：https://github.com/fannymonori/TF-ESPCN/tree/master/export

FSRCNN：快速准确推理的小模型，还可以进行实时视频放大。

下载链接：https://github.com/Saafke/FSRCNN_Tensorflow/tree/master/models

LapSRN：中等大小的模型，可以提升8倍分辨率。

下载链接：https://github.com/fannymonori/TF-LapSRN/tree/master/export

3️⃣实践

import cv2
from cv2 import dnn_superressr = dnn_superres.DnnSuperResImpl_create()
# -------------------输入图像路径--------------------------#
path = r'test/test.jpg'
# ----------------------模型路径---------------------------#
model = r'models/EDSR/EDSR_x3.pb'image = cv2.imread(path)sr.readModel(model)
sr.setModel('edsr', 3)
result = sr.upsample(image)cv2.imshow('image', result)
cv2.waitKey()
cv2.destroyAllWindows()

4️⃣注意事项

在使用.jpg图像时出现错误，请尝试切换到.png格式。
确保setModel()中的参数与readModel()中使用的模型匹配。
想使用GPU进行推理（默认是CPU），可以在读入模型后将后端设置为CUDA

path = "EDSR_x3.pb"
sr.readModel(path)# Set CUDA backend and target to enable GPU inference
sr.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
sr.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)

5️⃣效果展示

我只尝试了3种SR模型，没有使用LapSRN模型，但就目前来看，EDSR在细节方面确实是表现得最好的一个，但缺点就是推理时间太长了，长达3秒钟。

画质增强专业软件

🍁除了使用代码进行画质增强，我们还可以使用相关的专业软件进行处理噢🍁

Upscayl的GitHub地址：https://github.com/upscayl/upscayl

Upscayl项目是一个免费开源的 AI 图像升频器，支持 Linux、macOS 和 Windows 系统。它使用先进的人工智能算法来放大和增强低分辨率图像，且不损失质量。在该项目页面中，可以找到相关的代码、文档、发布版本等信息。如果大家对图像增强、人工智能图像处理等方面感兴趣，可以关注这个项目。