Qual filtro de imagem pode ser aplicado para remover o padrão de grade de jpegs corrompidos?

Tenho cerca de 1.400 jpegs que foram corrompidos de alguma forma e perderam as imagens de backup. Todos eles parecem ter o mesmo padrão de linhas em grade sobre cada um (ou seja, a grade não muda de imagem para imagem.

Aqui está a aparência de uma dessas imagens:

Existem técnicas de filtragem de imagem no Matlab, particularmente ou não, que removerão ou suavizarão esse padrão de grade?

Você pode usar um algoritmo de pintura padrão. Esses algoritmos substituem os pixels marcados em uma imagem pelos valores de pixel que cercam esses pixels marcados. O desafio aqui é detectar a grade (meus testes parecem mostrar que não é uma grade completamente regular). Então, eu vim com esta solução:

from PIL import Image
import requests
from io import BytesIO
import cv2

url = "http://i.stack.imgur.com/Ahrnl.jpg"
response = requests.get(url)
img = Image.open(BytesIO(response.content))

plt.imshow(img)
A = np.array(img)
A2 = A.copy()
A_gray = cv2.cvtColor(A, cv2.COLOR_RGB2GRAY)


# Do some rough edge detection to find the grid
sX = cv2.Sobel(A_gray, cv2.CV_64F, 1, 0, ksize=3)
sY = cv2.Sobel(A_gray, cv2.CV_64F, 0, 1, ksize=3)
sX[sX<0] = 0
sY[sY<0] = 0

plt.subplot(221)
plt.imshow(sX)

plt.subplot(222)
plt.imshow(sY)

plt.subplot(223)
# the sum operation projects the edges to the X or Y-axis. 
# The 0.2 damps the high peaks a little
eX = (sX**.2).sum(axis=0)  
eX = np.roll(eX, -1) # correct for the 1-pixel offset due to Sobel filtering
plt.plot(eX)

plt.subplot(224)
eY = (sY**.2).sum(axis=1)
eY = np.roll(eY, -1)
plt.plot(eY)

mask = np.zeros(A2.shape[:2], dtype=np.uint8)
mask[eY>480,:] = 1
mask[:, eX>390] = 1


A2[mask.astype(bool),:] = 255
plt.figure()
plt.subplot(221)
plt.imshow(A)

plt.subplot(222)
plt.imshow((A2))

restored = cv2.inpaint(A, mask, 1, cv2.INPAINT_NS)
plt.subplot(223)
plt.imshow(restored)

A saída do programa é a seguinte:

Para detectar a grade, fiz uma solução rápida e suja. Pode ser melhorado bastante, mas mostra a ideia inicial. O fluxo geral é:

1. detectar a grade
2. crie uma máscara que descreva quais pixels estão corrompidos pela grade
3. pintar os pixels corrompidos.

Para a pintura, usei a operação de pintura OpenCV . Para detectar a grade, realizei a detecção de arestas nas direções X e Y usando um filtro Sobel. Em seguida, adiciono todos os valores das arestas nas direções X e Y para encontrar picos, onde estão as linhas de grade. Depois, escolho os picos mais altos como as coordenadas nas quais as linhas da grade são estimadas. Não está funcionando perfeitamente (por exemplo, bordas fortes na imagem são falsamente detectadas como linhas de grade), mas mostra a ideia. Pode ser melhorada, por exemplo, na transformação de Hough para encontrar linhas, expulsar arestas muito fortes, etc.

Como alternativa, se a grade é realmente a mesma para todas as imagens, você pode executar a detecção da grade em conjunto para todas as imagens, o que produziria uma precisão muito melhor (basta fazer a técnica acima, mas antes de escolher os picos, resuma os resultados de todas as imagens). Mais detalhadamente, você calcularia o eX para todas as imagens e adicionaria todos esses eX em um único vetor. Esse vetor terá uma estrutura de pico muito mais clara e o limiar pode ser feito mais facilmente.

Tentei um algoritmo realmente simples de executar um filtro mediano 3x3 nos canais R e G dessa imagem e funciona muito bem. O código python é realmente simples:

import scipy.signal as sp
from scipy import ndimage

image = ndimage.imread('Ahrnl.jpg', flatten=False)
image_filtered = np.array(image)
for i in range(2) :
  image_filtered[:,:,i] = sp.medfilt2d(image[:,:,i])

Como alternativa, você pode usar a filtragem de domínio de frequência conforme discutido nesta pergunta: /programming/34027840/removing-periodic-noise-from-an-image-using-the-fourier-transform

A transformação de Fourier da sua imagem mostra claramente alguns "pontos" repetidos no espectro correspondentes a esse ruído periódico.

Como Maximilian apontou, este último método funciona bem apenas se o ruído for perfeitamente periódico, o que não parece ser o caso aqui.

Tentei executar um filtro realmente estúpido que zera quadrados de caixas de frequência 5x5 centrados em múltiplos de 9 nas direções x e y e (meio que) suprime o ruído, mas introduz artefatos em locais que não contêm ruído (por exemplo, o céu).

Talvez se possa fazer melhor com o design cuidadoso do filtro de entalhe, em vez de zerar diretamente as caixas de FFT ( nunca faça isso na prática! ) E aplicar o filtro apenas nas regiões da imagem em que o ruído está presente (por exemplo, não filtre o céu).