# CECS 229 Programming Assignment #5

Original price was: \$35.00.Current price is: \$30.00.

Category:

CECS 229 Programming Assignment #5

Submission Instructions:
To receive credit for this assignment you must submit the to CodePost a file named pa5.py by the due date:

Objectives:
Define a matrix data structure with relevant matrix operations.
Understand the role of matrices in simple image processing applications.
Problem 1.
Implement a class Matrix that creates matrix objects with attributes

colsp -column space of the Matrix object, as a list of columns (also lists)
rowsp -row space of the Matrix object, as a list of rows (also lists)
The constructor takes a list of rows as an argument, and constructs the column space from this rowspace. If a list is not provided, the parameter defaults to an empty list.

You must implement the following methods in the Matrix class:

Setters

set_col(self, j, u) – changes the j-th column to be the list u. If u is not the same length as the existing columns, then the method raises a ValueError with the message Incompatible column length.
set_row(self,i, v) – changes the i-th row to be the list v. If v is not the same length as the existing rows, then method raises a ValueError with the message Incompatible row length.
set_entry(self,i, j, x) – changes the existing  aij
entry in the matrix to x.
Getters

get_col(self, j) – returns the j-th column as a list.
get_row(self, i) – returns the i-th row as a list v.
get_entry(self, i, j) – returns the existing  aij
entry in the matrix.
col_space(self) – returns the list of vectors that make up the column space of the matrix object
row_space(self) – returns the list of vectors that make up the row space of the matrix object
get_diag(self, k) – returns the  k
-th diagonal of a matrix where  k=0
returns the main diagonal,  k>0
returns the diagonal beginning at  a1(k+1)
, and  k<0
returns the diagonal beginning at  a(−k+1)1
. e.g. get_diag(1) for an  n×n
matrix returns [ a12,a23,a34,…,a(n−1)n
]
__str__(self) – returns a formatted string representing the matrix entries as
a11a21⋮am1a12a22⋮am2……⋱…a1ma2m⋮amn

In addition to the methods above, the Matrix class must also overload the +, -, and * operators to support:

Matrix – Matrix subtraction
Matrix * scalar multiplication
Matrix * Matrix multiplication
Matrix * Vec multiplication
scalar * Matrix multiplication
# Importing the Vector class(created in the previous assignment) from the vector.py file
# from Vector import Vec

# Writing a Matrix class to create matrix objects with rows and columns with overloaded operators
class Matrix:

def __init__(self, rowsp):
self.rowsp = rowsp
self.colsp = self._construct_cols(rowsp)

# Constructing columns based on the number of row space
def _construct_cols(self, rowsp):
# Intializing column space as an empty list
colsp = []
# Setting Column number the same as the number of rows in the row space
cols_num = len(rowsp[0])
# Creating a list of empty lists for each column space
for _ in range(cols_num):
colsp.append([])

# Iterating through each row in the row space
for row in rowsp:
# Iterating through each entry in the row
for i, entry in enumerate(row):
# Appending the entry to the column space list
colsp[i].append(entry)
return colsp

def set_col(self, j, u):
”’
Changes the j-th column to be the list `u`.  If `u` is not the same length
as the existing columns, then the method raises a `ValueError` with the
message `Incompatible column length.`
”’
# Conditional statement to check u = length of the existing columns
if len(u) != len(self.colsp[0]):
# Raising ValueError if condition is not met
raise ValueError(“Incompatible column length.”)
else: # Running the code below if the condition is met
# Updating the first column space with the new column
self.colsp[j – 1] = u # -> j-1 because the index starts from 0
# Iterating through the row space
for i in range(len(self.rowsp)):
# Updating the row space with the new column
self.rowsp[i][j – 1] = u[i]

