Introdução
Esta é uma implementação do algoritmo Remoção de Objetos por Inpainting Baseada em Exemplos desenvolvido por A. Criminisi, P. Perez (Cambridge Microsoft Research Ltd.) e K. Toyama (Microsoft) [X] . Esse algoritmo é direcionado a imagens de alta informação (e quadros de vídeo) e visa ser o equilíbrio entre reconstrução estrutural e reconstrução orgânica. Os parágrafos desta resposta contêm citações de texto completo do artigo original (uma vez que não está mais disponível oficialmente) para tornar essa resposta mais independente.
O Algoritmo
Objetivo : Substituir uma área selecionada ( mascarada ) (de preferência um objeto em primeiro plano visualmente separado) por fundos visualmente plausíveis.
Em trabalhos anteriores, vários pesquisadores consideraram a síntese de textura como uma maneira de preencher grandes regiões de imagem com texturas "puras" - padrões repetitivos de textura bidimensional com estocástica moderada. Isso se baseia em um amplo corpo de pesquisa de síntese de textura, que busca replicar a textura ad infinitum , dada uma pequena amostra de fonte de textura pura [1] [8] [9] [10] [11] [12] [14] [15] [16] [19] [22] .
Por mais eficazes que sejam essas técnicas na replicação de textura consistente, elas têm dificuldade em preencher buracos nas fotografias de cenas do mundo real, que geralmente consistem em estruturas lineares e texturas compostas - várias texturas interagindo espacialmente [23] . O principal problema é que os limites entre as regiões da imagem são um produto complexo de influências mútuas entre diferentes texturas. Em contraste com a natureza bidimensional das texturas puras, esses limites formam o que pode ser considerado mais estruturas de imagem unidimensionais ou lineares.
Imagem inpainting técnicas encher furos em imagens por propagação de estruturas lineares (chamados isofotas na inpainting literatura) para a região alvo através de difusão. Eles são inspirados pelas equações diferenciais parciais do fluxo de calor físico e funcionam de maneira convincente como algoritmos de restauração. Sua desvantagem é que o processo de difusão introduz um pouco de desfoque, o que é perceptível.
A região a ser preenchida, ou seja, a região alvo é indicada por Ω e seu contorno é denotado δΩ. O contorno evolui para dentro à medida que o algoritmo progride, e também o chamamos de "frente de preenchimento". A região de origem, Φ, que permanece fixa em todo o algoritmo, fornece amostras usadas no processo de preenchimento. Agora, focamos em uma única iteração do algoritmo para mostrar como a estrutura e a textura são tratadas adequadamente por síntese baseada em exemplos. Suponha que o modelo quadrado Ψp ∈ Ω centrado no ponto p (fig. 2b) seja preenchido. A amostra de melhor correspondência da região de origem vem do patch Ψqˆ ∈ Φ, que é mais semelhante às partes que já foram preenchidas Ψp. No exemplo da fig. 2b, vemos que se liesp está na continuação de uma borda da imagem, as melhores correspondências provavelmente ocorrerão na mesma borda (ou de uma cor similar) (por exemplo, Ψq 'e Ψq' 'na figura 2c). Tudo o que é necessário para propagar a isofote para dentro é uma simples transferência do padrão do patch de melhor correspondência de origem (fig. 2d). Observe que a orientação isophote é preservada automaticamente. Na figura, apesar de a aresta original não ser ortogonal ao contorno alvo δΩ, a estrutura propagada manteve a mesma orientação da região de origem.
Detalhes de implementação e algoritmo
A funcionalidade desta implementação é encapsulada em uma DLL COM do ActiveX, que é descartada do programa host como um binário e, em seguida, invocada rapidamente, chamando o inpainter pelo IID. Nesse caso específico, a API é escrita em VisualBasic e pode ser chamada de qualquer idioma habilitado para COM. A seção a seguir do código descarta o binário:
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
A biblioteca é instanciada posteriormente usando o CLSID e o IID:
Local $hInpaintLib = DllOpen("inpaint.dll")
Local $oInpaintLib = ObjCreate("{3D0C8F8D-D246-41D6-BC18-3CF18F283429}", "{2B0D9752-15E8-4B52-9569-F64A0B12FFC5}", $hInpaintLib)
A biblioteca aceita um identificador GDIOBJECT, especificamente uma DIBSection de qualquer bitmap GDI / + (arquivos, fluxos etc.). O arquivo de imagem especificado é carregado e desenhado em um bitmap vazio construído a partir Scan0das dimensões da imagem de entrada.
O arquivo de entrada para esta implementação é qualquer formato de arquivo compatível com GDI / + que contém dados de imagem mascarada. As máscaras são uma ou mais regiões uniformemente coloridas na imagem de entrada. O usuário fornece um valor de cor RGB para a máscara, apenas pixels com exatamente esse valor de cor serão correspondidos. A cor de máscara padrão é verde (0, 255, 0). Todas as regiões mascaradas juntas representam a região de destino, Ω, a ser removida e preenchida. A região de origem, is, é definida como a imagem inteira menos a região de destino (Φ = I-Ω).
Em seguida, como em toda síntese de textura baseada em exemplos [10] , o tamanho da janela do modelo Ψ (também conhecido como " raio de varredura ") deve ser especificado. Essa implementação fornece um tamanho de janela padrão de 6² pixels, mas, na prática, exige que o usuário defina um pouco maior que o maior elemento de textura distinguível, ou "texel", na região de origem. Uma modificação adicional no algoritmo original é o " tamanho do bloco " definível pelo usuário, que determina a área de pixels a serem substituídos por uma nova cor uniforme. Isso aumenta a velocidade e diminui a qualidade. Os tamanhos de bloco maiores que 1px devem ser usados em áreas extremamente uniformes (água, areia, pele etc.), no entanto, Ψ deve ser mantido no máximo. .5x o tamanho do bloco (que pode ser impossível dependendo da máscara).
Para não travar o algoritmo em imagens de 1 bits, toda vez que uma imagem com menos de 5 cores é recebida, o tamanho da janela é amplificado em 10x.
Uma vez determinados esses parâmetros, o restante do processo de preenchimento da região é completamente automático. Em nosso algoritmo, cada pixel mantém um valor de cor (ou "vazio", se o pixel não estiver preenchido) e um valor de confiança, que reflete nossa confiança no valor do pixel e é congelado quando o pixel é preenchido. Durante o curso do algoritmo, os patches ao longo da frente de preenchimento também recebem um valor de prioridade temporário, que determina a ordem em que eles são preenchidos. Em seguida, nosso algoritmo itera as três etapas a seguir até que todos os pixels tenham sido preenchidos.
Etapa 1: Computando as prioridades do patch
A ordem de preenchimento é crucial para a síntese não-paramétrica de texturas [1] [6] [10] [13] . Até agora, o favorito padrão tem sido o método "casca de cebola", onde a região de destino é sintetizada de fora para dentro, em camadas concêntricas. Nosso algoritmo executa essa tarefa por meio do melhor algoritmo de preenchimento que depende inteiramente dos valores de prioridade atribuídos a cada amostra na frente de preenchimento. O cálculo da prioridade é enviesado em direção àquelas amostras que estão na continuação de arestas fortes e cercadas por pixels de alta confiança; esses pixels são o limite, marcado pelo valor -2. O código a seguir recalcula as prioridades:
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
Dado um patch Ψp centrado no ponto p para alguns p ∈ δΩ (ver fig. 3), sua prioridade P (p) é definida como o produto da confiança calculada ( ComputeConfidenceou C (p) ) e o termo de dados ( ComputeData, ou D (p) ), onde
, Onde
| Ψp | é a área de Ψp, α é um fator de normalização (por exemplo, α = 255 para uma imagem típica de nível de cinza) e np é um vetor unitário ortogonal à frente δΩ no ponto p. A prioridade é calculada para cada patch de borda, com patches distintos para cada pixel no limite da região de destino.
Implementado como
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
O termo de confiança C (p) pode ser pensado como uma medida da quantidade de informações confiáveis em torno do pixel p. A intenção é preencher primeiro os patches que já tenham mais pixels preenchidos, com preferência adicional aos pixels que foram preenchidos desde o início (ou que nunca fizeram parte da região de destino).
Isso incorpora automaticamente a preferência para determinadas formas ao longo da frente de preenchimento. Por exemplo, os patches que incluem cantos e gavinhas finas da região de destino tendem a ser preenchidos primeiro, pois são cercados por mais pixels da imagem original. Esses patches fornecem informações mais confiáveis com as quais comparar. Por outro lado, as manchas na ponta das “penínsulas” de pixels preenchidos que se projetam na região de destino tendem a ser deixadas de lado até que mais pixels adjacentes sejam preenchidos. Em um nível aproximado, o termo C (p) de (1) aproximadamente impõe a ordem de preenchimento concêntrico desejável.
À medida que o preenchimento prossegue, os pixels nas camadas externas da região de destino tendem a ser caracterizados por maiores valores de confiança e, portanto, são preenchidos mais cedo; pixels no centro da região de destino terão valores de confiança menores. O termo de dados D (p) é uma função da força das isofotes atingindo a frente δΩ a cada iteração. Esse termo aumenta a prioridade de um patch para o qual uma isofote "flui". Esse fator é de fundamental importância em nosso algoritmo, pois estimula estruturas lineares a serem sintetizadas primeiro e, portanto, propagadas com segurança na região de destino. Linhas quebradas tendem a se conectar, realizando o "Princípio da Conectividade" da psicologia da visão [7] [17] .
A ordem de preenchimento depende das propriedades da imagem, resultando em um processo de síntese orgânica que elimina o risco de artefatos de “estrutura quebrada” e também reduz artefatos em blocos sem uma etapa cara de corte de adesivo [9] ou uma etapa de mistura indutora de desfoque [19 ] .
Etapa 2: Propagando informações de textura e estrutura
Depois de calculadas todas as prioridades na frente de preenchimento ( limite ), o patch Ψpˆ com maior prioridade é encontrado. Em seguida, preenchemos com dados extraídos da região de origem Φ. Propagamos a textura da imagem por amostragem direta da região de origem. Semelhante a [10] , procuramos na região de origem o patch mais semelhante ao topˆ. Formalmente,
, Onde
a distância d (Ψa, Ψb) entre dois patches genéricos anda e Ψb é simplesmente definida como a soma das diferenças quadráticas (SSD) dos pixels já preenchidos nos dois patches. Nenhuma análise ou manipulação adicional ( especialmente sem desfoque ) é feita nesta etapa. Este cálculo é executado no ciclo principal do ciclo e é implementado da seguinte maneira:
Obtendo a prioridade máxima:
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
Encontrando o patch mais semelhante:
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
Etapa 3: Atualizando Valores de Confiança
Após o patch Ψpˆ ter sido preenchido com novos valores de pixel, a confiança C (p) é atualizada na área delimitada por ˆpˆ da seguinte maneira:
Essa regra de atualização simples permite medir a confiança relativa dos patches na frente de preenchimento, sem parâmetros específicos da imagem. À medida que o preenchimento prossegue, os valores de confiança diminuem, indicando que temos menos certeza dos valores de cores dos pixels próximos ao centro da região de destino. Implementado aqui (junto com todas as outras atualizações necessárias):
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
Código completo
Aqui está o código executável, completo com o código fonte das bibliotecas como comentários.
O código é chamado por
inpaint(infile, outfile, blocksize, windowsize, r, g, b)
Exemplos são incluídos na forma 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")
apenas remova o comentário do exemplo que você deseja executar usando CTRL+ Q.
Arquivos oficiais de teste
Este algoritmo é feito para ser ajustado para cada imagem. Portanto, os valores padrão (e também as máscaras padrão) são completamente abaixo do ideal. Os valores padrão são escolhidos para que cada amostra possa ser processada em um período de tempo razoável. Eu recomendo jogar com máscaras de forma irregular e melhores tamanhos de janelas. Clique nas imagens para aumentá-las!
Tabuleiro de damas
→ 
gótico americano
→ 
Labirinto
→ 
Monalisa
→ 
(máscara terrível)
Grito
→ 
Estrelado
→ 
Exemplos do mundo real
Todos eles usam máscaras personalizadas desenhadas à mão.
Se você tiver outras imagens interessantes que gostaria de ver incluídas, deixe um comentário.
Melhorias no EBII
Existem várias variantes do EBII por aí, criadas por vários pesquisadores. AnkurKumar Patel chamou minha atenção com sua coleção de artigos [24] sobre várias melhorias no EBII.
Especificamente, o artigo " Algoritmo Robusto Aprimorado para Pintura de Imagem Baseada em Exemplos " [25] menciona duas melhorias na pesagem dos valores de prioridade.
A melhoria
A modificação efetiva está na Etapa 1 (veja acima) do algoritmo e estende o efeito C (p) e D (p) na classificação de prioridade para esse pixel usando o seguinte:
Na fórmula para C e D dada acima, 
e 
são respectivamente o fator de normalização (por exemplo, α = 255), o vetor isofoto e o vetor unitário ortogonal à frente 
no ponto p.
Mais distante,
A função de prioridade é definida como a soma de peso do termo de confiança regularizado C (p) e o novo termo de dados D (p) . Onde α é o coeficiente de ajuste, é definido o seguinte 0Rp (p):
Onde α e β são respectivamente os pesos dos componentes da confiança e os termos dos dados. Note que α + β = 1 .
Pontuação objetiva
O que é realmente interessante é que este artigo contém um método proposto (e simples!) Para pontuar o desempenho se houver algoritmos EBII. Leve isso com um pouco de sal, pois esse é um método escolhido pelos próprios autores do artigo para verificar a eficácia da abordagem de variância proposta e a melhoria em várias imagens.
A avaliação do resultado é realizada através da comparação do PSNR (relação sinal de pico / ruído [26] ) entre a imagem restaurada e a imagem original. Geralmente, quanto maior o valor do PSNR, maior a semelhança da imagem reparada com a original. A equação para calcular o PSNR é a seguinte:
Estas são as impressionantes 2 (duas!) Imagens de teste do mundo real que eles usaram:
A conclusão é tão decepcionante quanto a qualidade do papel em si. Isso mostra muito pouca melhoria. O principal aqui é um possível método de pontuação de objetos para esse tipo de desafio (e outros desafios de reparo de imagem):
+-------+---------------+----------+
| Image | EBII Original | Improved |
+-------+---------------+----------+
| 1 | 52.9556 | 53.7890 |
| 2 | 53.9098 | 53.8989 |
+-------+---------------+----------+
Meh.
Pesquisa a ser realizada
(Específico para EBII)
a) Pré-processamento
Tudo se resume ao princípio "Apagamento mágico" de que o algoritmo deve "apenas funcionar" para tudo. Minha solução ingênua para isso é uma amplificação baseada em cores (veja acima), mas existem maneiras melhores. Estou pensando em reconhecer a média geométrica de todos os texels rastreáveis para ajustar automaticamente o tamanho da janela e tornar o tamanho do carimbo (também minha melhoria) dependente da resolução de texel e de imagem inteira. A pesquisa tem que ser feita aqui.
b) Pós-processamento
Os autores originais já fizeram um ótimo trabalho ao desmembrar todos os filtros de pós-processamento que vêm à mente. Hoje, tentei outra coisa, inspirada na sempre misteriosa Mona Lisa (graças ao undergroundmonorail). Se você pegar apenas a região não pintada e aplicar uma nova máscara a todos os estranhos blocos de cores e inseri-los em um algoritmo de despeckling, ficará com um resultado quase perfeito. Eu posso explorar isso em algum momento no futuro.
[X] - Remoção de Objetos por Pintura com Base em Exemplos por A. Criminisi, P. Perez, K. Toyama
[1] - M. Ashikhmin. Sintetizando texturas naturais. Em Proc. ACM Symp. em Interactive 3D Graphics, pp. 217–226, Research Triangle Park, NC, março de 2001.
[5] - M. Bertalmio, L. Vese, G. Sapiro e S. Osher. Pintura simultânea de estrutura e imagem de textura. para aparecer, 2002
[6] - R. Bornard, E. Lecan, L. Laborelli e JH. Chenot. Correção de dados ausentes em imagens estáticas e seqüências de imagens. Em ACM Multimedia, França, dezembro de 2002.
[7] - TF Chan e J. Shen. Pintura sem textura por difusões orientadas por curvatura (CDD). J. Visual Comm. Representante da Imagem, 4 (12), 2001.
[8] - JS de Bonet. Procedimento de amostragem multirresolução para análise e síntese de imagens de textura. Em Proc. ACM Conf. Comp. Graphics (SIGGRAPH), volume 31, pp. 361–368, 1997.
[9] - A. Efros e WT Freeman. Acolchoado de imagens para síntese e transferência de texturas. Em Proc. ACM Conf. Comp. Graphics (SIGGRAPH), pp. 341-346, Eugene Fiume, agosto de 2001.
[10] - A. Efros e T. Leung. Síntese de textura por amostragem não paramétrica. Em Proc. ICCV, pp. 1033-1038, Kerkyra, Grécia, setembro de 1999.
[11] - WT Freeman, EC Pasztor e OT Carmichael. Aprendendo visão de baixo nível. Int. J. Computer Vision, 40 (1): 25-47, 2000.
[12] - D. Garber. Modelos computacionais para análise e síntese de texturas. Tese de doutorado, Univ. do sul da Califórnia, EUA, 1981.
[13] - P. Harrison. Um procedimento não hierárquico para re-síntese de textura complexa. Em Proc. Int. Conf. Europa Central Comp. Gráficos, Visua. e Comp. Vision, Plzen, República Tcheca, fevereiro de 2001.
[14] - DJ Heeger e JR Bergen. Análise / síntese de textura baseada em pirâmide. Em Proc. ACM Conf. Comp. Graphics (SIGGRAPH), volume 29, pp. 229-233, Los Angeles, CA, 1995.
[15] - A. Hertzmann, C. Jacobs, N. Oliver, B. Curless e D. Salesin. Analogias de imagem. Em Proc. ACM Conf. Comp. Graphics (SIGGRAPH), Eugene Fiume, agosto de 2001.
[16] - H. Igehy e L. Pereira. Substituição de imagem através da síntese de textura. Em Proc. Int. Conf. Image Processing, pp. III: 186–190, 1997.
[17] - G. Kanizsa. Organização em visão. Praeger, Nova Iorque, 1979.
[19] - L. Liang, C. Liu, Y.-Q. Xu, B. Guo e H.-Y. Shum. Síntese de textura em tempo real por amostragem baseada em patch. Em ACM Transactions on Graphics, 2001.
[22] - L.-W. Wey e M. Levoy. Síntese rápida de textura usando quantização vetorial estruturada em árvore. Em Proc. ACM Conf. Comp. Graphics (SIGGRAPH), 2000.
[23] - A. Zalesny, V. Ferrari, G. Caenen e L. van Gool. Síntese de textura composta paralela. Oficina In Texture 2002 - (em conjunto com ECCV02), Copenhague, Dinamarca, junho de 2002.
[24] - AkurKumar Patel, Universidade Tecnológica de Gujarat, Ciência da Computação e Engenharia
[25] - Algoritmo Robusto Aprimorado para Pintura de Imagem Baseada em Exemplos
[26] - Wikipedia, Relação Pico-Sinal-Ruído
inpaint.exe left top width height img.jpg)?