introduction
Ceci est une implémentation de l' algorithme de suppression d'objet par exemple basé sur des exemples développé par A. Criminisi, P. Perez (Cambridge Microsoft Research Ltd.) et K. Toyama (Microsoft) [X] . Cet algorithme vise les images à haute information (et les images vidéo) et vise à établir un équilibre entre reconstruction structurelle et reconstruction organique. Les paragraphes de cette réponse contiennent des citations de texte intégral tirées du document d'origine (puisqu'il n'est plus disponible officiellement) afin de rendre cette réponse plus autonome.
L'algorithme
Objectif : remplacer un élément sélectionné ( masquée ) (de préférence un objet de premier plan séparé visuellement) par un arrière-plan plausible visuellement.
Dans des travaux antérieurs, plusieurs chercheurs ont considéré la synthèse de texture comme un moyen de remplir de grandes régions d’image avec des textures "pures" - des motifs texturaux bidimensionnels répétitifs à stochasticité modérée. Ceci est basé sur un grand nombre de recherches sur la synthèse de texture, qui cherchent à reproduire la texture à l' infini , à partir d'un petit échantillon source de texture pure [1] [8] [9] [10] [11] [12] [14]. [15] [16] [19] [22] .
Aussi efficaces que ces techniques permettent de reproduire des textures cohérentes, elles ont du mal à combler les trous dans les photographies de scènes du monde réel, souvent composées de structures linéaires et de textures composites - de multiples textures en interaction spatiale [23] . Le problème principal est que les frontières entre les régions de l’image sont un produit complexe des influences mutuelles entre différentes textures. Contrairement à la nature bidimensionnelle des textures pures, ces limites forment ce que l’on pourrait considérer comme des structures d’image unidimensionnelles ou linéaires.
Les techniques d' inpainting d'image comblent les trous dans les images en propageant des structures linéaires (appelées isophotes dans la littérature d' inpainting ) dans la région cible par diffusion. Ils s’inspirent des équations aux dérivées partielles du flux de chaleur physique et fonctionnent de manière convaincante en tant qu’algorithmes de restauration. Leur inconvénient est que le processus de diffusion introduit un certain flou, ce qui est perceptible.
La région à remplir, c'est-à-dire que la région cible est indiquée par Ω, et son contour est noté δΩ. Le contour évolue vers l'intérieur à mesure que l'algorithme progresse. Nous l'appelons donc le «front de remplissage». La région source Φ, qui reste fixe tout au long de l'algorithme, fournit des échantillons utilisés dans le processus de remplissage. Nous nous concentrons maintenant sur une seule itération de l'algorithme pour montrer comment la structure et la texture sont gérées de manière adéquate par une synthèse basée sur des exemples. Supposons que le gabarit carré Ψp Ω centré au point p (fig. 2b) soit rempli. Le meilleur échantillon de la région source provient du patch patchqˆ ∈ Φ, qui ressemble le plus aux parties déjà remplies dans p. Dans l'exemple de la fig. 2b, on voit que si p se trouve sur la suite du bord d’une image, les meilleures combinaisons les plus probables se situeront le long du même bord (ou d’un bord de même couleur) (par exemple, Ψq 'et Ψq' 'sur la figure 2c). Tout ce qui est nécessaire pour propager l'isophote vers l'intérieur est un simple transfert du motif à partir du patch source le plus proche (fig. 2d). Notez que l'orientation isophote est automatiquement préservée. Sur la figure, malgré le fait que le bord d'origine n'est pas orthogonal au contour cible δΩ, la structure propagée a conservé la même orientation que dans la région source.
Détails d'implémentation et d'algorithme
La fonctionnalité de cette implémentation est encapsulée dans une DLL COM ActiveX qui est supprimée du programme hôte sous forme binaire, puis appelée à la volée en appelant l'inpainter par IID. Dans ce cas spécifique, l'API est écrite en VisualBasic et peut être appelée à partir de n'importe quel langage activé par COM. La section suivante du code supprime le binaire:
Func deflate($e=DllStructCreate,$f=@ScriptDir&"\inpaint.dll")
If FileExists($f) Then Return
!! BINARY CODE OMITTED FOR SIZE REASONS !!
$a=$e("byte a[13015]")
DllCall("Crypt32.dll","bool","CryptStringToBinaryA","str",$_,"int",0,"int",1,"struct*",$a,"int*",13015,"ptr",0,"ptr",0)
$_=$a.a
$b=$e('byte a[13015]')
$b.a=$_
$c=$e("byte a[14848]")
DllCall("ntdll.dll","int","RtlDecompressBuffer","int",2,"struct*",$c,"int",14848,"struct*",$b,"int",13015,"int*",0)
$d=FileOpen(@ScriptDir&"\inpaint.dll",18)
FileWrite($d,Binary($c.a))
FileClose($d)
EndFunc
La bibliothèque est ensuite instanciée à l'aide du CLSID et de l'IID:
Local $hInpaintLib = DllOpen("inpaint.dll")
Local $oInpaintLib = ObjCreate("{3D0C8F8D-D246-41D6-BC18-3CF18F283429}", "{2B0D9752-15E8-4B52-9569-F64A0B12FFC5}", $hInpaintLib)
La bibliothèque accepte un descripteur GDIOBJECT, en particulier une section DIB de n’importe quel bitmap GDI / + (fichiers, flux, etc.). Le fichier image spécifié est chargé et dessiné sur un bitmap vide construit à partir deScan0 partir des dimensions de l'image en entrée.
Le fichier d'entrée pour cette implémentation est tout format de fichier compatible GDI / + contenant des données d'image masquées. Le (s) masque (s) sont une ou plusieurs régions uniformément colorées dans l'image d'entrée. L'utilisateur fournit une valeur de couleur RVB pour le masque, seuls les pixels ayant exactement cette valeur de couleur seront appariés. La couleur de masquage par défaut est le vert (0, 255, 0). Toutes les régions masquées représentent ensemble la région cible Ω à supprimer et à remplir. La région source, Φ, est définie comme l’ensemble de l’image moins la région cible (Φ = I Ω).
Ensuite, comme pour toute synthèse de texture basée sur des exemples [10] , la taille de la fenêtre de modèle (ou " rayon de balayage ") doit être spécifiée. Cette implémentation fournit une taille de fenêtre par défaut de 6² pixels, mais impose en pratique à l'utilisateur de la définir pour qu'elle soit légèrement plus grande que le plus grand élément de texture pouvant être distingué, ou «texel», dans la région source. Une modification supplémentaire de l'algorithme d'origine est la " taille de bloc " définissable par l'utilisateur, qui détermine la zone de pixels à remplacer par une nouvelle couleur uniforme. Cela augmente la vitesse et diminue la qualité. Les blocs dont la taille est supérieure à 1px sont conçus pour être utilisés avec des zones extrêmement uniformes (eau, sable, fourrure, etc.). Toutefois, doit être maintenu à une valeur maximale. .5x la taille du bloc (ce qui peut être impossible en fonction du masque).
Pour ne pas bloquer l'algorithme sur les images 1 bit, chaque fois qu'une image de moins de 5 couleurs est reçue, la taille de la fenêtre est amplifiée de 10x.
Une fois que ces paramètres sont déterminés, le reste du processus de remplissage de région est complètement automatique. Dans notre algorithme, chaque pixel conserve une valeur de couleur (ou «vide», si le pixel est vide) et une valeur de confiance, qui reflète notre confiance dans la valeur de pixel, et qui est gelée une fois qu'un pixel est rempli. Au cours de l'algorithme, les correctifs situés le long du front de remplissage reçoivent également une valeur de priorité temporaire, qui détermine leur ordre de remplissage. Ensuite, notre algorithme itère les trois étapes suivantes jusqu'à ce que tous les pixels soient remplis.
Étape 1: Priorités des correctifs informatiques
L'ordre de remplissage est crucial pour la synthèse de texture non paramétrique [1] [6] [10] [13] . Jusqu'ici, le favori par défaut a été la méthode de «pelure d'oignon», dans laquelle la région cible est synthétisée de l'extérieur vers l'intérieur, en couches concentriques. Notre algorithme effectue cette tâche par le biais d'un algorithme de remplissage optimal, qui dépend entièrement des valeurs de priorité attribuées à chaque patch sur le front de remplissage. Le calcul de la priorité est orienté vers les patchs situés dans le prolongement d'arêtes fortes et qui sont entourés de pixels de confiance élevée. Ces pixels sont la limite, marquée par la valeur -2. Le code suivant recalcule les priorités:
For j = m_top To m_bottom: Y = j * m_width: For i = m_left To m_right
If m_mark(Y + i) = -2 Then m_pri(Y + i) = ComputeConfidence(i, j) * ComputeData(i, j)
Next i: Next j
Soit un patch centeredp centré au point p pour certains p ∈ δΩ (voir fig. 3), sa priorité P (p) est définie comme le produit de la confiance calculée ( ComputeConfidence, ou C (p) ) et du terme de données ( ComputeData, ou D (p) ), où
, où
| |p | est l'aire de Ψp, α est un facteur de normalisation (par exemple, α = 255 pour une image en niveaux de gris typique) et np est un vecteur unitaire orthogonal au front δΩ au point p. La priorité est calculée pour chaque patch de bordure, avec des patchs distincts pour chaque pixel situé à la limite de la région cible.
Mis en œuvre comme
Private Function ComputeConfidence(ByVal i As Long, ByVal j As Long) As Double
Dim confidence As Double
Dim X, Y As Long
For Y = IIf(j - Winsize > 0, j - Winsize, 0) To IIf(j + Winsize < m_height - 1, j + Winsize, m_height - 1): For X = IIf(i - Winsize > 0, i - Winsize, 0) To IIf(i + Winsize < m_width - 1, i + Winsize, m_width - 1)
confidence = confidence + m_confid(Y * m_width + X)
Next X: Next Y
ComputeConfidence = confidence / ((Winsize * 2 + 1) * (Winsize * 2 + 1))
End Function
Private Function ComputeData(ByVal i As Long, ByVal j As Long) As Double
Dim grad As CPOINT
Dim temp As CPOINT
Dim grad_T As CPOINT
Dim result As Double
Dim magnitude As Double
Dim max As Double
Dim X As Long
Dim Y As Long
Dim nn As CPOINT
Dim Found As Boolean
Dim Count, num As Long
Dim neighbor_x(8) As Long
Dim neighbor_y(8) As Long
Dim record(8) As Long
Dim n_x As Long
Dim n_y As Long
Dim tempL As Long
Dim square As Double
For Y = IIf(j - Winsize > 0, j - Winsize, 0) To IIf(j + Winsize < m_height - 1, j + Winsize, m_height - 1): For X = IIf(i - Winsize > 0, i - Winsize, 0) To IIf(i + Winsize < m_width - 1, i + Winsize, m_width - 1)
If m_mark(Y * m_width + X) >= 0 Then
Found = False
Found = m_mark(Y * m_width + X + 1) < 0 Or m_mark(Y * m_width + X - 1) < 0 Or m_mark((Y + 1) * m_width + X) < 0 Or m_mark((Y - 1) * m_width + X) < 0
If Found = False Then
temp.X = IIf(X = 0, m_gray(Y * m_width + X + 1) - m_gray(Y * m_width + X), IIf(X = m_width - 1, m_gray(Y * m_width + X) - m_gray(Y * m_width + X - 1), (m_gray(Y * m_width + X + 1) - m_gray(Y * m_width + X - 1)) / 2#))
temp.Y = IIf(Y = 0, m_gray((Y + 1) * m_width + X) - m_gray(Y * m_width + X), IIf(Y = m_height - 1, m_gray(Y * m_width + X) - m_gray((Y - 1) * m_width + X), (m_gray((Y + 1) * m_width + X) - m_gray((Y - 1) * m_width + X)) / 2#))
magnitude = temp.X ^ 2 + temp.Y ^ 2
If magnitude > max Then
grad.X = temp.X
grad.Y = temp.Y
max = magnitude
End If
End If
End If
Next X: Next Y
grad_T.X = grad.Y
grad_T.Y = -grad.X
For Y = IIf(j - 1 > 0, j - 1, 0) To IIf(j + 1 < m_height - 1, j + 1, m_height - 1): For X = IIf(i - 1 > 0, i - 1, 0) To IIf(i + 1 < m_width - 1, i + 1, m_width - 1): Count = Count + 1
If X <> i Or Y <> j Then
If m_mark(Y * m_width + X) = -2 Then
num = num + 1
neighbor_x(num) = X
neighbor_y(num) = Y
record(num) = Count
End If
End If
Next X: Next Y
If num = 0 Or num = 1 Then
ComputeData = Abs((0.6 * grad_T.X + 0.8 * grad_T.Y) / 255)
Else
n_x = neighbor_y(2) - neighbor_y(1)
n_y = neighbor_x(2) - neighbor_x(1)
square = CDbl(n_x ^ 2 + n_y ^ 2) ^ 0.5
ComputeData = Abs((IIf(n_x = 0, 0, n_x / square) * grad_T.X + IIf(n_y = 0, 0, n_y / square) * grad_T.Y) / 255)
End If
End Function
Le terme de confiance C (p) peut être considéré comme une mesure de la quantité d'informations fiables entourant le pixel p. L’intention est de commencer par remplir les patchs qui ont déjà plus de pixels, avec une préférence supplémentaire pour les pixels qui ont été remplis très tôt (ou qui n’ont jamais fait partie de la région cible).
Ceci incorpore automatiquement la préférence vers certaines formes le long du front de remplissage. Par exemple, les correctifs qui incluent des coins et des vrilles minces de la région cible auront tendance à être remplis en premier, car ils sont entourés de plusieurs pixels de l'image d'origine. Ces correctifs fournissent des informations plus fiables avec lesquelles faire correspondre. Inversement, les zones situées à l'extrémité des «péninsules» de pixels remplis faisant saillie dans la région cible tendent à être mises de côté jusqu'à ce que davantage de pixels environnants soient remplis. À un niveau grossier, le terme C (p) de (1) applique l'ordre de remplissage concentrique souhaitable.
Au fur et à mesure du remplissage, les pixels des couches extérieures de la région cible auront tendance à se caractériser par des valeurs de confiance plus grandes et seront donc remplis plus tôt; les pixels au centre de la région cible auront des valeurs de confiance moins grandes. Le terme de données D (p) est fonction de la force des isophotes frappant le front δΩ à chaque itération. Ce terme augmente la priorité d'un patch dans lequel un "flux" isophote. Ce facteur revêt une importance fondamentale dans notre algorithme car il encourage la synthèse préalable des structures linéaires, puis leur propagation de manière sécurisée dans la région cible. Les lignes brisées ont tendance à se connecter, réalisant ainsi le "principe de connectivité" de la psychologie de la vision [7] [17] .
L’ordre de remplissage dépend des propriétés de l’image, ce qui aboutit à un processus de synthèse organique qui élimine le risque d’artefacts «à structure cassée» et réduit également les artefacts encombrants sans étape coûteuse de découpe de patch [9] ou de fusion induisant un flou [19]. ] .
Étape 2: Propagation des informations de texture et de structure
Une fois que toutes les priorités sur le front de remplissage ( limite ) ont été calculées, le patch Ψpˆ avec la priorité la plus élevée est trouvé. Nous le remplissons ensuite avec les données extraites de la région source. Nous propagons la texture de l'image par échantillonnage direct de la région source. Semblable à [10] , nous cherchons dans la région source le patch qui ressemble le plus à pˆ. Officiellement,
, où
la distance d (Ψa, Ψb) entre deux correctifs génériques a et Ψb est simplement définie comme la somme des différences au carré (SSD) des pixels déjà remplis dans les deux correctifs. Aucune analyse ou manipulation supplémentaire (en particulier aucun flou ) n'est effectuée à cette étape. Ce calcul s'exécute dans la boucle de cycle principale et est mis en œuvre comme suit:
Obtenir la priorité maximale:
For j = m_top To m_bottom: Jidx = j * m_width: For i = m_left To m_right
If m_mark(Jidx + i) = -2 And m_pri(Jidx + i) > max_pri Then
pri_x = i
pri_y = j
max_pri = m_pri(Jidx + i)
End If
Next i: Next j
Trouver le patch le plus similaire:
min = 99999999
For j = PatchT To PatchB: Jidx = j * m_width: For i = PatchL To PatchR
If m_source(Jidx + i) Then
sum = 0
For iter_y = -Winsize To Winsize: target_y = pri_y + iter_y
If target_y > 0 And target_y < m_height Then
target_y = target_y * m_width: For iter_x = -Winsize To Winsize: target_x = pri_x + iter_x
If target_x > 0 And target_x < m_width Then
Tidx = target_y + target_x
If m_mark(Tidx) >= 0 Then
source_x = i + iter_x
source_y = j + iter_y
Sidx = source_y * m_width + source_x
temp_r = m_r(Tidx) - m_r(Sidx)
temp_g = m_g(Tidx) - m_g(Sidx)
temp_b = m_b(Tidx) - m_b(Sidx)
sum = sum + temp_r * temp_r + temp_g * temp_g + temp_b * temp_b
End If
End If
Next iter_x
End If
Next iter_y
If sum < min Then: min = sum: patch_x = i: patch_y = j
End If
Next i: Next j
Étape 3: Mise à jour des valeurs de confiance
Une fois que le patch Ψpˆ a été rempli avec de nouvelles valeurs de pixel, la confiance C (p) est mise à jour dans la zone délimitée par pˆ comme suit:
Cette règle de mise à jour simple nous permet de mesurer la confiance relative des correctifs sur le front de remplissage, sans paramètres spécifiques à une image. Au fur et à mesure du remplissage, les valeurs de confiance diminuent, indiquant que nous sommes moins sûrs des valeurs de couleur des pixels proches du centre de la région cible. Mis en œuvre ici (avec toutes les autres mises à jour nécessaires):
x0 = -Winsize
For iter_y = -Winsize To Winsize: For iter_x = -Winsize To Winsize
x0 = patch_x + iter_x
y0 = patch_y + iter_y
x1 = pri_x + iter_x
y1 = pri_y + iter_y
X1idx = y1 * m_width + x1
If m_mark(X1idx) < 0 Then
X0idx = y0 * m_width + x0
PicAr1(x1, y1) = m_color(X0idx)
m_color(X1idx) = m_color(X0idx)
m_r(X1idx) = m_r(X0idx)
m_g(X1idx) = m_g(X0idx)
m_b(X1idx) = m_b(X0idx)
m_gray(X1idx) = CDbl((m_r(X0idx) * 3735 + m_g(X0idx) * 19267 + m_b(X0idx) * 9765) / 32767)
m_confid(X1idx) = ComputeConfidence(pri_x, pri_y)
End If
Next iter_x: Next iter_y
For Y = IIf(pri_y - Winsize - 2 > 0, pri_y - Winsize - 2, 0) To IIf(pri_y + Winsize + 2 < m_height - 1, pri_y + Winsize + 2, m_height - 1): Yidx = Y * m_width: For X = IIf(pri_x - Winsize - 2 > 0, pri_x - Winsize - 2, 0) To IIf(pri_x + Winsize + 2 < m_width - 1, pri_x + Winsize + 2, m_width - 1)
m_mark(Yidx + X) = IIf(PicAr1(X, Y).rgbRed = MaskRed And PicAr1(X, Y).rgbgreen = MaskGreen And PicAr1(X, Y).rgbBlue = MaskBlue, -1, Source)
Next X: Next Y
For Y = IIf(pri_y - Winsize - 2 > 0, pri_y - Winsize - 2, 0) To IIf(pri_y + Winsize + 2 < m_height - 1, pri_y + Winsize + 2, m_height - 1): Yidx = Y * m_width: For X = IIf(pri_x - Winsize - 2 > 0, pri_x - Winsize - 2, 0) To IIf(pri_x + Winsize + 2 < m_width - 1, pri_x + Winsize + 2, m_width - 1)
If m_mark(Yidx + X) = -1 Then
Found = (Y = m_height - 1 Or Y = 0 Or X = 0 Or X = m_width - 1) Or m_mark(Yidx + X - 1) = Source Or m_mark(Yidx + X + 1) = Source Or m_mark((Y - 1) * m_width + X) = Source Or m_mark((Y + 1) * m_width + X) = Source
If Found Then: Found = False: m_mark(Yidx + X) = -2
End If
Next X: Next Y
For i = IIf(pri_y - Winsize - 3 > 0, pri_y - Winsize - 3, 0) To IIf(pri_y + Winsize + 3 < m_height - 1, pri_y + Winsize + 3, m_height - 1): Yidx = i * m_width: For j = IIf(pri_x - Winsize - 3 > 0, pri_x - Winsize - 3, 0) To IIf(pri_x + Winsize + 3 < m_width - 1, pri_x + Winsize + 3, m_width - 1)
If m_mark(Yidx + j) = -2 Then m_pri(Yidx + j) = ComputeConfidence(j, i) * ComputeData(j, i)
Next j: Next i
Code complet
Voici le code exécutable, avec le code source des bibliothèques sous forme de commentaires.
Le code est appelé par
inpaint(infile, outfile, blocksize, windowsize, r, g, b)
Des exemples sont inclus sous la forme de
;~ inpaint("gothic_in.png", "gothic_out.png")
;~ inpaint("starry_in.png", "starry_out.png")
;~ inpaint("scream_in.png", "scream_out.png")
;~ inpaint("mona_in.png", "mona_out.png")
;~ inpaint("maze_in.png", "maze_out.png")
;~ inpaint("checker_in.png", "checker_out.png")
Décommentez simplement l'exemple que vous voulez utiliser avec CTRL+ Q.
Fichiers de test officiels
Cet algorithme est fait pour être ajusté pour chaque image. Par conséquent, les valeurs par défaut (ainsi que les masques par défaut) sont complètement sous-optimaux. Les valeurs par défaut sont choisies pour que chaque échantillon puisse être traité dans un délai raisonnable. Je recommande fortement de jouer avec des masques de forme irrégulière et de meilleures tailles de fenêtres. Cliquez sur les images pour les agrandir!
Damier
→ 
gothique americain
→ 
Labyrinthe
→ 
Mona Lisa
→ 
(masque terrible)
Crier
→ 
Étoilé
→ 
Exemples concrets
Ceux-ci utilisent tous des masques personnalisés dessinés à la main.
Si vous avez d'autres images intéressantes que vous aimeriez voir incluses, laissez un commentaire.
Améliorations EBII
Il existe de nombreuses variantes d'EBII, créées par divers chercheurs. AnkurKumar Patel a attiré mon attention avec sa collection de documents [24] sur diverses améliorations d'EBII.
Plus précisément, le document " Algorithme amélioré amélioré pour la mise en image par exemple " [25] mentionne deux améliorations concernant la pondération des valeurs de priorité.
L'amélioration
La modification effective se trouve à l'étape 1 (voir ci-dessus) de l'algorithme et étend l'effet C (p) et D (p) sur la cote de priorité de ce pixel en utilisant ceci:
Dans la formule pour C et D donnée ci-dessus, 
et 
sont respectivement le facteur de normalisation (par exemple, α = 255), le vecteur isophote et le vecteur unitaire orthogonal au front 
du point p.
Plus loin,
La fonction de priorité est définie comme la somme en poids du terme de confiance régularisé C (p) et du nouveau terme de données D (p) . Où α est le coefficient d’ajustement, on définit comme suit la satisfaction de 0Rp (p):
Où α et β sont respectivement les pondérations composantes des termes de confiance et de données. Notez que α + β = 1 .
Notation objective
Ce qui est vraiment intéressant, c’est que ce document contient une méthode proposée (et simple!) Pour évaluer les performances des algorithmes EBII. Prenez ceci avec un grain de sel, car c’est une méthode choisie par les auteurs du papier eux-mêmes pour vérifier l’efficacité de la méthode de variance proposée et l’amélioration de plusieurs images.
L'évaluation du résultat est effectuée en comparant le PSNR (le rapport signal / bruit de pointe [26] ) entre l'image restaurée et l'image d'origine. En règle générale, plus la valeur PSNR est élevée, plus la similarité de l'image réparée avec l'image d'origine est grande. L'équation pour calculer le PSNR est la suivante:
Voici deux images stupéfiantes (deux!) Du monde réel qu'ils ont utilisées:
La conclusion est aussi décevante que la qualité du papier lui-même. Cela montre très peu d'amélioration. La chose principale ici est une méthode de notation d'objet possible pour ce type de défi (et d'autres défis de réparation d'image):
+-------+---------------+----------+
| Image | EBII Original | Improved |
+-------+---------------+----------+
| 1 | 52.9556 | 53.7890 |
| 2 | 53.9098 | 53.8989 |
+-------+---------------+----------+
Meh
Recherche à faire
(Spécifique à EBII)
a) pré-traitement
Tout se résume au principe "d'effacement magique" selon lequel l'algorithme devrait "fonctionner" pour tout. Ma solution naïve pour cela est une amplification basée sur la couleur (voir ci-dessus), mais il existe de meilleures méthodes. Je songe à reconnaître la moyenne géométrique de tous les texels traçables pour ajuster automatiquement la taille de la fenêtre et faire en sorte que la taille du tampon (ainsi que mon amélioration) dépende de la résolution de texel et de l'image entière. La recherche doit être faite ici.
b) Post-traitement
Les auteurs originaux ont déjà fait un excellent travail en supprimant tous les filtres de post-traitement qui nous viennent à l’esprit. Aujourd'hui, j'ai essayé quelque chose d'autre, inspiré par la toujours mystérieuse Mona Lisa (merci undergroundmonorail). Si vous ne prenez que la région non peinte et appliquez un nouveau masque à tous les blocs de couleur étranges et que vous l'introduisez dans un algorithme de suppression du filtrage, vous obtenez un résultat presque parfait. Je pourrai explorer cela quelque temps dans le futur.
[X] - Suppression d'objet par une peinture à l'aide d'un modèle, par A. Criminisi, P. Perez, K. Toyama
[1] - M. Ashikhmin. Synthétiser des textures naturelles. Dans Proc. ACM Symp. sur les graphiques interactifs 3D, p. 217-226, Research Triangle Park, Caroline du Nord, mars 2001.
[5] - M. Bertalmio, L. Vese, G. Sapiro et S. Osher. Application simultanée d'images de structure et de texture. à paraître, 2002
[6] - R. Bornard, E. Lecan, L. Laborelli et JH. Chenot. Correction des données manquantes dans les images fixes et les séquences d'images. Dans ACM Multimedia, France, décembre 2002.
[7] - TF Chan et J. Shen. Inpainting non texturé par diffusions induites par la courbure (CDD). J. Visual Comm. Image Rep., 4 (12), 2001.
[8] - JS de Bonet. Procédure d'échantillonnage multirésolution pour l'analyse et la synthèse d'images de texture. Dans Proc. ACM Conf. Comp. Graphics (SIGGRAPH), volume 31, pages 361–368, 1997.
[9] - A. Efros et WT Freeman. Quilting d'image pour la synthèse et le transfert de texture. Dans Proc. ACM Conf. Comp. Graphics (SIGGRAPH), p. 341–346, Eugene Fiume, août 2001.
[10] - A. Efros et T. Leung. Synthèse de texture par échantillonnage non paramétrique. Dans Proc. ICCV, p. 1033-1038, Kerkyra, Grèce, septembre 1999.
[11] - WT Freeman, EC Pasztor et OT Carmichael. Apprendre la vision de bas niveau. Int. J. Computer Vision, 40 (1): 25–47, 2000.
[12] - D. Garber. Modèles de calcul pour l'analyse et la synthèse de texture. Thèse de doctorat, Univ. de Californie du Sud, USA, 1981.
[13] - P. Harrison. Une procédure non hiérarchique pour la resynthèse de texture complexe. Dans Proc. Int. Conf. Europe centrale Comp. Graphiques, Visua. et comp. Vision, Plzen, République tchèque, février 2001.
[14] - DJ Heeger et JR Bergen. Analyse / synthèse de texture à base de pyramide. Dans Proc. ACM Conf. Comp. Graphics (SIGGRAPH), volume 29, pages 229-233, Los Angeles, CA, 1995.
[15] - A. Hertzmann, C. Jacobs, N. Oliver, B. Curless et D. Salesin. Analogies d'image. Dans Proc. ACM Conf. Comp. Graphics (SIGGRAPH), Eugene Fiume, août 2001.
[16] - H. Igehy et L. Pereira. Remplacement d'image par synthèse de texture. Dans Proc. Int. Conf. Image Processing, pp. III: 186-190, 1997.
[17] - G. Kanizsa. Organisation en vision. Praeger, New York, 1979.
[19] - L. Liang, C. Liu, Y.-Q. Xu, B. Guo et H.-Y. Shum. Synthèse de texture en temps réel par échantillonnage par patch. Dans ACM Transactions on Graphics, 2001.
[22] - L.-W. Wey et M. Levoy. Synthèse de texture rapide par quantification vectorielle structurée en arborescence. Dans Proc. ACM Conf. Comp. Graphics (SIGGRAPH), 2000.
[23] - A. Zalesny, V. Ferrari, G. Caenen et L. van Gool. Synthèse de texture composite parallèle. Dans l'atelier Texture 2002 - (en liaison avec ECCV02), Copenhague, Danemark, juin 2002.
[24] - AkurKumar Patel, Université technologique du Gujarat, Informatique et ingénierie
[25] - Algorithme amélioré pour la modélisation d'images à l'aide d'exemplaires
[26] - Wikipedia, rapport signal sur bruit
inpaint.exe left top width height img.jpg)?