def set_row(self, i, v):
”’
Changes the i-th row to be the list `v`.  If `v` is not the same length
as the existing rows, then method raises a `ValueError` with the
message `Incompatible row length.`
”’
# Conditional statement to check v = length of the existing rows
if len(v) != len(self.rowsp[0]): # Starting from 0 because the index starts from 0
# Raising ValueError if condition is not met
raise ValueError(“Incompatible row length.”)
else: # Running the code below if the condition is met
# Updating the row space with the new row
self.rowsp[i – 1] = v
# Reconstructing the column space of the matrix
self.colsp = self._construct_cols(self.rowsp)

def set_entry(self, i, j, x):
”’
Changes the existing a_ij entry in the matrix to ‘x’.
”’
# Replacing the j-th entry in the row with x
self.rowsp[i – 1][j – 1] = x # -> i-1, j-1 because the index starts from 0
# Replacing the i-th entry in the column with x
self.colsp[j – 1][i – 1] = x # -> i-1, j-1 because the index starts from 0

# Returns the j-th column as a list
def get_col(self, j):
return self.colsp[j – 1] # -> j-1 because the index starts from 0

# Returns the i-th row as a list v
def get_row(self, i):
return self.rowsp[i – 1] # -> i-1 because the index starts from 0

# Returns the a_ij entry in the matrix
def get_entry(self, i, j):
return self.rowsp[i – 1][j – 1]

# Returns the list of vectors that make up the column space of the matrix object
def row_space(self):
return self.rowsp

# Returns the list of vectors that make up the row space of the matrix object
def col_space(self):
return self.colsp

def get_diag(self, k):
”’
Returns the k-th diagonal of the matrix as a list, where:
-> k = 0 returns the main diagonal
-> k > 0 returns the diagonal beginning at a_1(k+1)
-> k < 0 returns the diagonal beginning at a_-(k+1)1
”’
if k > 0:
# Storing diagonal entries beginning at a_1(k+1)
diag_3 = []
# Iterating through the row spaces from a_1(k+1)
for i in range(len(self.rowsp) – k):
# Appending the values based on the given kth value
diag_3.append(self.rowsp[i][i + k]) # -> 1(k+1) => (1)(k+1) => [i][i+k]
# Returning the diagonal values from a_1(k+1)
return diag_3
elif k < 0:
# Storing diagonal entries beginning at a_-(k+1)1
diag_2 = []
# Iterating through the row spaces from a_-(k+1)1
for i in range(len(self.rowsp) + k):
# Appending the values based on the given kth value
diag_2.append(self.rowsp[i – k][i]) # -> -(k+1)1 => (1-k)(1) => [i-k][i]
# Returning the diagonal values from a_-(k+1)1
return diag_2
else:
# Storing the main diagonal entries
main_diag = []
# Iterating through the row spaces
for i in range(len(self.rowsp)):
# Appending the values of the main diagonal
main_diag.append(self.rowsp[i][i])
# Returning the values of the main diagonal
return main_diag

if len(self.rowsp) != len(other.rowsp) or len(self.colsp) != len(other.colsp):
raise ValueError(“Incompatible matrix dimensions for addition.”)
else:
# Creating a list of empty lists for the sum of the matrices
matrix_sum = []
for i in range(len(self.rowsp)):
row_sum = []
for j in range(len(self.colsp)):
# Appending the sum of the corresponding entries to row sum
row_sum.append(self.rowsp[i][j] + other.rowsp[i][j])
# Appending the row sum to the matrix sum
matrix_sum.append(row_sum)
# Returning the matrix sum as a Matrix object
return Matrix(matrix_sum)

def __sub__(self, other):
if len(self.rowsp) != len(other.rowsp) or len(self.colsp) != len(other.colsp):
raise ValueError(“Incompatible matrix dimensions for subtraction.”)
else:
# Creating a list of empty lists for the difference of the matrices
matrix_diff = []
for i in range(len(self.rowsp)):
# Storing each reduced row in a list
row_diff = []
for j in range(len(self.colsp)):
# Appending the difference of the corresponding entries to row difference
row_diff.append(self.rowsp[i][j] – other.rowsp[i][j])
# Appending the row difference to the matrix difference
matrix_diff.append(row_diff)
# Returning the reduced matrix as a Matrix object
return Matrix(matrix_diff)

