Plusieurs conditions aux limites d'image hypothétiques couramment utilisées sont utilisées pour supprimer l'effet de sonnerie et sa réalisation (ci-dessous)

Trois autres BC

1. répété BC

        Xu Zhou et al. Ont mentionné dans "Un cadre de déconvolution basé sur des conditions aux limites pour la suppression du flou d'image" que la formule écrite dans le texte original est plus compliquée et difficile à comprendre, donc je ne la répéterai pas. En fait, le noyau est le gris d'un certain pixel dans la zone de limite extérieure. Le degré est égal à l'échelle de gris du pixel dans l'image la plus proche. La ligne de séparation étant horizontale ou verticale, c'est encore plus simple. Supposons que la limite extérieure soit divisée en 8 zones:

        Autrement dit: toutes les valeurs de pixel de 1 sont égales à la valeur de pixel dans le coin supérieur gauche de l'image interne, 3, 6 et 8 sont similaires au coin supérieur droit, au coin inférieur gauche et au coin inférieur droit coin respectivement; la valeur de pixel de chaque pixel dans 2, 7 est dans la même colonne de l'image interne La valeur de pixel haut / bas; la valeur de pixel de chaque pixel entre 4 et 5 est la valeur de pixel gauche / droite de l'image interne doubler.

2. BC indéterminé

        Dans "Image et profondeur d'une caméra conventionnelle avec une ouverture codée", le BC suppose que l'image originale x est agrandie en une image agrandie xe avec des conditions aux limites supposées. La fonction P (étant la matrice des conditions aux limites) est inconnue, et le valeur de P Le noyau est 0.

3. Méthode des limites lisses

        De "Réduire les artefacts de frontière dans la déconvolution d'image". Afin de gagner du temps et d'éviter que les images dessinées par moi-même ne soient trop chaudes, j'utilise directement certaines des images et des formules du papier.

        Comme le montre la figure, G est l'image originale de l'image de taille M * N. L'auteur suppose que A, B et C de la même taille que G. Le bas et le haut de A sont similaires au haut et au bas de G autant que possible; la gauche de B Les parties gauche et droite sont aussi similaires que possible aux parties droite et gauche de G; le bas et le haut de C sont aussi similaires que possible au haut et au bas de B; les parties gauche et les parties droites de C sont les mêmes que les parties droite et gauche de A. Cela peut être similaire; comme indiqué en (b), la même couleur est la partie similaire, et l'image agrandie finale est le T de (c).

        L'auteur suppose d'abord que la largeur de la bordure est (dans cet article, la largeur de la bordure est différente de la dernière largeur de la bordure développée), et A 'est utilisé pour représenter l'image développée par A à travers les bordures supérieure et inférieure, et la taille est (M + 2 ) * N, et satisfait:

        La zone de calcul de la formule A 'ci-dessus est la zone limite de A. La valeur de i est de 1 à  . La partie gauche sur le côté droit de l'équation représente l'image d'origine et l'image lissée filtrée par le filtre gaussien. A est obtenu en minimisant la formule suivante:

        A est exprimé filtre laplacien,  représente la limite extérieure du carré le plus bas formulé 'dans le carré de la valeur de différence A est satisfaite et une valeur de gradient du second ordre A et la limite avec un minimum La meilleure solution est la valeur finale A. Il en va de même pour B et C. Notez que B 'est M * (N + 2 ) et C' est (M + 2 ) * (N + 2 ). La limite de B 'est de la colonne 1 à la colonne et la colonne N + +1 à la colonne N + 2 , et la zone limite de C est la colonne 1 à la colonne et la colonne N + +1 à la colonne N + 2, la colonne 1 à la ligne et colonne N + +1 Aller à la ligne N + 2 .

4. Conditions aux limites progressives

       De "Restauration aveugle des images floues de mouvement basée sur la régularisation clairsemée et l'hypothèse de frontière asymptotique". Supposons que la largeur de la bordure développée est n et que la taille de l'image est H * W. L'auteur divise l'image développée en 8 parties, et la zone 1 ~ 4 est développée dans la direction de l'intérieur vers l'extérieur:

La méthode d'expansion est la suivante: (y représente l'image floue d'origine)

Pour la zone 1:

Autrement dit, pour un certain pixel, sa valeur de gris est égale à la moyenne des valeurs de gris des trois pixels ci-dessous, en bas à gauche et en bas à droite. En particulier, s'il est situé à la limite, il est la moyenne de deux pixels où trois pixels sont situés dans le pixel.

 Pour la zone 2:

Les régions 3 et 4 sont similaires. Ensuite, les zones 1 ~ 4 évoluent progressivement, c'est-à-dire devenant de plus en plus sombres de l'intérieur vers l'extérieur:

 

Pour les zones 5 à 8, développez dans les directions suivantes:

 En prenant la zone 5 comme exemple, la valeur de gris d'un pixel dans le triangle inférieur est égale à la valeur de gris du pixel le plus proche dans la même colonne dans la zone 2, et le triangle supérieur est égal à la valeur de gris la plus proche dans la même ligne . Les pixels sur la diagonale sont les valeurs moyennes de la même ligne et de la même colonne.

Les effets répétés de la Colombie-Britannique sont les suivants:

Les effets des conditions aux limites progressives sont les suivants:

        Cependant, je comprends assez vaguement la méthode des limites lisses. Parce qu'elle est un peu étourdissante à mettre en œuvre, je colle la définition originale de A 'et:

        Nous développons le bloc A de quelques pixels verticalement, ce qui donne un bloc carré plus grand A 'contenant A et sa bordure extérieure ∂A. ∂A est défini comme ......

        Ce qui suit est la première formule. Le casse-tête est le suivant: si A est H * W, la limite extérieure de A est aussi similaire que possible aux première et dernière lignes alpha de A ', et le gradient de A est aussi petit que possible. . . La condition qui fait apparaître la formule n'est-elle pas le minimum que la limite extérieure soit les lignes de A ', et le H * W de l'image intérieure est tout zéro? Parce que le gradient est calculé uniquement en interne. Et si c'est pour calculer le gradient de la limite extérieure de A +, alors c'est compréhensible et le résultat est idéal, mais il n'est pas conforme à l'énoncé de la formule, car la formule est écrite , non . Mais si ce n'est que pour A, cela n'a pas de sens. Dans la formule, la zone située dans le coin inférieur droit du côté droit de la fonction de minimisation est limitée à , si je comprends bien, elle fait référence à la limite extérieure de A et aux lignes de A ', et non à la zone de limite extérieure de A et A '. Égaux. On suppose ici que le gradient est obtenu à partir de A et de la limite extérieure, mais le résultat final n'est que l'image du centre de A.

A, B et C sont obtenus comme suit:

Le T final:

Partie de code:

1. répété BC

x=rgb2gray(imread('tt.jpg'));
[N1,N2]=size(x);
% [M1,M2]=size(Psf);
M1=127;
M2=127;
m1=(M1-1)/2;
m2=(M1-1)/2;
%Repeated BC

xe=zeros(N1+2*m1,N2+2*m2);
for i=1:N1+2*m1
    for j=1:N2+2*m2
        if i<=m1 
            if j<=m1%区域1
                xe(i,j)=x(1,1);
            elseif j<=m1+N2 %区域2
                xe(i,j)=x(1,j-m1);
            else %区域3
                xe(i,j)=x(1,N2);
            end
        elseif i<=m1+N1 %区域4
            if j<=m1
                xe(i,j)=x(i-m1,1);
            elseif j<=m1+N2%内部图像区域
                 xe(i,j)=x(i-m1,j-m1);
            else%区域5
                xe(i,j)=x(i-m1,N2);
            end
        else
            if j<=m1%区域6
                xe(i,j)=x(N1,1);
            elseif j<=m1+N2%区域7
                 xe(i,j)=x(N1,j-m1);
            else%区域8
                xe(i,j)=x(N1,N2);
            end   
        end
    end
end

4. Conditions de bord progressives:

%title:《Blind Restoration of Motion Blurred Images Based on Sparse Regularization and Asymptotic Boundary Hypothesis》
%基于稀疏正则化和渐近边界假设的运动模糊图像盲复原 

