def create_ghost(image1, image2, image3):
"""
Given three image objects, this function creates and returns a Ghost
solution image based on the images passed in. All the images passed
in will be the same size.
Input:
three images to be processed
Returns:
a new Ghost solution image
"""
# Your code goes here
ghost = SimpleImage.blank(image1.width, image1.height)
for x in range(ghost.width):
for y in range(ghost.height):
pixel1 = image1.get_pixel(x, y)
pixel2 = image2.get_pixel(x, y)
pixel3 = image3.get_pixel(x, y)
ghost.set_pixel(x, y, get_best_pixel(pixel1, pixel2, pixel3))
return ghost
def find_flames(filename):
"""
This function should highlight the "sufficiently red" pixels
in the image and grayscale all other pixels in the image
in order to highlight areas of wildfires.
"""
image = SimpleImage(filename)
for pixel in image:
avg = (pixel.red + pixel.green + pixel.blue) / 3
if avg < pixel.red:
pixel.red = 255
pixel.green = 0
pixel.blue = 0
else:
pixel.red = avg
pixel.green = avg
pixel.blue = avg
return image
def make_warhol():
image = SimpleImage.blank(1302, 860)
first_line = [
green_scale(),
orange_scale(),
purple_scale(),
red_scale(),
yellow_scale(),
brown_scale()
]
# return fill_background(first_line, secound_line, image)
for index, doimage in enumerate(first_line):
for pixel in doimage:
image.set_pixel(pixel.x + place_element(index).x,
pixel.y + place_element(index).y, pixel)
index = index + 1
return image
def find_flames(filename):
"""
This function should highlight the "sufficiently red" pixels
in the image and grayscale all other pixels in the image
in order to highlight areas of wildfires.
"""
image = SimpleImage(filename)
for pixel in image:
average = (pixel.red + pixel.blue + pixel.green) // 3
# Here I will apply this avera to the image | I am not sure, helpp!!! Lets see
if pixel.red >= average * INTENSITY_THRESHOLD:
pixel.red = 255
pixel.blue = 0
pixel.green = 0
else:
# convert to grayscale = average
pixel.red = average
pixel.blue = average
pixel.green = average
return image
def find_flames(filename):
"""
This function should highlight the "sufficiently red" pixels
in the image and grayscale all other pixels in the image
in order to highlight areas of wildfires.
"""
image = SimpleImage(filename)
# TODO: your code here
for pixel in image:
avg = find_average(pixel.red, pixel.green, pixel.blue)
if (pixel.red >= avg):
pixel.red = 255
pixel.green = 0
pixel.blue = 0
else:
pixel.red = avg
pixel.green = avg
pixel.blue = avg
return image
def main():
# DO NOT MODIFY
# args = sys.argv[1:]
#
# if len(args) != 1:
# print('Please specify directory of images on command line')
# return
#
# # We just take 1 argument, the folder containing all the images.
# # The load_images() capability is provided above.
# images = load_images(args[0])
# result = create_ghost(images)
# if result:
# print("Displaying image!")
# result.show()
# else:
# print("No image to display!")
green_im = SimpleImage.blank(20, 20, 'green')
green_pixel = green_im.get_pixel(0, 0)
return get_pixel_dist(green_pixel, 0, 255, 255)
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_im = SimpleImage.blank(20, 20, 'green')
# green_pixel = green_im.get_pixel(0, 0)
# print(get_pixel_dist(green_pixel, 5, 255, 10))
# 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)
# # print(get_average([green_pixel, green_pixel, green_pixel, blue_pixel]))
# best1 = get_best_pixel([green_pixel, blue_pixel, blue_pixel])
# print(best1.red, best1.green, best1.blue)
######## YOUR CODE ENDS HERE ###########
for x in range(width):
for y in range(height):
pixels = [] # 選定座標後，打開每張圖取他的特定座標x,y
for image in images: # 打開每個image
pixel = image.get_pixel(x, y)
result_pixel = result.get_pixel(x, y)
pixels.append(pixel) # 把pixel放到list裡面
best = get_best_pixel(pixels) # 得到最好的pixel
result_pixel.red = best.red # 把最好的pixel送給result
result_pixel.green = best.green
result_pixel.blue = best.blue
print("Displaying image!")
result.show()
def main():
# Get file and load image
filename = get_file()
image = SimpleImage(filename)
# Show the image before the transform
image.show()
for pixel in image:
pixel.red *= 1.5
pixel.green *= 0.7
pixel.blue *= 1.5
# Show the image after the transform
image.show()
def main():
# Get file and load image
filename = get_file()
image = SimpleImage(filename)
# Show the image before the transform
image.show()
# Apply the filter
#convert the file
for pixel in image:
cool_filter(pixel)
# Show the image after the transform
image.show()
def main():
# Get file and load image
filename = get_file()
image = SimpleImage(filename)
# Show the image before the transform
image.show()
# Apply the filter
# TODO: your code here!
for pixel in image:
pixel.red = random.randint(0, 255)
# Show the image after the transform
image.show()
def blur(img):
"""
First, this function create the blank image.
Second, it will get the blur color in each point from old image.
Third, it will assign the blur color to the blank image.
--------------------------------------------------
:param img: SimpleImage, the original image.
:return: new_img: SimpleImage, blur image.
"""
new_img = SimpleImage.blank(img.width, img.height)
for r in range(img.height):
for c in range(img.width):
pixel = img.get_pixel(c, r)
pixel_blur = new_img.get_pixel(c, r)
new_pixel = get_blur_color(c, r)
pixel_blur.red = new_pixel.red
pixel_blur.green = new_pixel.green
pixel_blur.blue = new_pixel.blue
return new_img
def find_flames(filename):
"""
This function should highlight the "sufficiently red" pixels
in the image and grayscale all other pixels in the image
in order to highlight areas of wildfires.
"""
image = SimpleImage(filename)
for pixel in image:
average = (pixel.red + pixel.green + pixel.blue) // 3
# See if this pixel is "sufficiently" red
if pixel.red >= average * INTENSITY_THRESHOLD:
pixel.red = 255
pixel.green = 0
pixel.blue = 0
else:
pixel.red = average
pixel.green = average
pixel.blue = average
return image
def highlight_fires(filename):
"""
:param img: The image of the greenland, to be detected whether on fire.
:return: str, 'img', (the modified image),
mark the fire area as red;
turn the rest of area into grayscale.
"""
img = SimpleImage(filename)
for pixel in img:
avg = (pixel.red + pixel.green + pixel.blue) / 3
if pixel.red > avg * HURDLE_FACTOR:
# If pixel.red over the hurdle, then turn pixel.red into red to alert!
pixel.red = 255
pixel.green = 0
pixel.blue = 0
else:
# Grayscale
pixel.red = avg
pixel.green = avg
pixel.blue = avg
return img
def main(): # {by: Charlie}
# (1) load image–part of main
image = SimpleImage(DEFAULT_FILE)
# (2) get user’s choice of kernel
choice = user_choice()
# (3) get the kernel array
kernel = create_kernel(choice)
# (4) change image to grayscale
make_grayscale(image)
# (5) add 1px border to image
image = add_border(image, 1)
# (6) process the bordered image using the kernel
final_image = process_image(image, kernel)
# (7) show results
final_image.show()
def find_flames(filename):
"""
This function should highlight the "sufficiently red" pixels
in the image and grayscale all other pixels in the image
in order to highlight areas of wildfires.
"""
image = SimpleImage(filename)
# TODO: your code here
for pixel in image:
if pixel.red > ((pixel.red + pixel.green + pixel.blue) / 3):
pixel.red = 255
pixel.blue = 0
pixel.green = 0
average = ((pixel.red + pixel.green + pixel.blue) / 3)
# r = pixel.red
# b = pixel.blue
# g = pixel.green
#pixel.red = average
pixel.blue = average
pixel.green = average
return image
def highlight_fires(filename):
"""
Remove all the green and blue color from the photo and
assign 255 to pixel.red in order to enhance the big fire spot.
-----------------------------------------------------------------
:param filename: str, the file path of the image
:return: img : SimpleImage, the image of red spot with big fire and the gray scale with no fire
"""
img = SimpleImage('images/greenland-fire.png')
for pixel in img:
avg = (pixel.red + pixel.green + pixel.blue) // 3
if pixel.red > avg * HURDLE_FACTOR:
pixel.red = 255
pixel.green = 0
pixel.blue = 0
else:
pixel.red = avg
pixel.green = avg
pixel.blue = avg
return img
def highlight_fires(filename):
"""
This function will scan through every pixel of the image and detects the pixels that are recognized as fire.
Finally, the function will label them in red.
:param filename: The directory of an image you want to process.
:return: SimpleImage, parts of the image are labeled by red and other parts are in gray scale.
"""
img = SimpleImage(filename)
for pixel in img:
avg = (pixel.red + pixel.green + pixel.blue) // 3
# Highlight places that are on fire.
if pixel.red > avg * HURDLE_FACTOR:
pixel.red = 255
pixel.green = 0
pixel.blue = 0
# Gray scale for other parts.
else:
pixel.red = avg
pixel.green = avg
pixel.blue = avg
return img
def highlight_fires(filename):
"""
:param filename: str, picture filename
:return: SimpleImage
loop through every pixel in the picture
find out the average of value of RGB in each pixel.
use a if/ else statement to determine which pixel will turn full red and gray scale.
"""
img = SimpleImage(filename)
for pixel in img:
avg = (pixel.red + pixel.green + pixel.blue) // 3
if pixel.red > avg * HURDLE_FACTOR:
pixel.red = 255
pixel.green = 0
pixel.blue = 0
else:
pixel.red = avg
pixel.green = avg
pixel.blue = avg
return img
def highlight_fires(filename):
"""
This function will highlight the fire in the image with red
and turn the rest of it into gray
-----------------------------------------------------------
:param filename: str, the name of the file
:return: SimpleImage, the image of highlighted fires
"""
highlighted_img = SimpleImage(filename)
for pixel in highlighted_img:
avg = (pixel.red + pixel.green + pixel.blue) // 3
if pixel.red > avg * HURDLE_FACTOR:
pixel.red = 255
pixel.green = 0
pixel.blue = 0
else:
pixel.red = avg
pixel.green = avg
pixel.blue = avg
# The pixel will become gray
return highlighted_img
def find_flames(filename):
"""
This function should highlight the "sufficiently red" pixels
in the image and grayscale all other pixels in the image
in order to highlight areas of wildfires.
"""
image = SimpleImage(filename)
# precondition: regular image, no fires highlighted
# postcondition: grayscale image with red where fires are
# first - check for red enough pixels that could indicate fires
for pixel in image:
avg = get_average(pixel) # See if this pixel is "sufficiently" red
if pixel.red >= avg: # If so,set the red enough pixels to red = 255, then green and blue to 0
pixel.red = 255
pixel.green = 0
pixel.blue = 0
else: # all over pixel set to grayscale
pixel.red = avg
pixel.green = avg
pixel.blue = avg
return image
def redscreen(mainfile, background):
# takes out image
image = SimpleImage(mainfile)
# takes out background image to be put into the main image above
back = SimpleImage(background)
# for seeing each pixel in the image
for pixel in image:
# taking out the average of all the pixels
average = (pixel.red + pixel.green + pixel.blue) // 3
# is your green pixel more greener than the avg intensity
if pixel.red >= average * INTENSITY_THRESHOLD:
# if so then overwrite the pixel in the original image
# corresponding pixel from the background image
x = pixel.x
y = pixel.y
# set background image in those specific pixels which
# are greener than average and replace them
image.set_pixel(x, y, back.get_pixel(x, y))
return image
def main():
"""
Run your desired photoshop functions here.
You should save the return value of the image and then
call .show() to visualize the output of your program.
"""
# original_poppy = SimpleImage('images/poppy.png')
# original_poppy.show()
#
# red_poppy = red_channel('images/poppy.png')
# red_poppy.show()
#
# dark_poppy = darker('images/poppy.png')
# dark_poppy.show()
#
# original_dandelion = SimpleImage('images/dandelion.png')
# original_dandelion.show()
#
# dark_half_dandelion = right_half('images/dandelion.png')
# dark_half_dandelion.show()
#
# dark_quarter_dandelion = right_quarter('images/dandelion.png')
# dark_quarter_dandelion.show()
#
# gray_dandelion = grayscale('images/dandelion.png')
# gray_dandelion.show()
#
# original_curb = SimpleImage('images/curb.png')
# original_curb.show()
#
# new_curb = curb_repair('images/curb.png')
# new_curb.show()
#
original_stop = SimpleImage('images/stop.png')
original_stop.show()
original_leaves = SimpleImage('images/leaves.png')
original_leaves.show()
def solve_mystery(filename):
"""Solve the mystery as described in the handout."""
# SimpleImage boilerplate provided as a starting point
nums_in_list = parse_file(filename)
width = nums_in_list[0] # correct values needed here
height = nums_in_list[1]
image = SimpleImage.blank(width, height)
num_pixel = 0
for y in range(image.height):
for x in range(image.width):
pixel = image.get_pixel(x, y)
# manipulate pixel in here
pixel.red = nums_in_list[num_pixel + 2]
pixel.blue = nums_in_list[num_pixel + 2]
pixel.green = nums_in_list[num_pixel + 2]
num_pixel += 1
# This displays image on screen
image.show()
def find_flames(filename):
"""
This function should highlight the "sufficiently red" pixels
in the image and grayscale all other pixels in the image
in order to highlight areas of wildfires.
"""
image = SimpleImage(filename)
for pixel in image:
red = pixel.red
blue = pixel.blue
green = pixel.green
average = (red + blue + green) / 3
if average > red:
pixel.blue = average
pixel.green = average
pixel.red = average
else:
pixel.red = RED_ADJUST
pixel.blue = BLUE_ADJUST
pixel.green = GREEN_ADJUST
return image
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
"""
start = time.time()
width = images[0].width
height = images[0].height
result = SimpleImage.blank(width, height)
# Scan through all pixels.
for x in range(width):
for y in range(height):
# Create a list of pixels for the function 'get_best_pixel'.
pixels = []
for image in images:
pixels.append(image.get_pixel(x, y))
# Best pixel of a certain pixel in the image.
best = get_best_pixel(pixels)
# Each pixel of the result image is set as best
result.set_pixel(x, y, best)
end = time.time()
print(end - start)
# Method 2 #
# for x in range(width):
# for y in range(height):
# pixels = []
# result_pix = result.get_pixel(x, y)
# for image in images:
# pixels.append(image.get_pixel(x, y))
# best = get_best_pixel(pixels)
# result_pix.red = best.red
# result_pix.green = best.green
# result_pix.blue = best.blue
# End Method 2 #
print("Displaying image!")
result.show()
def main():
# Get file and load image
filename = get_file()
image = SimpleImage(filename)
new_image = SimpleImage.blank(900, 559)
# Show the image before the transform
image.show()
for y in range(image.height):
for x in range(image.width):
pixel = image.get_pixel(x, y)
pixel.red = pixel.red * 1.5
pixel.green = pixel.green * 0.7
pixel.blue = pixel.blue * 1.5
new_image.set_pixel(x, y, pixel)
new_image.show()
def main():
# Get file and load image
filename = get_file()
image = SimpleImage(filename)
# Show the image before the transform
image.show()
# Apply the filter
for px in image:
px.red *= 1.5
px.green *= 0.7
px.blue *= 1.5
# Show the image after the transform
image.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 x in range(result.width):
for y in range(result.height):
pixel = get_best_pixel([
images[0].get_pixel(x, y), images[1].get_pixel(x, y),
images[2].get_pixel(x, y), images[3].get_pixel(x, y)
])
result.set_pixel(x, y, pixel)
# use nested for loop to get and run through all pixels in all four images
# use get_best_pixel to get the best pixel in each (x, y)
# set that best pixel on the result
"""
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, green_pixel, green_pixel, blue_pixel])
print(best1.red, best1.green, best1.blue)
print(get_average([green_pixel, green_pixel, green_pixel, blue_pixel]))
green_im = SimpleImage.blank(20, 20, 'green')
green_pixel = green_im.get_pixel(0 ,0)
print(get_pixel_dist(green_pixel, 5, 255, 10))
"""
######## YOUR CODE ENDS HERE ###########
print("Displaying image!")
result.show()
def main():
# Get file and load image
filename = get_file()
image = SimpleImage(filename)
# Show the image before the transform
image.show()
# Apply the filter
for pixel in image:
pixel.red = pixel.red * 1.5
pixel.green = pixel.green * .07
pixel.blue = pixel.blue * 1.5
# Show the image after the transform
image.show()
def add_border(original_img, border_sz):
"""
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_sz many pixels thick.
Inputs:
- original_img: The original image to process
- border_sz: The thickness of the border to add around the image
Returns:
A new SimpleImage with the border added around original image
- Create a new image
- for each in pixel (nested loop version)
- if pixel is a border pixel
- set it to black
- else
- set it to orginal image pixel
"""
new_image_height = original_img.height + 2 * border_sz
new_image_width = original_img.width + 2 * border_sz
new_image = SimpleImage.blank(new_image_width, new_image_height)
for x in range(new_image_width):
for y in range(new_image_height):
new_pixel = new_image.get_pixel(x, y)
if is_border_pixel(x, y, border_sz, new_image_width,
new_image_height):
new_pixel.red = 0
new_pixel.green = 0
new_pixel.blue = 0
else:
old_x = x - border_sz
old_y = y - border_sz
new_pixel = original_img.get_pixel(old_x, old_y)
new_image.set_pixel(x, y, new_pixel)
return new_image
