I have around 1,400 jpegs that have been corrupted somehow and have lost the backup images. They all seem to have the same gridded pattern of lines over each (i.e. the gridding does not shift from image to image.
Here's what one of these images looks like:
Are there any image filtering techniques in Matlab particulary or otherwise that will remove or smooth this gridding pattern?
You can use a standard inpainting algorithm. These algorithms replace marked pixels in an image with the pixel values that surround these marked pixels. The challenge here is to detect the grid (my tests seem to show that it is not a completely regular grid). So, I came up with this solution:
from PIL import Image
import requests
from io import BytesIO
import cv2
url = "https://i.sstatic.net/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)
The program output is as follows:
To detect the grid I did a quick-and-dirty solution. It can be improved a lot, but it shows the initial idea. The general flow is:
For inpainting I used OpenCV inpaint operation. For detecting the grid, I performed edge detection in X and Y direction using a Sobel filter. Then I add all edge values in the X-direction and Y-direction to find peaks, where the grid lines are. Then, I choose the highest peaks as the coordinates where the grid lines are estimated. It's not working perfect (e.g. strong edges in the image are falsely detected as grid lines), but it shows the idea. It can be improved by e.g. Hough transformation to find lines, kicking out very strong edges etc.
Alternatively, if the grid is really the same for all images, then you can perform the grid detection jointly for all images, which would yield a much better accuracy (just do the technique above, but before choosing the peaks, sum up the results from all pictures). In more detail, you would calculate eX for all images and add all these eX together into a single vector. This vector will have a much clearer peak structure and the thresholding can be done easier.
I tried a really simple algorithm of running a 3x3 median filter on the R and G channels of that image and it works quite well.
The python code is really simple:
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])
Alternatively you can use frequency domain filtering as discussed in this question: https://stackoverflow.com/questions/34027840/removing-periodic-noise-from-an-image-using-the-fourier-transform
The Fourier transform of your image clearly shows some repeated "dots" in the spectrum corresponding to this periodic noise.
As Maximilian pointed out, this latter method works well only if the noise is perfectly periodic, which does not seem to be the case here.
I tried running a really stupid filter that zeros out 5x5 squares of frequency bins centered around multiples of 9 in both x and y directions and it (sort of) suppresses the noise but introduces artifacts in locations that don't contain noise (eg. the sky).
One can perhaps do better with careful notch-filter design instead of directly zeroing FFT bins (never do that in practice!) and only applying the filter in regions of the image where the noise is present (i.e. don't filter the sky).