f=rgb2gray(imread('tt.jpg'));
[H,W]=size(f);
% psf=load('psf_304.txt');
% Psf=psf./sum(sum(psf));
% y=imfilter(f,Psf,'conv'); 
% [n,n2]=size(psf);%模糊核大小
n=128;%宽度
I=zeros(H+2*n,W+2*n);
I(n+1:n+H,n+1:n+W)=f;
%area 1
for i=n:-1:1%注意从内向外，在area1为从下到上递减
    for j=n+1:n+W
        if j==n+1
            I(i,j)=(I(i+1,j)+I(i+1,j+1))/2;%如果位于最左侧
        elseif j==n+W
            I(i,j)=(I(i+1,j)+I(i+1,j-1))/2;%如果位于最右侧
        else
            I(i,j)=(I(i+1,j-1)+I(i+1,j)+I(i+1,j+1))/3;%其余情况
        end
    end
end
%area 4
for i=n+H+1:n+H+n%注意从内向外，在area1为从上到下递增
    for j=n+1:n+W
        if j==n+1
            I(i,j)=(I(i-1,j)+I(i-1,j+1))/2;
        elseif j==n+W
            I(i,j)=(I(i-1,j)+I(i-1,j-1))/2;
        else
            I(i,j)=(I(i-1,j-1)+I(i-1,j)+I(i-1,j+1))/3;
        end
    end
end
%area 2
for j=n:-1:1
    for i=n+1:n+H
        if i==n+1
            I(i,j)=(I(i,j+1)+I(i+1,j+1))/2;
        elseif i==n+W
            I(i,j)=(I(i,j+1)+I(i-1,j+1))/2;
        else
            I(i,j)=(I(i-1,j+1)+I(i,j+1)+I(i+1,j+1))/3;
        end
    end
end
%area 3
for j=n+W+1:n+W+n
    for i=n+1:n+H
        if i==n+1
            I(i,j)=(I(i,j-1)+I(i+1,j-1))/2;
        elseif i==n+W
            I(i,j)=(I(i,j-1)+I(i-1,j-1))/2;
        else
            I(i,j)=(I(i-1,j-1)+I(i,j-1)+I(i+1,j-1))/3;
        end
    end
end
for i=1:n%渐进缩放
    I(i,n+1:n+W)=I(i,n+1:n+W)*(i-1)/n;
    I(n+1:n+H,i)=I(n+1:n+H,i)*(i-1)/n;
    I(n+1:n+H,n+W+i)=I(n+1:n+H,n+W+i)*(n-i)/n;
    I(n+H+i,n+1:n+W)=I(n+H+i,n+1:n+W)*(n-i)/n;
end

% area 5
for i=1:n
    for j=1:n
        if i<j %上三角
            I(i,j)=I(i,n+1);
        elseif i>j 
            I(i,j)=I(n+1,j);
        else
            I(i,j)=(I(i,n+1)+I(n+1,j))/2;
        end
    end
end
%area  8
for i=n+H+1:n+H+n
    for j=n+W+1:n+W+n
        if i-H<j-W %上三角
            I(i,j)=I(n+H,j);
        elseif i-H>j-W 
            I(i,j)=I(i,n+W);
        else
            I(i,j)=(I(i,n+W)+I(n+H,j))/2;
        end
    end
end
%area 6
for i=1:n
    for j=n+W+1:n+W+n
        if i+(j-W-n)<n
            I(i,j)=I(i,n+W);
        elseif i+(j-W-n)>n
            I(i,j)=I(n+1,j);
        else
            I(i,j)=(I(i,n+W)+I(n+1,j))/2;
        end
    end
end
%area 7
for i=n+H+1:n+H+n
    for j=1:n
        if j+(i-H-n)<n
            I(i,j)=I(n+H,j);
        elseif j+(i-H-n)>n
            I(i,j)=I(i,n+1);
        else
            I(i,j)=(I(i,n+1)+I(n+H,j))/2;
        end
    end
end
I=uint8(I);

3. Méthode de bord lisse:

G=rgb2gray(imread('tt.jpg'));
[m,n]=size(G);
G=imresize(G,[0.1*m,0.1*n]);
m=0.1*m;
n=0.1*n;
alpha=ceil(n/5);%随便设的宽度
Ap=zeros(m+2*alpha,n);%A’
Bp=zeros(m,n+2*alpha);
Cp=zeros(m+2*alpha,n+2*alpha);
A0=Ap;%A的初始值
B0=Bp;
C0=Cp;
H=fspecial('gaussian', [m,n], 1);
GH=imfilter(G,H);%对原图像平滑

