Detecting a pixelated image in python

I have no idea if this would work - but, something you could try is to get the nearest neighbors around a pixel. The pixellated squares will be a visible jump in RGB values around a region.

You can find the nearest neighbors for every pixel in an image with something like

def get_neighbors(x,y, img):
    ops = [-1, 0, +1]
    pixels = []
    for opy in ops:
        for opx in ops:
            try:
                pixels.append(img[x+opx][y+opy])
            except:
                pass
    return pixels

This will give you the nearest pixels in a region of your source image.

To use it, you'd do something like

def detect_pixellated(fp):
    img = misc.imread(fp)
    width, height = np.shape(img)[0:2]

    # Pixel change to detect edge
    threshold = 20

    for x in range(width):
        for y in range(height):
            neighbors = get_neighbors(x, y, img)

            # Neighbors come in this order:
            #  6   7   8
            #  3   4   5
            #  0   1   2

            center = neighbor[4]
            del neighbor[4]

            for neighbor in neighbors:
                diffs = map(operator.abs, map(operator.sub, neighbor, center))
                possibleEdge = all(diff > threshold for diff in diffs)

After further thought though, use OpenCV and do edge detection and get contour sizes. That would be significantly easier and more robust.

If you scan through lines of it it's abit easier because then you deal with linear graphs instead of 2d image graphs, which is always simpler.

Solution:

scan a line across the pixels, put the line in an array if it is faster to access for computations, and then run algorithms on the line(s) to determine the blockiness:

1/ run through every pixel in your line and compare it to the previous pixel by substracting the value between the two pixels. make an array of previous pixel values. if large jumps in pixel values are at regular invervals, it's blocky. if there are large jumps in values combined with small jumps in values, it's blocky... you can assume that if there are many equal pixel differences, it's blocky, especially if you repeat the analysis twice at 2 and 4 neighbour pixel intervals, and on multiple lines.

you can also make graphs of pixel differences between pixels 3-5-10 pixels apart, to have additional information on gradient changes of sampled lines of pics. if the ratio of pixel differences of neighbour pixels and 5th neighbour pixels is similar, it also indicates unsmooth colors.

there can be many algorythms, including fast fourrier on a linear graph, same as audio, that you would use on line(s) from the pic, that is simpler than a 2d image algorythm.