Why is Python randint() generating bizarre grid effect when used in script to transform image?

Question

I am playing around with images and the random number generator in Python, and I would like to understand the strange output picture my script is generating.

The larger script iterates through each pixel (left to right, then next row down) and changes the color. I used the following function to offset the given input red, green, and blue values by a randomly determined integer between 0 and 150 (so this formula is invoked 3 times for R, G, and B in each iteration):

def colCh(cVal):
  random.seed()
  rnd = random.randint(0,150)
  newVal = max(min(cVal - 75 + rnd,255),0)
  return newVal

My understanding is that random.seed() without arguments uses the system clock as the seed value. Given that it is invoked prior to the calculation of each offset value, I would have expected a fairly random output.

When reviewing the numerical output, it does appear to be quite random:

Scatter plot of every 100th R value as x and R' as y:

However, the picture this script generates has a very peculiar grid effect:

Output picture with grid effect hopefully noticeable:

Furthermore, fwiw, this grid effect seems to appear or disappear at different zoom levels.

I will be experimenting with new methods of creating seed values, but I can't just let this go without trying to get an answer.

Can anybody explain why this is happening? THANKS!!!

Update: Per Dan's comment about possible issues from JPEG compression, the input file format is .jpg and the output file format is .png. I would assume only the output file format would potentially create the issue he describes, but I admittedly do not understand how JPEG compression works at all. In order to try and isolate JPEG compression as the culprit, I changed the script so that the colCh function that creates the randomness is excluded. Instead, it merely reads the original R,G,B values and writes those exact values as the new R,G,B values. As one would expect, this outputs the exact same picture as the input picture. Even when, say, multiplying each R,G,B value by 1.2, I am not seeing the grid effect. Therefore, I am fairly confident this is being caused by the colCh function (i.e. the randomness).

Update 2: I have updated my code to incorporate Sascha's suggestions. First, I moved random.seed() outside of the function so that it is not reseeding based on the system time in every iteration. Second, while I am not quite sure I understand how there is bias in my original function, I am now sampling from a positive/negative distribution. Unfortunately, I am still seeing the grid effect. Here is my new code:

random.seed()
def colCh(cVal):
  rnd = random.uniform(-75,75)
  newVal = int(max(min(cVal + rnd,255),0))
  return newVal

Any more ideas?

Answer 1

As imgur is down for me right now, some guessing:

Your usage of PRNGs is a bit scary. Don't use time-based seeds in very frequently called loops. It's very much possible, that the same seeds are generated and of course this will generate patterns. (granularity of time + number of random-bits used matter here)

So: seed your PRNG once! Don't do this every time, don't do this for every channel. Seed one global PRNG and use it for all operations.

There should be no pattern then.

(If there is: also check the effect of interpolation = image-size change)

Edit: As imgur is on now, i recognized the macro-block like patterns, like Dan mentioned in the comments. Please change your PRNG-usage first before further analysis. And maybe show more complete code.

It may be possible, that you recompressed the output and JPEG-compression emphasized the effects observed before.

Another thing is:

newVal = max(min(cVal - 75 + rnd,255),0)

There is a bit of a bias here (better approach: sample from symmetric negative/positive distribution and clip between 0,255), which can also emphasize some effect (what looked those macroblocks before?).