def __mul__(self, other):
if type(other) == float or type(other) == int:
# Storing the product of matrix-scalar multiplication
scalar_mult_matrix = []
# Iterating through each row in the row space
for final_matrix_row in self.rowsp:
# Storing the each scaled row in a list
scaled_row = []
# Going through each element in the row
for element in final_matrix_row:
# Mulitplying each element with the scalar value
scaled_element = element * other
# Appending the scaled product into the scaled row
scaled_row.append(scaled_element)
# Appending the scaled rows to the scaled matrix
scalar_mult_matrix.append(scaled_row)
# Returning a scaled matrix as a Matrix object
return Matrix(scalar_mult_matrix)
elif type(other) == Matrix: # If the other object is a matrix
# Checking if dimensions of the matrices match or not
if len(self.rowsp[0]) != len(other.rowsp):
raise ValueError(“Dimension mismatch for multiplication.”)
else: # Running the code below if the dimensions are fine
# Array to store the product of the matrices
product_of_matrices = []
# Iterating through the rows of the first matrix
for row in range(len(self.rowsp)):
# Storing the product of each row of the first matrix with the columns of the second matrix
final_matrix_row = []
# Iterating through the columns of the other matrix
for column in range(len(other.colsp)):
# Storing the sum of the product of each row
matrix_sum = 0
# Iterating through the first index of the other matrix’s column
for l in range(len(other.colsp[0])):
# Storing the multiplication of first matrix
self_matrix_mul = self.rowsp[row][l]
# Storing the multiplication of the second matrix
other_matrix_mul = other.rowsp[l][column]
# Adding the products of the two matrices’ rows
matrix_sum += self_matrix_mul * other_matrix_mul
# Appending the matrix sum to final matrix row
final_matrix_row.append(matrix_sum)
# Appending the final matrix rows to the final matrix product
product_of_matrices.append(final_matrix_row)
# Returning the product of matrices as a Matrix object
return Matrix(product_of_matrices)
elif type(other) == Vec.Vec: # If the other object is a vector
“””This didn’t work”””
matrix_vector_product = []
for final_matrix_row in self.rowsp:
mat_vec_product = 0
for row in range(len(final_matrix_row)):
mat_vec_product += final_matrix_row[row] * Vec.Vec(other)
matrix_vector_product.append(mat_vec_product)
return Vec.Vec(matrix_vector_product)
else:
print(“ERROR: Unsupported Type.”)
return

def __rmul__(self, other):
if type(other) == float or type(other) == int:
return self.__mul__(other)
else:
print(“ERROR: Unsupported Type.”)
return

# Returns a formatted string representing the matrix entries as
def __str__(self):
“””prints the rows and columns in matrix form “””
mat_str = “”
for row in self.rowsp:
mat_str += str(row) + “\n”
return mat_str

def __eq__(self, other):
“””overloads the == operator to return True if
two Matrix objects have the same row space and column space”””
return self.row_space() == other.row_space() and self.col_space() == other.col_space()

def __req__(self, other):
“””overloads the == operator to return True if
two Matrix objects have the same row space and column space”””
return self.row_space() == other.row_space() and self.col_space() == other.col_space()
”’
B = Matrix([ [1, 2, 3, 4], [0, 1, 2, 3], [-1, 0, 1, 2], [-2, -1, 2, 3]])
A = Matrix([ [2, 0], [0, 2], [0, 0], [0, 0]])

print(“Matrix A:”)
print(A)
print()

print(“Matrix B:”)
print(B)
”’
Matrix A:
[2, 0]
[0, 2]
[0, 0]
[0, 0]

Matrix B:
[1, 2, 3, 4]
[0, 1, 2, 3]
[-1, 0, 1, 2]
[-2, -1, 2, 3]

