## Prerequisites

Go through the previous article of this thread: [๐ท] Tinkering with images #1

## Introduction

In my previous **post**, I covered some basic operations that I was able to perform on images using OpenCV, such as, capturing an image from my laptop’s webcam & storing its pixel values in a file.

Since it became clear to me, that, a

where each element of the array is called a **digital image of N*M dimensions is basically a multi-dimensional array with N rows and M columns**, **pixel** where each pixel is an array of three elements denoting intensity values for red, green & blue pixels, ranging between 0 & 255. The above description can be shown in the image below:

Keeping the above description in mind, I decided to work on the following:

- Generation of
**“pseudo-random images”**or basically images where the value of each pixel’s element is generated using Python’s pseudo-random integer generating function,.`random.randint()`

- Next, I decided to work on something similar: Rather than selecting a random integer value b/w 0-255, the program would select a
**random prime number**from prime numbers b/w 0-255. I wanted to check whether there was any significant difference between the two.

**Program #1**: Generating a pseudo-random image

**Explanation:** Basically, the entire program can be broken down into three functions:

1. ** generateRandomPixel()** : This function generates individual pixels of an image where the value for red, green & blue pixels is generated using the

**method, which returns a pseudo-random integer between 0 & 255. The output of this function can be described as**

`random.randInt(0,255)`

**. Here is the code for the above-mentioned function:**

`[random.randInt(0,255), random.randInt(0,255), random.randInt(0,255)]`

```
#GENERATING PSEUDO-RANDOM IMAGES
#IMPORTING MODULES
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 list [R,G,B]
```

2. ** generateCol(ColSize):** It returns a row of pixels with

**length. The way this works is by simply calling the**

`colSize`

**method, where,**

`generateRandomPixel()`

**is the column size. The output of the above method is pushed into a temporary array which is returned back. The actual output looks like this:**

`colSize`

**. Here is the code for the above-mentioned function:**

`[[R1,G1,B1], ..... , [Ry,Gy,By]]`

```
'''
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.
```

3. ** generateRow(ColSize,RowSize)**: It returns an M*N array with each element of the array being a pixel, which is an array of 3 values. This is done by simply calling the

**,**

`generateCol(colSize)`

**number of times. The only thing to keep in mind would be th**

`rowSize`

**e**method that will generate a list, but to convert this into an image, we would have to convert this list into a NumPy array, which can be achieved using the

`generateRow`

**numpy.asarray()**

method which can be imported using the NumPy package. ```
'''
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 #1**

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

**Image: A Cathode Ray Tube (CRT) Television****Program #2**: Generating a pseudo-random image using prime integers

This program is the 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 #2**

The output of the above program is the same as that of the first program.

**Summary**

Hereโs a small summary of all the different functions used in the program:

** random.randInt(M,N): **Returns a random integer between M & N.

** numpy.asarray(list)**: Converts a list into an array.

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 **matplotlib**. I would be covering this part in my next blog post. Bye for now.

## One response to “[๐ท] Tinkering with images #2”

[…] my previous post, I had written about my experiments with pseudo-random images with integers & prime integers […]

LikeLike