Question

I want to get an estimate for the worst-case scenario of an algorithm where the number of iterations depends on how many pixels in an image have neighbours that differ from themselves. Assuming the image to be in grayscale, I’m looking for a way to generate an M x N matrix filled with random values in the range [0, 255] where no two pixels with the same value are contiguous (including “corner” neighbours, i.e. this is for the 8-neighbour case).

Edit: should’ve made this clearer in the original posting. I’m looking to get a relatively uniform sampling of all values in the range [0, 255].

How would one do this? The efficiency of the solution doesn’t really matter, I’m looking for something that’s easy to reason about.

Answer 1

0 1 0 1 0 1 0
2 3 2 3 2 3 2
1 0 1 0 1 0 1

etc.

More generally, the dumbest way to try to colour a graph is to visit each vertex in turn (in any order you like), and give it a colour that hasn’t already been used for a vertex that’s adjacent to it. If (as in this case) you have more colours than the greatest possible number of adjacent vertices, you can’t lose.

The grid above is the result of visiting the matrix from left-to-right along each row, and using the smallest available value. You can instead choose one at random from the available values:

import random
rows = [[None] * 10 for i in xrange(10)] # or numpy matrix
for i, row in enumerate(rows):
    for j, _ in enumerate(row):
        available = set(xrange(256))
        if j > 0:
            available.discard(row[j-1])
        if i > 0:
            available.difference_update(rows[i-1][max(0,j-1):j+2])
        row[j] = random.choice(tuple(available))
print '\n'.join(map(str, rows))