基于少量随机存活像素的大尺寸位图图像插值修复技术问询

针对仅留存1%以下随机存活像素的2000×2000位图，以下是适合的修复算法及代码实现：

一、传统修复算法（无需GPU） #

1. 全变分(TV)双调和插值 #

通过最小化图像总变分保持边缘结构，适合利用局部信息重构缺失区域，对低纹理图像效果尚可。

import numpy as np
from skimage import io, restoration
from skimage.color import rgba2rgb

# 读取并预处理图像
img = io.imread('damaged_image.png')
# 处理透明/黑色像素，生成掩码（True表示缺失像素）
if img.shape[-1] == 4:
    img_rgb = rgba2rgb(img)
    mask = (img[..., 3] == 0) | (np.all(img[..., :3] == 0, axis=-1))
else:
    img_rgb = img / 255.0
    mask = np.all(img == 0, axis=-1)

# 执行双调和插值修复
restored_img = restoration.inpaint_biharmonic(img_rgb, mask, channel_axis=-1)

# 保存结果
io.imsave('restored_tv.png', (restored_img * 255).astype(np.uint8))

2. 稀疏字典学习修复 #

通过训练图像块字典，用稀疏编码重构缺失区域，适合有重复纹理的图像。

import numpy as np
from sklearn.decomposition import MiniBatchDictionaryLearning
from skimage import io
from skimage.util import view_as_windows

# 提取含存活像素的图像块作为训练样本
def extract_valid_patches(img, mask, patch_size=8):
    patches = []
    for i in range(img.shape[0] - patch_size + 1):
        for j in range(img.shape[1] - patch_size + 1):
            patch_mask = mask[i:i+patch_size, j:j+patch_size]
            if not np.all(patch_mask):
                patches.append(img[i:i+patch_size, j:j+patch_size].flatten())
    return np.array(patches)

# 读取图像
img = io.imread('damaged_image.png') / 255.0
mask = np.all(img == 0, axis=-1)
patch_size = 8

# 训练字典
train_patches = extract_valid_patches(img, mask, patch_size)
dict_learner = MiniBatchDictionaryLearning(n_components=256, batch_size=32, max_iter=100)
dict_learner.fit(train_patches)

# 逐块重构缺失区域
restored_img = img.copy()
for i in range(img.shape[0] - patch_size + 1):
    for j in range(img.shape[1] - patch_size + 1):
        patch_mask = mask[i:i+patch_size, j:j+patch_size]
        if np.all(patch_mask):
            # 用字典生成重构块
            code = dict_learner.transform(restored_img[i:i+patch_size, j:j+patch_size].flatten().reshape(1, -1))
            recon_patch = code @ dict_learner.components_
            restored_img[i:i+patch_size, j:j+patch_size] = recon_patch.reshape(patch_size, patch_size, 3)

io.imsave('restored_sparse.png', (restored_img * 255).astype(np.uint8))

二、深度学习修复算法（需GPU，效果更优） #

当缺失率极高（<1%）时，传统方法依赖局部信息的局限性明显，深度学习能利用全局图像先验生成更接近原图的结果。

1. LaMa大掩码修复模型 #

专门针对大面积缺失场景设计，对随机稀疏缺失的修复效果显著，支持大尺寸图像。

import numpy as np
from PIL import Image
from lama_inpainting import LaMaInpainter  # 需提前安装LaMa库

# 初始化模型
inpainter = LaMaInpainter(model_path='lama_models/big-lama')

# 读取图像与生成掩码
img = Image.open('damaged_image.png').convert('RGB')
img_np = np.array(img)
# 掩码：缺失区域（黑色/透明）设为255，其余为0
mask_np = np.all(img_np == 0, axis=-1).astype(np.uint8) * 255
mask_img = Image.fromarray(mask_np)

# 执行修复
restored_img = inpainter.inpaint(img, mask_img)
restored_img.save('restored_lama.png')

2. Stable Diffusion 图像补全 #

利用扩散模型的生成能力，可通过提示词引导修复方向，适合需要保留原图风格或细节的场景。

from diffusers import StableDiffusionInpaintPipeline
import torch
from PIL import Image
import numpy as np

# 加载模型（需GPU，显存≥4GB）
pipe = StableDiffusionInpaintPipeline.from_pretrained(
    "runwayml/stable-diffusion-inpainting",
    torch_dtype=torch.float16
).to("cuda")

# 预处理图像与掩码（先缩放到模型支持的尺寸，修复后再放大）
orig_size = (2000, 2000)
img = Image.open("damaged_image.png").convert("RGB").resize((512, 512))
img_np = np.array(img)
mask_np = np.all(img_np == 0, axis=-1).astype(np.uint8) * 255
mask_img = Image.fromarray(mask_np).resize((512, 512))

# 提示词需贴合原图内容，引导模型生成正确结果
prompt = "photo of [原图内容描述], high resolution, realistic details"
restored_img = pipe(prompt=prompt, image=img, mask_image=mask_img).images[0]

# 缩放回原尺寸并保存
restored_img = restored_img.resize(orig_size)
restored_img.save("restored_sd.png")

注意事项 #

• 传统方法适合无GPU的场景，但修复效果受限于图像自身信息，高缺失率下表现一般。
• 深度学习方法需GPU加速，其中LaMa更适合纯修复（无需额外引导），Stable Diffusion适合需要风格/内容引导的场景。
• 2000×2000的大尺寸图像，建议先缩放至模型支持的尺寸修复后再放大，或使用支持大尺寸的LaMa模型。

内容的提问来源于stack exchange，提问作者user2214913