lambda=3;
for i=1:alpha
    Ap(i,:)=GH(m-alpha-i,:);%根据公式得到A、B、C的边界
    Ap(m+alpha+i,:)=GH(i,:);
    Bp(:,i)=GH(:,n-alpha+i);
    Bp(:,n+alpha+i)=GH(:,i);
    Cp(i,:)=Bp(m-alpha+i,:);
    Cp(m+alpha+i,:)=Bp(i,:);
    Cp(:,i)=Ap(:,n-alpha+i);
    Cp(:,n+alpha+i)=Ap(:,i);
end

fun_A=@(A) sum(sum(lap(A).^2))+lambda*sum(sum(similar(A,Ap,alpha,m,n,'A').^2));%设置A的最小化函数
fun_B=@(A) sum(sum(lap(A).^2))+lambda*sum(sum(similar(A,Bp,alpha,m,n,'B').^2));
fun_C=@(A) sum(sum(lap(A).^2))+lambda*sum(sum(similar(A,Cp,alpha,m,n,'C').^2));
options = optimset('MaxFunEvals ',3e8,'MaxIter',7e5);%设置优化的参数
A=fminunc(fun_A,A0,options);%调用最小化优化函数得到最优值A
B=fminunc(fun_B,B0,options);
C=fminunc(fun_C,C0,options);
A=A(alpha+1:alpha+m,:);%裁剪得到图像部分
B=B(:,alpha+1:alpha+n);
C=C(alpha+1:alpha+m,alpha+1:alpha+n);
Z=[C,A,C;B,G,B;C,A,C];%拼接得到完整Tail
T=Z(m/2+1:5/2*m,n/2+1:5/2*n);%根据图示得到最终结果


function s=similar(A,Ap,alpha,m,n,str)
    if strcmp('A',str)
        s(1:alpha,:)=A(1:alpha,:)-Ap(1:alpha,:);
        s(alpha+1:2*alpha,:)=A(m+alpha+1:m+2*alpha,:)-Ap(m+alpha+1:m+2*alpha,:);
    elseif strcmp('B',str)
        s(:,1:alpha)=A(:,1:alpha)-Ap(:,1:alpha);
        s(:,alpha+1:2*alpha)=A(:,n+alpha+1:n+2*alpha)-Ap(:,n+alpha+1:n+2*alpha);
    else
        t=1;
        for i=1:m+2*alpha
            for j=1:n+2*alpha
                if i<=alpha || j<=alpha || i>=m+alpha+1 || j>=n+alpha+1
                    s(t)=A(i,j)-Ap(i,j);
                    t=t+1;
                end
            end
        end
    end
        
end

function d=lap(A)
    [m,n]=size(A);
    d=zeros(m,n);
    for i=2:m-1
        for j=2:n-1
            d(i,j)=A(i+1,j)+A(i-1,j)+A(i,j+1)+A(i,j-1)-4*A(i,j);
        end
    end
end
   

