# Experiments with images #2 – Pseudo-random Images

Date (s) : Multiple days [Unaccounted]

Time : Unaccounted

In my previous post, I had covered some basic operations on/with images using OpenCV such as capturing an image from webcam & storing the pixel values in a file. Moving ahead, I decided to do some miniature experiments on generation of Pseudo-random images, which could be generated using Python’s pseudo-random integer generating function random.randint(). Once I was done with it, I decided to do a similar experiment but rather than selecting a random value b/w 0-255, the program would select a random prime number from prime numbers b/w 0-255. Here are the programs & their outputs which I have covered soo far :

1. Generating a pseudo-random image : This program generates a pseudo-random image using random.randint(). I had to also use the numpy.asarray() function for converting the list into a numpy array :
``````#Generating a pseudo-random Image : An Image where each Pixel's [R,G,B] value is selected randomly between 0-255
#Created by asxyzp (Aashish Panigrahi)

import sys
import cv2
import random
import numpy

'''
Function: GenerateRandomPixel()
Functionality: Will generate a random pixel
Parameter(s): NILL
Output: [R,G,B] list where R,G,B are random values between 0-255
'''
def GenerateRandomPixel():
R = random.randint(0,255)
G = random.randint(0,255)
B = random.randint(0,255)
return list([R,G,B])        #Returns a pixel's [R,G,B] list

'''
Function: GenerateCol()
Functionality: Will generate a list storing y pixel values for an image with x*y resolution
Parameter(s): ColSize - Will store the column size
Output: [[R1,G1,B1], ..... , [Ry,Gy,By]] where Ri,Gi,Bi are random values between 0-255
'''
def GenerateCol(ColSize):
tempCol=[]
for i in range(ColSize):
tempCol.append(GenerateRandomPixel())
return list(tempCol)        #Returns a column list of pixel values for an image with x*y res.

'''
Function: GenerateRow()
Functionality: Will generate a list storing x columns (w/ y pixels) for an image with x*y resolution
Parameters(x) : ColSize - Will store the column size
RowSize - Will store the row size
Output :
[
[[R11,G11,B11],...,[R1y,G1y,B1y]],
.
.
[[Rx1,Gx1,Bx1],...,[Rxy,Gxy,Bxy]],
] where Ri,Gi,Bi will be random values between 0-255
'''
def GenerateRow(ColSize,RowSize):
tempRow=[]
for i in range(RowSize):
tempRow.append(GenerateCol(ColSize))
return list(tempRow)    #Returns a list which stores an image of x*y res.

'''
Function: GenerateRandomImage(NameOfFile)
Functionality: Will generate a random image & will store it in NameOfFile.FileType
Parameter(s): NameOfFile (w/o file type)
'''
def GenerateRandomImage():
NameOfFile = input("Name of file in which random image will be stored (w/o file type)?\t")
ColSize = int(input("Column size of an image?\t"))
RowSize = int(input("Row size of an image?   \t"))
NameOfFile += ".png"
cv2.imwrite(NameOfFile,numpy.asarray(GenerateRow(ColSize,RowSize)))
#numpy.asarray(listName) converted the image list into a numpy array for writing into an image using cv2.imwrite()

RandomIngNum = int(input("Number of random images to be generated?\t"))
i = 0
while i<RandomIngNum:
GenerateRandomImage()
i+=1``````

Output of the above program :

Okay, so the above images look exactly the old Cathode Ray Tube (CRT) television sets :

2. Generating a pseudo-random image using prime integers : This program is same as above, w/ the only difference being that the image is generated w/ the help of prime numbers. Here is the program below :

``````#Description: Generating a pseudorandom image with prime numbers
#Author(s)  : asxyzp

import cv2
import random
import numpy

PrimeArr = []                       #Will store prime numbers between 0-255

'''
Name : CheckPrime(num)
Utility : Checks whether the number num is prime
Parameter(s) : num (a positive integer)
return value : boolean (true : If num is prime, false : If num is not prime)
'''
def CheckPrime(num):
if num<2:                       #0,1 aren't prime
#print(num," is not prime\n")
return False
elif num==2:                    #2 is prime
#print(num," is not prime\n")
return True
elif num>2:
for i in range(2,num):
if num%i==0:            #If num>2 & num is divisible by any number between 2 & num-1, then num isn't prime
return False
return True

'''
Name : GeneratePrimeArr()
Utility : Generates & stores prime numbers between 0 & 255 in primeArr
Parameter(s) : None
Return value : None
'''
def GeneratePrimeArr():
for i in range(0,256):
if CheckPrime(i):           #Appends number if prime
PrimeArr.append(i)

GeneratePrimeArr()                  #Generates an array of prime numbers

'''
Function: GenerateRandomPixel()
Functionality: Will generate a random pixel from PrimeArr list
Parameter(s): NILL
Output: [R,G,B] list where R,G,B are random prime values between 0-255
'''
def GenerateRandomPixel():
R = random.choice(PrimeArr) #random.choice(PrimeArr) chooses random values from PrimeArr list
G = random.choice(PrimeArr)
B = random.choice(PrimeArr)
return list([R,G,B])        #Returns a pixel's [R,G,B] list

'''
Function: GenerateCol()
Functionality: Will generate a list storing y pixel values for an image with x*y resolution
Parameter(s): ColSize - Will store the column size
Output: [[R1,G1,B1], ..... , [Ry,Gy,By]] where Ri,Gi,Bi are random prime values between 0-255
'''
def GenerateCol(ColSize):
tempCol=[]
for i in range(ColSize):
tempCol.append(GenerateRandomPixel())
return list(tempCol)        #Returns a column list of pixel values for an image with x*y res.

'''
Function: GenerateRow()
Functionality: Will generate a list storing x columns (w/ y pixels) for an image with x*y resolution
Parameters(x) : ColSize - Will store the column size
RowSize - Will store the row size
Output :
[
[[R11,G11,B11],...,[R1y,G1y,B1y]],
.
.
[[Rx1,Gx1,Bx1],...,[Rxy,Gxy,Bxy]],
] where Ri,Gi,Bi will be random prime values between 0-255
'''
def GenerateRow(ColSize,RowSize):
tempRow=[]
for i in range(RowSize):
tempRow.append(GenerateCol(ColSize))
return list(tempRow)    #Returns a list which stores an image of x*y res.

'''
Function: GenerateRandomImage(NameOfFile)
Functionality: Will generate a random image & will store it in NameOfFile.FileType
Parameter(s): NameOfFile (w/o file type)
'''
def GenerateRandomImage(NameOfFile,ColSize,RowSize):
NameOfFile += ".png"
cv2.imwrite(NameOfFile,numpy.asarray(GenerateRow(ColSize,RowSize)))
#numpy.asarray(listName) converted the image list into a numpy array for writing into an image using cv2.imwrite()

RandomIngNum = int(input("Number of random images to be generated?\t"))
i = 0
NameOfFile = input("Name of file in which random image will be stored (w/o file type)?\t")
ColSize = int(input("Column size of an image?\t"))
RowSize = int(input("Row size of an image?   \t"))
while i<RandomIngNum:
GenerateRandomImage(NameOfFile+str(i+1),ColSize,RowSize)
i+=1
print("Random prime images generated :)")``````

Output of the above program is same as that of the first program. Moving ahead, I got really curious about the frequency of the occurrence of the pixels in the above images, so I build a program to plot frequency using a python library called as matplotlib. I would be covering this part in my next blog post. Bye for now.