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.