def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width
height = images[0].height
photo_number = len(images)
pixels = []
result = SimpleImage.blank(width, height)
for i in range(height):
for j in range(width):
for k in range(photo_number):
get_pixel = images[k].get_pixel(j, i)
pixels.append(get_pixel)
best = get_best_pixel(pixels)
result_get = result.get_pixel(j, i)
result_get.red = best.red
result_get.green = best.green
result_get.blue = best.blue
pixels = []
######## YOUR CODE STARTS HERE #########
# Write code to populate image and create the 'ghost' effect
image_blank = SimpleImage.blank(width, height)
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def crop_image(filename, n):
"""
Takes the left half of image, and copies it on top of the right half.
"""
image = SimpleImage(filename)
width = image.width
new_width = width - (2 * n)
height = image.height
new_height = height - (2 * n)
image_crop_width = SimpleImage.blank(new_width, height)
for y in range(height):
for x in range(new_width):
pixel = image.get_pixel((x + n), y)
image_crop_width.set_pixel(x, y, pixel)
image_crop_width.show()
image_crop_height = SimpleImage.blank(width, new_height)
for y in range(new_height):
for x in range(width):
pixel = image.get_pixel(x, y + n)
image_crop_height.set_pixel(x, y, pixel)
image_crop_height.show()
image_crop_width_height = SimpleImage.blank(new_width, new_height)
for y in range(new_height):
for x in range(new_width):
pixel = image.get_pixel(x + n, y + n)
image_crop_width_height.set_pixel(x, y, pixel)
image_crop_width_height.show()
def trim_crop_image(original_img, trime_size):
"""
This function returns a new SimpleImage which is a trimmed and
cropped version of the original image by shaving trime_size pixels
from each side (top, left, bottom, right) of the image. You may
assume trime_size is less than half the width of the image.
Inputs:
- original_img: The original image to process
- trime_size: The number of pixels to shave from each side
of the original image
Returns:
A new SimpleImage with trime_size pixels shaved off each
side of the original image
"""
new_width = original_img.width - 2 * trime_size
new_height = original_img.height - 2 * trime_size
new_img = SimpleImage.blank(new_width, new_height)
for x in range(new_width):
for y in range(new_height):
old_x = x + trime_size
old_y = y + trime_size
orig_pixel = original_img.get_pixel(old_x, old_y)
new_img.set_pixel(x, y, orig_pixel)
return new_img
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height)
######## YOUR CODE STARTS HERE #########
# Write code to populate image and create the 'ghost' effect
for x in range(width):
for y in range(height):
pixels = []
for image in images:
pixels.append(image.get_pixel(x, y))
best = get_best_pixel(pixels)
result_pixel = result.get_pixel(x, y)
result_pixel.red = best.red
result_pixel.green = best.green
result_pixel.blue = best.blue
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def reflect(filename):
"""
This function uses the original image to create a reflected image.
:param filename: str, the file path of the original image
:return: a new image with the original image and the mirrored one
"""
img = SimpleImage(filename)
img_new = SimpleImage.blank(img.width, img.height * 2)
for y in range(img.height):
for x in range(img.width):
pixel_img = img.get_pixel(x, y)
# divide the new blank canvas into two parts
pixel_new1 = img_new.get_pixel(x, y)
pixel_new2 = img_new.get_pixel(x, img_new.height - y - 1)
# fill the first empty pixel(upper part)
pixel_new1.red = pixel_img.red
pixel_new1.green = pixel_img.green
pixel_new1.blue = pixel_img.blue
# fill the second empty pixel(mirrored part)
pixel_new2.red = pixel_img.red
pixel_new2.green = pixel_img.green
pixel_new2.blue = pixel_img.blue
return img_new
def blur(old_img):
"""
:param old_img: SimpleImage, the original image
:return: new_img: SimpleImage, the image after blur
"""
old_img = SimpleImage("images/smiley-face.png")
# blank image for blurred
new_img = SimpleImage.blank(old_img.width, old_img.height)
for x in range(old_img.width):
for y in range(old_img.height):
# initiate with 0
r_sum = 0
g_sum = 0
b_sum = 0
count = 0
# find pixel of x-1, x, x+1 and y-1, y, y+1 and add it with the neighbors
for i in range(-1, 2, 1):
for j in range(-1, 2, 1):
pixel_x = x + i
pixel_y = y + j
if 0 <= pixel_x < old_img.width:
if 0 <= pixel_y < old_img.height:
pixel = old_img.get_pixel(pixel_x, pixel_y)
r_sum += pixel.red
g_sum += pixel.green
b_sum += pixel.blue
# count the number of neighbors
count += 1
new_pixel = new_img.get_pixel(x, y)
new_pixel.red = r_sum / count
new_pixel.green = g_sum / count
new_pixel.blue = b_sum / count
return new_img
def blur(img):
"""
:param img: str
:return: SimpleImage
This function will blur the image by make pixels RGB value to the average value with nearby pixels.
1. Create blank image
2. loop the pixels original image
3. loop the nearby pixels RGB value
4. if the nearby pixel in the range of the picture, include into calculation.
"""
img = img
new_img = SimpleImage.blank(img.width, img.height)
for x in range(img.width):
for y in range(img.height):
red = 0
green = 0
blue = 0
num = 0
for i in range(x - 1, x + 2):
for j in range(y - 1, y + 2):
if img.width > i >= 0 and img.height > j >= 0:
pixel_img = img.get_pixel(i, j)
red += pixel_img.red
green += pixel_img.green
blue += pixel_img.blue
num += 1
pixel_new = new_img.get_pixel(x, y)
pixel_new.red = red // num
pixel_new.green = green // num
pixel_new.blue = blue // num
return new_img
def add_border(original_img, border_size):
"""
This function returns a new SimpleImage which is the same as
original image except with a black border added around it. The
border should be border_size many pixels thick.
Inputs:
- original_img: The original image to process
- border_size: The thickness of the border to add around the image
Returns:
A new SimpleImage with the border added around original image
"""
# add twice the border size since we will have a border on both sides
new_width = original_img.width + 2*border_size
new_height = original_img.height + 2*border_size
# gives us a blank image of size new_width and new_height
bordered_img = SimpleImage.blank(new_width, new_height)
for x in range(bordered_img.width):
for y in range(bordered_img.height):
if is_border_pixel(x, y, border_size, bordered_img):
pixel = bordered_img.get_pixel(x, y)
pixel.red = 0
pixel.green = 0
pixel.blue = 0
else:
# need to set pixel originally at (x,y) to shifted new position
orig_x = x - border_size
orig_y = y - border_size
orig_pixel = original_img.get_pixel(orig_x, orig_y)
bordered_img.set_pixel(x, y, orig_pixel)
return bordered_img
def reflect(filename):
"""
:param filename: str, the file path of the original image
:return:SimpleImage, image generated by a mirror-reversal of an original across a horizontal axis
"""
img = SimpleImage('images/mt-rainier.jpg')
# Make an empty canvas
blank_img = SimpleImage.blank(img.width, img.height*2)
for y in range(img.height):
for x in range(img.width): # it has pixel data!
img_pixel = img.get_pixel(x, y)
# empty spot 1
blank_p1 = blank_img.get_pixel(x, y)
# empty spot 2
blank_p2 = blank_img.get_pixel(x, blank_img.height-1-y)
# coloring
blank_p1.red = img_pixel.red
blank_p1.blue = img_pixel.blue
blank_p1.green = img_pixel.green
# coloring
blank_p2.red = img_pixel.red
blank_p2.blue = img_pixel.blue
blank_p2.green = img_pixel.green
return blank_img
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height)
######## YOUR CODE STARTS HERE #########
pixel_lst = []
for i in range(width):
for j in range(height):
for image in images:
pixel = image.get_pixel(i, j)
pixel_lst.append(pixel)
pixel = get_best_pixel(pixel_lst)
pixel_result = result.get_pixel(i, j)
pixel_result.red = pixel.red
pixel_result.green = pixel.green
pixel_result.blue = pixel.blue
pixel_lst = []
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def blur(img):
"""
Using pixel coordinates to get the pixel and its neighbors for average of rgb and then get blurred.
:param img: SimpleImage, the image object which will be blurred.
:return: SimpleImage, the image which were all blurred.
"""
new_img = SimpleImage.blank(img.width, img.height)
for x in range(new_img.width):
for y in range(new_img.height):
sum_red = 0
sum_green = 0
sum_blue = 0
neighbor_pixels_num = 0
new_img_p = new_img.get_pixel(x, y)
for i in range(3):
for j in range(3):
if 0 <= x + (i-1) < img.width and 0 <= y + (j-1) < img.height:
neighbor_pixels_num += 1
sum_red += img.get_pixel(x + (i-1), y + (j-1)).red
sum_green += img.get_pixel(x + (i-1), y + (j-1)).green
sum_blue += img.get_pixel(x + (i-1), y + (j-1)).blue
new_img_p.red = sum_red // neighbor_pixels_num
new_img_p.green = sum_green // neighbor_pixels_num
new_img_p.blue = sum_blue // neighbor_pixels_num
return new_img
def triplicate(filename):
image = SimpleImage(filename)
new = SimpleImage.blank(image.width * 3, image.height)
for y in range(image.height):
for x in range(image.width):
old = image.get_pixel(x, y)
# left image
left = new.get_pixel(x, image.height - 1 - y)
left.red = old.red
left.green = old.green
left.blue = old.blue
# middle image
middle = new.get_pixel(x + image.width, y)
middle.red = old.red
middle.green = old.green
middle.blue = old.blue
# right image
right = new.get_pixel(image.width - 1 - x, y)
right.red = old.red
right.green = old.green
right.blue = old.blue
pass
def trim_crop_image(original_img, trim_size):
"""
This function returns a new SimpleImage which is a trimmed and
cropped version of the original image by shaving trim_sz pixels
from each side (top, left, bottom, right) of the image. You may
assume trim_sz is less than half the width of the image.
Inputs:
- original_img: The original image to process
- trim_size: The number of pixels to shave from each side
of the original image
Returns:
A new SimpleImage with trim_sz pixels shaved off each
side of the original image
"""
nudimx = original_img.width - 2 * trim_size
nudimy = original_img.height - 2 * trim_size
new = SimpleImage.blank(nudimx, nudimy)
for y in range(new.height):
for x in range(new.width):
newx = x + trim_size - 1
newy = y + trim_size - 1
new.set_pixel(x, y, original_img.get_pixel(newx, newy))
return new
def add_border(original_img, border_size):
"""
This function returns a new SimpleImage which is the same as
original image except with a black border added around it. The
border should be border_size many pixels thick.
Inputs:
- original_img: The original image to process
- border_size: The thickness of the border to add around the image
Returns:
A new SimpleImage with the border added around original image
"""
# TODO: your code here
new_width = original_img.width + 2 * border_size
new_height = original_img.height + 2 * border_size
new_image = SimpleImage.blank(new_width, new_height)
for x in range(new_image.width):
for y in range(new_image.height):
if is_border_pixel(x, y, border_size, new_image):
pixel = new_image.get_pixel(x, y)
pixel.red = 0
pixel.blue = 0
pixel.green = 0
else:
old_x = x - border_size
old_y = y - border_size
old_pixel = original_img.get_pixel(old_x, old_y)
new_image.set_pixel(x, y, old_pixel)
return new_image
def get_blur_color(x, y):
"""
This function calculate the Red, Green, and Blue from each
point. Then, assign the blur color to (x,y).
--------------------------------------------------
:param x: int, the column of each spot.
:param y: int, the row of each spot.
:return: new_pixel: the R, G, and B of that point pixel.
"""
img = SimpleImage("images/smiley-face.png")
new_img = SimpleImage.blank(img.width, img.height)
new_pixel = new_img.get_pixel(x, y)
start_x = 0
start_y = 0
end_x = 0
end_y = 0
if x == 0:
start_x = 0
end_x = x + 2
start_y = 0
end_y = y + 2
elif x == img.width - 1:
start_x = x - 1
end_x = x + 1
else:
start_x = x - 1
end_x = x + 2
if y == 0:
start_y = 0
end_y = y + 2
elif y == img.height - 1:
start_y = y - 1
end_y = y + 1
else:
start_y = y - 1
end_y = y + 2
total_r = 0
total_g = 0
total_b = 0
counts = 0
for y in range(start_y, end_y):
for x in range(start_x, end_x):
pixel = img.get_pixel(x, y)
total_r += pixel.red
total_g += pixel.green
total_b += pixel.blue
counts += 1
print('total r g b', total_r, total_g, total_b) # make sure the algorithm is running
new_r = total_r / counts
new_g = total_g / counts
new_b = total_b / counts
new_pixel.red = new_r
new_pixel.green = new_g
new_pixel.blue = new_b
return new_pixel
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height)
######## YOUR CODE STARTS HERE #########
# Write code to populate image and create the 'ghost' effect
# The first two for-loops (used with indexes i and j) are used for filling up blank image with the best pixels
# The third loop (for-each loop) is used for create the RGB list of original images
for i in range(width):
for j in range(height):
images_pixel = []
for image in images:
red = image.get_pixel(i, j).red
green = image.get_pixel(i, j).green
blue = image.get_pixel(i, j).blue
images_pixel.append([red, green, blue])
best_pixel = get_best_pixel(images_pixel)
result.get_pixel(i, j).red = best_pixel[0]
result.get_pixel(i, j).green = best_pixel[1]
result.get_pixel(i, j).blue = best_pixel[2]
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
print(1)
pixels = []
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height)
######## YOUR CODE STARTS HERE #########
# Write code to populate image and create the 'ghost' effect
for x in range(width): # x
for y in range(height): # y
for img in images: # the pictures pixel
pix = img.get_pixel(x, y)
pixels.append(pix) # add the pixel in pixels
best = get_best_pixel(pixels) # choose the best pixel of all
pixel = result.get_pixel(x, y)
pixel.red = best.red
pixel.green = best.green
pixel.blue = best.blue
pixels = [] # clear up pixels
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height)
######## YOUR CODE STARTS HERE #########
# Write code to populate image and create the 'ghost' effect
for i in range(width):
for j in range(height):
pixels = []
for k in range(len(images)):
pixels += [images[k].get_pixel(i, j)]
best_pixel = get_best_pixel(pixels)
img = pixels.index(best_pixel)
result.get_pixel(i, j).red = images[img].get_pixel(i, j).red
result.get_pixel(i, j).green = images[img].get_pixel(i, j).green
result.get_pixel(i, j).blue = images[img].get_pixel(i, j).blue
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def copy_image(image): # Creates a copy of the image
copy = SimpleImage.blank(image.width, image.height)
for pixel in copy:
x = pixel.x
y = pixel.y
copy.set_pixel(x, y, image.get_pixel(x, y))
return copy
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height) # create a blank canvas
# Write code to populate image and create the 'ghost' effect
for x in range(result.width):
for y in range(result.height):
pixel_lst = [] # create a blank list to store pixel
for image in images: # for each every image in folder
pixel = image.get_pixel(x, y)
pixel_lst.append(pixel)
best_pixel = get_best_pixel(pixel_lst) # find the best pixel from all images
# assign the best rgb to blank canvas
result.get_pixel(x, y).red = best_pixel.red
result.get_pixel(x, y).green = best_pixel.green
result.get_pixel(x, y).blue = best_pixel.blue
print("Displaying image!")
result.show()
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height)
######## YOUR CODE STARTS HERE #########
# compare different photo at same position
for x in range(width):
for y in range(height):
pixels = [] # a list for load the the pixel at same position
for image in images:
same_position_pixel = image.get_pixel(x, y)
pixels.append(same_position_pixel)
best_pixel = get_best_pixel(pixels) # choose the best pixel
result_pixel = result.get_pixel(
x, y) # fill the best pixel into the result
result_pixel.red = best_pixel.red
result_pixel.green = best_pixel.green
result_pixel.blue = best_pixel.blue
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height)
######## YOUR CODE STARTS HERE #########
# get a pixel in the result image
for x in range(result.width):
for y in range(result.height):
pixels = []
result_pixel = result.get_pixel(x, y)
# create pixels in every image for the specific pixel
for image in images:
pixels.append(image.get_pixel(x, y))
# create colors of the result pixel
result_pixel.red = get_best_pixel(pixels).red
result_pixel.green = get_best_pixel(pixels).green
result_pixel.blue = get_best_pixel(pixels).blue
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def blur(img):
"""
:param img:
:return: new(blurred) img
"""
#create new image
new_img = SimpleImage.blank(img.width, img.height)
sum_red, sum_green, sum_blue, count = 0, 0, 0, 0
# frame = 3 x 3, [[x_left_bnd, x_right_bnd], [y_low_bnd, y_up_bnd]]
frame = [[-1, 2], [-1, 2]]
for x in range(img.width):
for y in range(img.height):
for frame_x in range(frame[0][0], frame[0][1]):
for frame_y in range(frame[1][0], frame[1][1]):
if (img.width > x + frame_x >= 0) & (img.height >
y + frame_y >= 0):
# get old img pixel
img_pixel = img.get_pixel(x + frame_x, y + frame_y)
# calculate RGB sum
sum_red += img_pixel.red
sum_green += img_pixel.green
sum_blue += img_pixel.blue
count += 1
# average RGB and assign to new image
new_img.set_rgb(x, y, sum_red // count, sum_green // count,
sum_blue // count)
# reset RGB sum and count
sum_red, sum_green, sum_blue, count = 0, 0, 0, 0
return new_img
def reflect(filename):
"""
This function will create a reflected image in a vertical way
-----------------------------------------------------------
:param filename: str, the name of the file
:return: SimpleImage, the reflected image
"""
img = SimpleImage(filename)
new_img = SimpleImage.blank(img.width, img.height * 2)
for x in range(img.width):
for y in range(img.height):
img_pixel = img.get_pixel(x, y)
# The colored pixel of the original image
new_img_pixel1 = new_img.get_pixel(x, y)
# The blanked pixel of the new image counted from the top
new_img_pixel2 = new_img.get_pixel(x, new_img.height - 1 - y)
# The blanked pixel of the new image counted from the bottom
new_img_pixel1.red = img_pixel.red
new_img_pixel1.green = img_pixel.green
new_img_pixel1.blue = img_pixel.blue
new_img_pixel2.red = img_pixel.red
new_img_pixel2.green = img_pixel.green
new_img_pixel2.blue = img_pixel.blue
return new_img
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height)
######## YOUR CODE STARTS HERE #########
# Write code to populate image and create the 'ghost' effect
pixel_lst = []
for j in range(width):
for k in range(height):
# This double for loop is here to address every pixel of the process picture
for i in range(len(images)):
# This for loop is here to address the number of pictures the user feeds in
pixel_lst.append(images[i].get_pixel(j, k))
# This line takes the same pixel from each feeded-in picture and puts it into the list
best_pixel = get_best_pixel(pixel_lst)
result_pixel = result.get_pixel(j, k)
result_pixel.red = best_pixel.red
result_pixel.green = best_pixel.green
result_pixel.blue = best_pixel.blue
pixel_lst = []
# This line resets the list to continue for next pixel
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height)
######## YOUR CODE STARTS HERE #########
for x in range(result.width):
for y in range(result.height):
result_pixel = result.get_pixel(x, y)
# Take out the pixels of the same position (x,y) in different pictures to list.
pixels = []
for z in range(len(images)):
pic = images[z]
pic_pixel = pic.get_pixel(x, y)
pixels.append(pic_pixel)
best_pixel = get_best_pixel(pixels)
result_pixel.red = best_pixel.red
result_pixel.green = best_pixel.green
result_pixel.blue = best_pixel.blue
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height)
######## YOUR CODE STARTS HERE #########
# Write code to populate image and create the 'ghost' effect
# green_pixel = SimpleImage.blank(20, 20, 'green').get_pixel(0, 0)
# red_pixel = SimpleImage.blank(20, 20, 'red').get_pixel(0, 0)
# blue_pixel = SimpleImage.blank(20, 20, 'blue').get_pixel(0, 0)
# best1 = get_best_pixel([green_pixel, blue_pixel, blue_pixel])
# print(best1.red, best1.green, best1.blue)
for x in range(width):
for y in range(height):
pixel_lst = []
for i in range(len(images)):
image = images[i]
pixel = image.get_pixel(x, y)
pixel_lst.append(pixel)
best_pixel = get_best_pixel(pixel_lst)
result_pixel = result.get_pixel(x, y)
result_pixel.red = best_pixel.red
result_pixel.green = best_pixel.green
result_pixel.blue = best_pixel.blue
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def reflect(filename):
"""
:param filename: str, the file path of the original image.
:return: mirror lake picture.
"""
img = SimpleImage(filename)
blank_img = SimpleImage.blank(img.width, img.height * 2)
for y in range(img.height):
for x in range(img.width):
# data
img_pixel = img.get_pixel(x, y)
# Empty pixel1
new_pixel1 = blank_img.get_pixel(x, y)
# create pixel 2
new_pixel2 = blank_img.get_pixel(x, blank_img.height - 1 - y)
new_pixel1.red = img_pixel.red
new_pixel1.green = img_pixel.green
new_pixel1.blue = img_pixel.blue
new_pixel2.red = img_pixel.red
new_pixel2.green = img_pixel.green
new_pixel2.blue = img_pixel.blue
return blank_img
def solve(images):
"""
Given a list of image objects, compute and display a Ghost solution image
based on these images. There will be at least 3 images and they will all
be the same size.
Input:
images (List[SimpleImage]): list of images to be processed
"""
width = images[0].width # hoover's width
height = images[0].height # hoover's height
result = SimpleImage.blank(width, height)
######## YOUR CODE STARTS HERE #########
# Write code to populate image and create the 'ghost' effect
print(len(images))
for x in range(width):
for y in range(height):
new_pixel = result.get_pixel(x, y)
pixel_list = []
for z in range(len(images)): # Element of list of images is image, but not pixel!!
img = images[z]
pixel_list.append(img.get_pixel(x,y)) # Make a list for using method- get_best_pixel and get_average
best_pixel = get_best_pixel(pixel_list)
new_pixel.red = best_pixel.red
new_pixel.green = best_pixel.green
new_pixel.blue = best_pixel.blue
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def shrink(figure_img):
# shrink the photo with green background
small_img = SimpleImage.blank(figure_img.width // 2,
figure_img.height // 2)
if figure_img.width % 2 == 1 or figure_img.height % 2 == 1:
for x in range(0, figure_img.width - 1, 2):
for y in range(0, figure_img.height - 1, 2):
pixel_1 = figure_img.get_pixel(x, y)
pixel_2 = figure_img.get_pixel(x + 1, y)
pixel_3 = figure_img.get_pixel(x, y + 1)
pixel_4 = figure_img.get_pixel(x + 1, y + 1)
small_pixel = small_img.get_pixel(x // 2, y // 2)
small_pixel.red = (pixel_1.red + pixel_2.red + pixel_3.red +
pixel_4.red) // 4
small_pixel.green = (pixel_1.green + pixel_2.green +
pixel_3.green + pixel_4.green) // 4
small_pixel.blue = (pixel_1.blue + pixel_2.blue +
pixel_3.blue + pixel_4.blue) // 4
else:
for x in range(0, figure_img.width, 2):
for y in range(0, figure_img.height, 2):
pixel_1 = figure_img.get_pixel(x, y)
pixel_2 = figure_img.get_pixel(x + 1, y)
pixel_3 = figure_img.get_pixel(x, y + 1)
pixel_4 = figure_img.get_pixel(x + 1, y + 1)
small_pixel = small_img.get_pixel(x // 2, y // 2)
small_pixel.red = (pixel_1.red + pixel_2.red + pixel_3.red +
pixel_4.red) // 4
small_pixel.green = (pixel_1.green + pixel_2.green +
pixel_3.green + pixel_4.green) // 4
small_pixel.blue = (pixel_1.blue + pixel_2.blue +
pixel_3.blue + pixel_4.blue) // 4
return small_img