Tester Cell for get_diag()
“””All Works
B = Matrix([ [1, 2, 3, 4], [0, 1, 2, 3], [-1, 0, 1, 2], [-2, -1, 2, 3]])
print(“Matrix:”)
print(B)

print(“Main diagonal:”,B.get_diag(0))
print(“Expected: [1, 1, 1, 3]”)
print()
print(“Diagonal at k = -1:”, B.get_diag(-1))
print(“Expected: [0, 0, 2]”)
print()
print(“Diagonal at k = -2:”, B.get_diag(-2))
print(“Expected: [-1, -1]”)
print()
print(“Diagonal at k = -3:”, B.get_diag(-3))
print(“Expected: [-2]”)
print()
print(“Diagonal at k = 1:”, B.get_diag(1))
print(“Expected: [2, 2, 2]”)
print()
print(“Diagonal at k = 2:”, B.get_diag(2))
print(“Expected: [3, 3]”)
print()
print(“Diagonal at k = 3:”, B.get_diag(3))
print(“Expected: [4]”)
“””
Matrix:
[1, 2, 3, 4]
[0, 1, 2, 3]
[-1, 0, 1, 2]
[-2, -1, 2, 3]

Main diagonal: [1, 1, 1, 3]
Expected: [1, 1, 1, 3]

Diagonal at k = -1: [0, 0, 2]
Expected: [0, 0, 2]

Diagonal at k = -2: [-1, -1]
Expected: [-1, -1]

Diagonal at k = -3: [-2]
Expected: [-2]

Diagonal at k = 1: [2, 2, 2]
Expected: [2, 2, 2]

Diagonal at k = 2: [3, 3]
Expected: [3, 3]

Diagonal at k = 3: [4]
Expected: [4]
Tester Cell for
row_space()
col_space()
get_row()
get_col()
set_row()
set_col()
”’All Works
A = Matrix([[1, 2, 3], [4, 5, 6]])
print(“Original Row Space:”, A.row_space())
print(“Original Column Space:”, A.col_space())
print(“Original Matrix:”)
print(A)
print()