(PS: après y avoir réfléchi, il est plus rapide de définir la valeur d'initialisation telle que A0 à Ap, etc., puis de limiter la valeur de A: chaque valeur est comprise entre 0 et 255)     

  Afin d'accélérer le calcul, les dimensions horizontale et verticale de l'image sont réduites à 0,1 fois l'original. La fonction similaire est la partie du deuxième terme de la formule de minimisation , et lap est le gradient laplacien de A et la limite Parce que l'influence est relativement faible, je suis paresseux. Le gradient sur le bord même est directement mis à zéro. En raison de l' approximation de A, les paramètres de A, B et C sont égaux aux A ', B' et C 'correspondants. Ceci est également pratique pour calculer le gradient de la frontière A +. La fonction similaire est que pour A , B, C La plage de limites est différente, donc A, B et C doivent être considérés séparément. Comme je ne sais pas comment l'auteur optimise réellement cette équation de minimisation, j'utilise directement la fonction de minimisation fminunc de matlab. Les fonctions similaires incluent fmincon, fminbnd, etc., Applicable à différents scénarios et conditions, fminunc peut être utilisé pour résoudre la valeur minimale de fonctions multivariées sans contrainte. Les méthodes d'utilisation sont les suivantes:

        (De MatlabWorks), fun est une fonction qui doit être minimisée, et A après @ est défini comme une variable en utilisant fun = @ (A) f (A) dans le code, et f (A) représente une formule arbitraire, qui est la plus petite La variable, x0 est la valeur initiale du changement, x est le résultat de plusieurs optimisations, les options permettent de modifier certains des paramètres par défaut de la fonction de minimisation, tels que le nombre maximum d'itérations, la tolérance de terminaison, etc. ., la méthode spécifique peut être consultée par vous-même ou Référez-vous à la méthode dans le code pour contrôler le processus de minimisation de la fonction.

        Bien sûr, comme le calcul est relativement lent, je pense que l'auteur a utilisé d'autres méthodes au lieu de le minimiser directement comme moi. J'ai pensé à plusieurs idées pour résoudre ce problème de minimisation. Par exemple, pour A, les limites supérieure et inférieure peuvent être près de l'image interne. Par exemple, un côté d'une colonne est 65 et l'autre côté est 78. Si la hauteur d'image interne est 13, alors les valeurs de pixel d'image interne de cette colonne sont (65), 66,67 , ..., 76,77, (78). De cette façon, vous pouvez directement rendre l'autre partie de la frontière égale aux lignes de A ', ou effectuer un lissage pour réduire autant que possible le gradient pour les données à l'intérieur l'image. Par exemple, il y a une falaise au milieu de deux falaises de hauteur inégale. Le moyen le plus simple est de relier les deux falaises avec une échelle pour que le changement de hauteur, y compris l'échelle et la falaise, soit plus progressif, bien que cette méthode ne soit pas possible. pas la solution optimale, et il existe d'autres solutions, comme la construction d'une échelle le long de la pente d'une certaine falaise, ce qui n'est pas réalisé ici.

        La ligne droite brune sur la figure: la façon la plus simple de penser; la courbe brune, qui semble plus lisse, peut être la solution optimale; la courbe bleue: ce n'est pas la solution optimale à première vue. Courbes rouges des deux côtés: le gris change des bordures de part et d'autre de A, qui sont les "falaises" d'avant. Le T final et le code de la version de connexion linéaire sont les suivants:

(C prend la distance euclidienne dans deux directions)

G=rgb2gray(imread('tt.jpg'));
[m,n]=size(G);
alpha=ceil(n/5);
Ap=zeros(m+2*alpha,n);
Bp=zeros(m,n+2*alpha);
Cp=zeros(m+2*alpha,n+2*alpha);
H=fspecial('gaussian', [m,n], 1);
GH=imfilter(G,H);
lambda=3;
for i=1:alpha
    Ap(i,:)=GH(m-alpha-i,:);
    Ap(m+alpha+i,:)=GH(i,:);
    Bp(:,i)=GH(:,n-alpha+i);
    Bp(:,n+alpha+i)=GH(:,i);
end
for j=1:n
    s1=Ap(alpha,j);
    s2=Ap(m+alpha+1,j);
    k=(s1-s2)/(m+1);
    for i=alpha+1:m+alpha
        Ap(i,j)=s1-k*(i-alpha);
    end
end
for i=1:m
    s1=Bp(i,alpha);
    s2=Bp(i,n+alpha+1);
    k=(s1-s2)/(n+1);
    for j=alpha+1:n+alpha
        Bp(i,j)=s1-k*(j-alpha);
    end
end
for i=1:alpha
    Cp(i,:)=Bp(m-alpha+i,:);
    Cp(m+alpha+i,:)=Bp(i,:);
    Cp(:,i)=Ap(:,n-alpha+i);
    Cp(:,n+alpha+i)=Ap(:,i);
end
for i=alpha+1:m+alpha
    for j=alpha+1:n+alpha
        s1=Cp(alpha,j);
        s2=Cp(m+alpha+1,j);       
        e1=Cp(i,alpha);
        e2=Cp(i,n+alpha+1);
        ks=(s1-s2)/(m+1);
        ke=(e1-e2)/(n+1);
        Cp(i,j)=sqrt((s1-ks*(i-alpha))^2+ (e1-ke*(j-alpha))^2);
    end
end
A=Ap(alpha+1:alpha+m,:);
B=Bp(:,alpha+1:alpha+n);
C=Cp(alpha+1:alpha+m,alpha+1:alpha+n);
Z=[C,A,C;B,G,B;C,A,C];
T=Z(m/2+1:5/2*m,n/2+1:5/2*n);