一种简单的图像修复方法

该方法可以用于美颜中的祛斑，通过快速迭代的方式去除斑点。

假设输入图像为：

计算方向权重：

对于其他方向，操作类似We。

最终的输出为：

 

对要修复的区域，反复进行同样的操作即可。

 简单的matlab仿真代码如下：

clear
clc
close all

% 设定迭代次数
iter=100;

InputData = imread('anish.jpg');
InputData = rgb2gray(InputData);
InputData = double(InputData);

[height,width]=size(InputData);
mask=ones(height,width);

% 模拟产生斑点
imshow(uint8(InputData))
[x,y] = ginput();
InputData(x-3:x+3,y-3:y+3) = 0;
mask(x-3:x+3,y-3:y+3) = 0;
OutputData=InputData;

imshow(uint8(InputData)),title('input')

for t=1:1:iter
    for i=1:1:height
        for j=1:1:width
            if mask(i,j)==0
                if j>1&&j<width
                    E=j+1;
                    W=j-1;
                elseif j==1
                    E=j+1;
                    W=j+1;
                else
                    E=j-1;
                    W=j-1;
                end
                if i>1&&i<height
                    S=i+1;
                    N=i-1;
                elseif i==1
                    S=i+1;
                    N=i+1;
                else
                    S=i-1;
                    N=i-1;
                end
                Io=OutputData(i,j);
                Ie=OutputData(i,E);
                Iw=OutputData(i,W);
                In=OutputData(N,j);
                Is=OutputData(S,j);
                
                Ine=OutputData(N,E);
                Inw=OutputData(N,W);
                Ise=OutputData(S,E);
                Isw=OutputData(S,W);
                
                We=1+(Ie-Io)^2+(Ine+In-Ise-Is)^2/16;
                We=1/sqrt(We);
                
                Ww=1+(Iw-Io)^2+(Inw+In-Is-Isw)^2/16;
                Ww=1/sqrt(Ww);
                
                Ws=1+(Is-Io)^2+(Ise+Ie-Iw-Isw)^2/16;
                Ws=1/sqrt(Ws);
                
                Wn=1+(In-Io)^2+(Ine+Ie-Iw-Inw)^2/16;
                Wn=1/sqrt(Wn);
                
                OutputData(i,j)=(Ie*We+Iw*Ww+In*Wn+Is*Ws)/(We+Ww+Ws+Wn);                
            end
        end
    end
end
figure,imshow(uint8(OutputData)),title('output')

 结果如下：

一般地，如果待修复的区域越大，需要迭代的次数相对就大。