A.set_row(1, [10, 20, 30])
print(“Modification #1”)
print(“Row Space after modification:”, A.row_space())
print(“Column Space after modification:”, A.col_space())
print(“Modified Matrix:”)
print(A)
print()

A.set_col(2, [20, 50])
print(“Modification #2”)
print(“Row Space after modification:”, A.row_space())
print(“Column Space after modification:”, A.col_space())
print(“Modified Matrix:”)
print(A)
print()

A.set_row(2, [40, 50, 6])
print(“Modification #3”)
print(“Row Space after modification:”, A.row_space())
print(“Column Space after modification:”, A.col_space())
print(“Modified Matrix:”)
print(A)
print()

A.set_entry(2, 3, 60)
print(“Modification #4”)
print(“Row Space after modification:”, A.row_space())
print(“Column Space after modification:”, A.col_space())
print(“Modified Matrix:”)
print(A)
print()

print(“The 2nd row is:”, A.get_row(2))
print(“The 3rd column is:”, A.get_col(3))
print()

print(“Modification #5″)
A.set_row(2, [40, 50])
A.set_col(2, [30, 4, 1])
print(A)
”’
Original Row Space: [[1, 2, 3], [4, 5, 6]]
Original Column Space: [[1, 4], [2, 5], [3, 6]]
Original Matrix:
[1, 2, 3]
[4, 5, 6]

Modification #1
Row Space after modification: [[10, 20, 30], [4, 5, 6]]
Column Space after modification: [[1, 10], [20, 5], [3, 30]]
Modified Matrix:
[10, 20, 30]
[4, 5, 6]

Modification #2
Row Space after modification: [[10, 20, 30], [4, 50, 6]]
Column Space after modification: [[1, 10], [20, 50], [3, 30]]
Modified Matrix:
[10, 20, 30]
[4, 50, 6]

Modification #3
Row Space after modification: [[10, 20, 30], [40, 50, 6]]
Column Space after modification: [[1, 40], [50, 50], [3, 6]]
Modified Matrix:
[10, 20, 30]
[40, 50, 6]

Modification #4
Row Space after modification: [[10, 20, 30], [40, 50, 60]]
Column Space after modification: [[1, 40], [50, 50], [3, 60]]
Modified Matrix:
[10, 20, 30]
[40, 50, 60]

The 2nd row is: [40, 50, 60]
The 3rd column is: [3, 60]

Modification #5
—————————————————————————
ValueError                                Traceback (most recent call last)
Cell In[88], line 49
45 print()
48 print(“Modification #5”)
—> 49 A.set_row(2, [40, 50])
50 A.set_col(2, [30, 4, 1])
51 print(A)

Cell In[87], line 56, in Matrix.set_row(self, i, v)
53 # Conditional statement to check v = length of the existing rows
54 if len(v) != len(self.rowsp[0]): # Starting from 0 because the index starts from 0
55     # Raising ValueError if condition is not met
—> 56     raise ValueError(“Incompatible row length.”)
57 else: # Running the code below if the condition is met
58     # Updating the row space with the new row
59     self.rowsp[i – 1] = v

ValueError: Incompatible row length.
Expected Output

Original Row Space: [[1, 2, 3], [4, 5, 6]]
Original Column Space: [[1, 4], [2, 5], [3, 6]]
Original Matrix:
[1, 2, 3]
[4, 5, 6]

Modification #1
Row Space after modification: [[10, 20, 30], [4, 5, 6]]
Column Space after modification: [[10, 4], [20, 5], [30, 6]]
Modified Matrix: Set row 1 to [10, 20, 30]
[10, 20, 30]
[4, 5, 6]

Modification #2
Row Space after modification: [[10, 20, 30], [4, 50, 6]]
Column Space after modification: [[10, 4], [20, 50], [30, 6]]
Modified Matrix: Set col 2 to [20, 50]
[10, 20, 30]
[4, 50, 6]

Modification #3
Row Space after modification: [[10, 20, 30], [40, 50, 6]]
Column Space after modification: [[10, 40], [20, 50], [30, 6]]
Modified Matrix: Set row 2 to [40, 50, 6]
[10, 20, 30]
[40, 50, 6]

Modification #4
Row Space after modification: [[10, 20, 30], [40, 50, 60]]
Column Space after modification: [[10, 40], [20, 50], [30, 60]]
Modified Matrix: Set row 2 col 3 to 60
[10, 20, 30]
[40, 50, 60]

The 2nd row is: [40, 50, 60]
The 3rd column is: [30, 60]

Modification #5
—————————————————————————
ValueError                                Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_9756/1966277524.py in <module>
48 #——— MODIFICATION 5 —————#
49 print(“Modification #5”)
—> 50 A.setRow(2, [40, 50])
51 A.setCol(2, [30, 4, 1])
52 print(“Modified Matrix: Set row 2 to [40, 50] and col 2 to [30, 4, 1]”)

~\AppData\Local\Temp/ipykernel_9756/2205165582.py in setRow(self, i, v)
159         “””Sets the i-th row to be the list v”””
160         if len(v) != len(self.Rowsp[0]):
–> 161             raise ValueError(“ERROR: Incompatible row length.”)
162         else:
163             self.Rowsp[i-1] = v  # Updating the row

ValueError: ERROR: Incompatible row length.`
Tester cell for +, -, *
“””———————————–TESTER CELL————————————————-
“TESTING OPERATOR + ”

A = Matrix([[1, 2],[3, 4],[5, 6]])
B = Matrix([[1, 2],[1, 2]])
C = Matrix([[10, 20],[30, 40],[50, 60]])

# P = A + B # dimension mismatch –> Check successful
Q = A + C
R = A – C

print(“Matrix A”)
print(A)
print()

print(“Matrix C”)
print(C)
print()

”’Works”’
print(“Matrix Q = A + C”)
print(Q)
print()

”’Works”’
print(“Matrix R = A – C”)
print(R)
print()

“TESTING OPERATOR * ”
# TESTING SCALAR-MATRIX MULTIPLICATION
T = -0.5 * B
print(“Matrix B”)
print(B)
print()

”’Works”’
print(“Matrix T = -0.5 * B”)
print(T)
print()

# TESTING MATRIX-MATRIX MULTIPLICATION
U = A * B
print(“Matrix U = A * B”)
print(U)
print()

# TESTING MATRIX-VECTOR MULTIPLICATION
x = Vec([0, 1])  # Vec object
b = A * x   # b is a Vec data type
print(“Vector b = A * x”)
print(b)
“””
Matrix A
[1, 2]
[3, 4]
[5, 6]

Matrix C
[10, 20]
[30, 40]
[50, 60]

Matrix Q = A + C
[11, 22]
[33, 44]
[55, 66]

Matrix R = A – C
[-9, -18]
[-27, -36]
[-45, -54]

Matrix B
[1, 2]
[1, 2]

Matrix T = -0.5 * B
[-0.5, -1.0]
[-0.5, -1.0]

Matrix U = A * B
[3, 6]
[7, 14]
[11, 22]

—————————————————————————
TypeError                                 Traceback (most recent call last)
Cell In[92], line 52
50 # TESTING MATRIX-VECTOR MULTIPLICATION
51 x = Vec([0, 1])  # Vec object
—> 52 b = A * x   # b is a Vec data type
53 print(“Vector b = A * x”)
54 print(b)

Cell In[87], line 217, in Matrix.__mul__(self, other)
215     mat_vec_product = 0
216     for i in range(len(row)):
–> 217         mat_vec_product += row[i] * Vec(other)
218     matrix_vector_product.append(mat_vec_product)
219 return Vec(matrix_vector_product)

File c:\Users\User\OneDrive\Desktop\CECS Files\CECS 229 Files\Programming Assignment #5\Vector.py:129, in Vec.__rmul__(self, other)
127 vector_product = []
128 # Running a loop through all the elements in the vector
–> 129 for element in range(len(self.elements)):
130     # Multiplying the each elements in the vector to the scalar value
131     product_result = self.elements[element] * other
132     # Appending the product of the elements to the list

TypeError: object of type ‘Vec’ has no len()
⎡⎣⎢135246⎤⎦⎥[01]=⎡⎣⎢1⋅0+2⋅13⋅0+4⋅15⋅0+6⋅1⎤⎦⎥=⎡⎣⎢246⎤⎦⎥

Expected Output:

Matrix A
[1, 2]
[3, 4]
[5, 6]

Matrix C
[10, 20]
[30, 40]
[50, 60]

Matrix Q = A + C
[11, 22]
[33, 44]
[55, 66]

Matrix R = A – C
[-9, -18]
[-27, -36]
[-45, -54]

Matrix B
[1, 2]
[1, 2]

Matrix T = -0.5 * B
[-0.5, -1.0]
[-0.5, -1.0]

Matrix A:
[1, 2]
[3, 4]
[5, 6]

Row-space of A:
[[1, 2], [3, 4], [5, 6]]

Column-space of A:
[[1, 3, 5], [2, 4, 6]]

Matrix B:
[1, 2]
[1, 2]

Row-space of B:
[[1, 2], [1, 2]]

Column-space of B:
[[1, 1], [2, 2]]

Matrix U = A * B
[3, 6]
[7, 14]
[11, 22]

Vector b = A * x
[0, -2, -4]
Extra-Credit
Worth: 5% extra-credit applied to midterm

Submit your work on this Jupyter NB to the appropriate Dropbox folder by Sunday, 4/9 @11:59 PM
Submit your completed video to the appropriate Dropbox folder by Sunday, 4/9 @11:59 PM
Demo your work to me during OH in order to receive the extra-credit. The last day you may demo is Thursday, 4/20.
No partial credit. This is an all-or-nothing EC opportunity
Background:

One of my favorite bands is “Alt-J”. Take a look at the music video for their song, “Matilda” at https://www.youtube.com/watch?v=Q06wFUi5OM8. The faces you see morphing into one another are the faces of the four members who were in the band at the time. In this exercise you will explore how a simplified version of this “morphing effect” can be achieved. In our simplified morphing effect, we will fade one face into another.

First, keep in mind that a video is just a collection of several still images displayed with a speed fast enough to make the change from one image to another imperceptible to the human eye.

To make the discussion simpler, suppose the images are grayscale pictures. We can represent a grayscale picture with  m×n
pixels as a matrix  Pm×n
where each entry  pij∈{0,1,…,255}
is the intensity value of the pixel at location  (i,j)
, [The intensity values range from 0 (black) to 255 (white)]. We are able to prove that the set of matrices  S={Pm×n|pij∈Z256}
is a vector space, under addition and scalar multiplication defined as below:

Let  P,Q∈S
, and  α∈R,0≤α≤1

Addition:  P+Q=[aij] where aij={pij+qij255 if the sum is 255 or less otherwise

Scalar Multiplication:  αP=[aij] where aij={αpij255 if the product is 255 or less otherwise

Hence, given two “image-matrices”  P1,P2∈S
, we can form convex combinations of these two elements with the confidence that the resulting matrices will be in  S
, and thus, still represent images; i.e., if  α1,α2∈R
such that  α1+α2=1
, then

α1P1+α2P2∈S
and represents a new image.

Think: what would the image corresponding to matrix  P
look like if  P=0.5P1+0.5P2
? Since the images  P1
and  P2
make an equal contribution to the intensity of each pixel in  P
, we can expect the image to look like an equal mix of the two images. e.g. if the two images contain faces in more-or-less the same position, the resulting image should display a face that more-or-less looks like both faces.

What if  P=0.85P1+0.15P2
? Then, since most of the intensity in each pixel of  P
is being contributed by  P1
, we can expect the resulting image  P
to display something that looks more like the first image,  P1
, vs the second image,  P2
.

Download the png and image modules. The image module contains the methods

file2image() – Reads an image into a list of lists of pixel values (triples with values representing the three intensities in the RGB color channels). e.g. [[(1, 2, 3), (1, 2, 3), (1, 2, 3)],[(1, 2, 3), (1, 2, 3), (1, 2, 3)],[(1, 2, 3), (1, 2, 3), (1, 2, 3)]] would be representing an image with  3×3
pixels.
image2file() – Writes an image in list of lists format to a file.
Use the functions listed above to implement:

img2matrix(filename) – creates and returns a Matrix object with the image data returned by file2image() from the module image. The parameter filename is a string data type specifying the location of the image you wish to use. If the image is not grayscale, you must convert it to grayscale prior to creating the Matrix object. You can do so using the functions isgray() and color2gray(), also found in the image module.
matrix2img(image_matrix, path) – creates a png file out of a Matrix object. You may want to use the function image2file() from the image module.
“””
import image
import png

def image2matrix(filename):
takes a png file and returns a Matrix object of the pixels
INPUT: filename – the path and filename of the png file
OUTPUT: a Matrix object with dimensions m x n, assuming the png file has width = n and height = m,
# Reading the image file into a triplet list of pixel values
image_data = image.file2image(filename)
# Conditional statement to check if the image is grayscale
if not image.isgray(image_data):
image_data = image.color2gray(image_data)
return Matrix(image_data)

def matrix2image(img_matrix, path):
returns a png file created using the Matrix object, img_matrix
INPUT:
* img_matrix – a Matrix object where img_matrix[i][j] is the intensity of the (i,j) pixel
* path – the location and name under which to save the created png file
OUTPUT:
* a png file
image_data = []
for i in range(img_matrix.nrows()):
row = []
for j in range(img_matrix.ncols()):
pixel_value = int(img_matrix[i][j])
row.append(pixel_value)
image_data.append(row)
image.image2file(image_data, path)
“””
“””——————TESTER FOR FUNCTIONS png2graymatrix() AND graymatrix2png()————————-“””
# M = image2matrix(“img11.png”)  # matrix for img11.png
# F = image2matrix(“img02.png”)  # matrix for img02.png
# C = (0.40 * M) + (0.60 * F)   # convex combo: first image contributes 40% of its intensity, second image contributes 60%

# matrix2image(C, “mixedfaces.png”)  # converting the matrix to png named mixedfaces

Download and extract the zip folder faces.zip. In it, you will find the images of 20 faces.
Use the functions you implemented in Task 1 to implement a function called mix(img1, img2) that generates a set of 101 images. These images must be the result of taking convex combinations of two given images. In particular, you should begin by combining the two images so that the 1st/101 picture looks completely like img1. Then, modify the scalars of the combination so that the mixed image is the sum of a percentage of the intensities for each image. For example, the 2nd/101 picture would be a mixture of 99% of the first image’s intensity mixed with 1% of the second image’s intensity. The 51th/100 picture will look like both images equally mixed together (50/50). The 76th picture will looks like 25% of the first image’s intensity mixed with 75% of the second image’s intensity, and the 101st/101 picture looks like img2 only.
Call your mix() function on two images of your choice found in the faces.zip folder. The resulting images should give the illusion that one face is morphing into the other.
“””def mix(img1, img2):
generates a set of 101 images that results from the convex mixing the given images
INPUT:
– img1: string of path + name of first image
– img2: string of path + name of second image

OUTPUT: None (images are saved to the path given to matrix2image())

image1_matrix = image2matrix(img1)
image2_matrix = image2matrix(img2)

for i in range(101):
percentage_1 = (100 – i) / 100
percentage_2 = i / 100

mixed_image_matrix = (Matrix(image1_matrix) * percentage_1) + (Matrix(image2_matrix) * percentage_2)

file_path = f”mixed_image/{i}.png”
matrix2image(mixed_image_matrix, file_path)
“””

Use the function make_video() below to create a video out of the 101 images you generated in Task 2. You will need to have installed the package opencv in order for the function to work. I recommend that you complete this entire task in a separate IDE such as PyCharm, where it is easier to install packages.

# import cv2
# import os

“””def make_video(images, outvid=None, fps=5, size=None, is_color=True, format=”XVID”):
Create a video from a list of images.

@param      outvid      output video
@param      images      list of images to use in the video
@param      fps         frame per second
@param      size        size of each frame
@param      is_color    color
@param      format      see http://www.fourcc.org/codecs.php

By default, the video will have the size of the first image.
It will resize every image to this size before adding them to the video.

fourcc = cv2.VideoWriter_fourcc(*format)
vid = None
for image in images:
if not os.path.exists(image):
raise FileNotFoundError(image)
if vid is None:
if size is None:
size = img.shape[1], img.shape[0]
vid = cv2.VideoWriter(outvid, fourcc, float(fps), size, is_color)
if size[0] != img.shape[1] and size[1] != img.shape[0]:
img = cv2.resize(img, size)
vid.write(img)
vid.release()
return vid
“””
Sample Usage:

img_path = “C:\\Users\\kapiv\\Documents\\CECS 229\\CA #5\\faces\\”
vid_path = “C:\\Users\\kapiv\\Documents\\CECS 229\\CA #5\\male_faces.avi”

images = []  # Initializing empty list of image paths
for i in range(15):  # adding images male00.png – male14.png to the list
if i < 10:
file = f”{img_path}male0{i}.png”
else:
file = f”{img_path}male{i}.png”