def convertBlackWhite(input_image):
grayscale_image = image.EmptyImage(input_image.getWidth(), input_image.getHeight())
for col in range(input_image.getWidth()):
for row in range(input_image.getHeight()):
p = input_image.getPixel(col, row)
red = p.getRed()
green = p.getGreen()
blue = p.getBlue()
avg = (red + green + blue) / 3.0
newpixel = image.Pixel(avg, avg, avg)
grayscale_image.setPixel(col, row, newpixel)
blackwhite_image = image.EmptyImage(input_image.getWidth(), input_image.getHeight())
for col in range(input_image.getWidth()):
for row in range(input_image.getHeight()):
p = grayscale_image.getPixel(col, row)
red = p.getRed()
if red > 140:
val = 255
else:
val = 0
newpixel = image.Pixel(val, val, val)
blackwhite_image.setPixel(col, row, newpixel)
return blackwhite_image
def smooth_image(input_image):
copy_image = image.EmptyImage(input_image.getWidth()+2, input_image.getHeight()+2)
for row in range(input_image.getHeight()):
for col in range(input_image.getWidth()):
p = input_image.getPixel(col, row)
red = p.getRed()
green = p.getGreen()
blue = p.getBlue()
new_pixel = image.Pixel(red, green, blue)
copy_image.setPixel(col+1, row+1, new_pixel)
print(copy_image.getWidth(), copy_image.getHeight())
sm_image = image.EmptyImage(copy_image.getWidth(), copy_image.getHeight())
for row in range(1, copy_image.getHeight()-1):
for col in range(1, copy_image.getWidth()-1):
try:
p = input_image.getPixel(col, row)
p_r = input_image.getPixel(col+1, row)
p_u = input_image.getPixel(col, row-1)
p_d = input_image.getPixel(col, row+1)
p_l = input_image.getPixel(col-1, row)
p_ru = input_image.getPixel(col+1, row-1)
p_lu = input_image.getPixel(col-1, row-1)
p_rd = input_image.getPixel(col+1, row+1)
p_ld = input_image.getPixel(col-1, row+1)
sm_red = int((p_r.getRed() + p_u.getRed() + p_ru.getRed() + p_l.getRed() + p_lu.getRed() +
p_d.getRed() + p_rd.getRed() + p_ld.getRed() + p.getRed()) / 9)
sm_green = int((p_r.getGreen() + p_u.getGreen() + p_ru.getGreen() + p_l.getGreen() +
p_lu.getGreen()+ p_d.getGreen() + p_rd.getGreen() + p_ld.getGreen() +
p.getGreen()) / 9)
sm_blue = int((p_r.getBlue() + p_u.getBlue() + p_ru.getBlue() + p_l.getBlue() +
p_lu.getBlue() + p_d.getBlue() + p_rd.getBlue() + p_ld.getBlue() +
p.getBlue()) / 9)
sm_new_pixel = image.Pixel(sm_red, sm_green, sm_blue)
st_image.setPixel(col, row, sm_new_pixel)
except ValueError:
#print("ValueError at Row:", row, " Col:", col)
pass
return sm_image
def smooeth(input_image):
new_image = image.EmptyImage(input_image.getWidth(), input_image.getHeight())
#width = y
#height = x
for i in range(1, img.getWidth() - 1):
for j in range(1, img.getHeight() - 1):
newx = old_image.
def smooth(oldimage):
oldw = oldimage.getWidth()
oldh = oldimage.getHeight()
newim = image.EmptyImage(oldw, oldh)
for row in range(oldh):
for col in range(oldw):
p1 = oldimage.getPixel(col, row)
p2 = oldimage.getPixel(col + 1, row)
red1 = p1.getRed()
red2 = p2.getRed()
green1 = p1.getGreen()
green2 = p2.getGreen()
blue1 = p1.getBlue()
blue2 = p2.getBlue()
newRed = int((red1 + red2) / 2)
newGreen = int((green1 + green2) / 2)
newBlue = int((blue1 + blue2) / 2)
newPixel = image.Pixel(newRed, newGreen, newBlue)
newim.setPixel(col, row, newPixel)
#oldpixel = oldimage.getPixel(col,row)
#newim.setPixel((2*col),(2*row), (oldpixel))
#newim.setPixel((2*col+1), (2*row), (oldpixel))
#newim.setPixel((2*col), (2*row+1), (oldpixel))
#newim.setPixel((2*col+1), (2*row+1), (oldpixel))
return newim
def sepia(i, win):
"""
Function that takes an image, processes the pixels to sepia values, and returns a new image
:param win: window frame to display image
:param i: image file
:return: new image
"""
# Creates and returns empty image object with width and height
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
# Image processing - do something with pixel at position (col,row)
for row in range(i.getHeight()):
for col in range(i.getWidth()):
# get one pixel
p = i.getPixel(col, row)
# change the properties
new_red = int((p.getRed() * 0.393) + (p.getGreen() * 0.769) +
(p.getBlue() * 0.189))
if new_red > 255:
new_red = 255
new_green = int((p.getRed() * 0.349) + (p.getGreen() * 0.686) +
(p.getBlue() * 0.168))
if new_green > 255:
new_green = 255
new_blue = int((p.getRed() * 0.272) + (p.getGreen() * 0.534) +
(p.getBlue() * 0.131))
if new_blue > 255:
new_blue = 255
# set pixel to new properties
new_pixel = image.Pixel(new_red, new_green, new_blue)
newimg.setPixel(col, row, new_pixel) # setter method
return newimg.draw(win)
def remove_all_red(i, win):
"""
Function that takes an image, processes the pixels by removing all red values, and returns a new image
:param win: window frame to display image
:param i: image file
:return: new image
"""
# Creates and returns empty image object with width and height
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
# Image processing - do something with pixel at position (col,row)
for row in range(i.getHeight()):
for col in range(i.getWidth()):
# get one pixel
p = i.getPixel(col, row)
# change the properties
new_red = 0
new_green = p.getGreen()
new_blue = p.getBlue()
# set pixel to new properties
new_pixel = image.Pixel(new_red, new_green, new_blue)
newimg.setPixel(col, row, new_pixel) # setter method
return newimg.draw(win)
def convertSepia(input_image):
sepia_image = image.EmptyImage(input_image.getWidth(),input_image.getHeight())
for col in range(input_image.getWidth()):
for row in range(input_image.getHeight()):
p = input_image.getPixel(col, row)
red = p.getRed()
green = p.getGreen()
blue = p.getBlue()
newR = int((red * 0.393) + (green * 0.769) + (blue * 0.189))
newG = int((red * 0.349) + (green * 0.686) + (blue * 0.168))
newB = int((red * 0.272) + (green * 0.534) + (blue * 0.131))
avg = int((red + green + blue) / 3.0)
newpixel = image.Pixel(newR, newG, newB)
sepia_image.setPixel(col, row, newpixel)
#blackwhite_image = image.EmptyImage(input_image.getWidth(),input_image.getHeight())
#for col in range(input_image.getWidth()):
#for row in range(input_image.getHeight()):
#p = grayscale_image.getPixel(col, row)
#red = p.getRed()
#if red > 140:
#val = 255 #White
#else:
#val = 0 #Black
#newpixel = image.Pixel(val, val, val)
#blackwhite_image.setPixel(col, row, newpixel)
return sepia_image
def halve(oldimage):
"""Halves the size of the image"""
oldw = oldimage.getWidth()
oldh = oldimage.getHeight()
newim = image.EmptyImage(int(oldw * .5), int(oldh * .5))
for row in range(oldh - 1):
for col in range(oldw - 1):
oldpixel1 = oldimage.getPixel(col, row)
oldpixel2 = oldimage.getPixel(col + 1, row)
oldpixel3 = oldimage.getPixel(col, row + 1)
oldpixel4 = oldimage.getPixel(col + 1, row + 1)
newred = int((oldpixel1.getRed() + oldpixel2.getRed() +
oldpixel3.getRed() + oldpixel4.getRed()) / 4)
newgreen = int((oldpixel1.getGreen() + oldpixel2.getGreen() +
oldpixel3.getGreen() + oldpixel4.getGreen()) / 4)
newblue = int((oldpixel1.getBlue() + oldpixel2.getBlue() +
oldpixel3.getBlue() + oldpixel4.getBlue()) / 4)
newpixel = image.Pixel(newred, newgreen, newblue)
newim.setPixel(int(.5 * col), int(.5 * row), newpixel)
return newim
def convertToSepiaTone(imageToChange):
width = imageToChange.getWidth()
height = imageToChange.getHeight()
sepiaImage = image.EmptyImage(width, height)
for col in range(width):
for row in range(height):
newPixel = calculateSepiaToneRGB(imageToChange.getPixel(col, row))
sepiaImage.setPixel(col, row, newPixel)
return sepiaImage
def double(oldimage):
oldw = oldimage.getWidth()
oldh = oldimage.getHeight()
newim = image.EmptyImage(oldw * 2, oldh * 2)
for row in range(oldh):
for col in range(oldw):
avediv = 0
red = 0
green = 0
blue = 0
oldpixel = oldimage.getPixel(col, row)
if col > 1:
pixel = oldimage.getPixel(col - 1, row)
avediv += 1
red += pixel.getRed()
green += pixel.getGreen()
blue += pixel.getBlue()
if col < oldw - 1:
pixel = oldimage.getPixel(col + 1, row)
avediv += 1
red += pixel.getRed()
green += pixel.getGreen()
blue += pixel.getBlue()
if row > 1:
pixel = oldimage.getPixel(col, row - 1)
avediv += 1
red += pixel.getRed()
green += pixel.getGreen()
blue += pixel.getBlue()
if row < oldh - 1:
pixel = oldimage.getPixel(col, row + 1)
avediv += 1
red += pixel.getRed()
green += pixel.getGreen()
blue += pixel.getBlue()
if avediv > 0:
red = red / avediv
green = green / avediv
blue = blue / avediv
newpixel = image.Pixel(red, green, blue)
newim.setPixel(2 * col, 2 * row, newpixel)
newim.setPixel(2 * col + 1, 2 * row, newpixel)
newim.setPixel(2 * col, 2 * row + 1, newpixel)
newim.setPixel(2 * col + 1, 2 * row + 1, newpixel)
else:
newim.setPixel(2 * col, 2 * row, oldpixel)
newim.setPixel(2 * col + 1, 2 * row, oldpixel)
newim.setPixel(2 * col, 2 * row + 1, oldpixel)
newim.setPixel(2 * col + 1, 2 * row + 1, oldpixel)
return newim
def doubleImage(oldImage):
oldW = oldImage.getWidth()
oldH = oldImage.getHeight()
newIm = image.EmptyImage(oldW * 2, oldH * 2)
for row in range(oldH):
for col in range(oldW):
oldPixel = oldImage.getPixel(col, row)
newIm.setPixel(2 * col, 2 * row, oldPixel)
newIm.setPixel(2 * col + 1, 2 * row, oldPixel)
newIm.setPixel(2 * col, 2 * row + 1, oldPixel)
newIm.setPixel(2 * col + 1, 2 * row + 1, oldPixel)
return newIm
def pixelMapper(oldimage, rgbFunction):
width = oldimage.getWidth()
height = oldimage.getHeight()
newim = image.EmptyImage(width, height)
for row in range(height):
for col in range(width):
originalpixel = oldimage.getPixel(col, row)
newpixel = rgbFunction(originalpixel)
newim.setPixel(col, row, newpixel)
return newim
def operateOnPixel(sourceImage, rgbTransformeation):
width = sourceImage.getWidth()
height = sourceImage.getHeight()
newImage = image.EmptyImage(width, height)
#rgbTransformer(sourceImage.getPixel(col, row)
for col in range(width):
for row in range(height):
newImage.setPixel(
col, row, rgbTransformeation(sourceImage.getPixel(col, row)))
return newImage
def main():
original= image.FileImage('tree.jpg')
OGWidth= original.getWidth()
OGHeight= original.getHeight()
new= image.EmptyImage(OGWidth, OGHeight)
spring_to_fall(OGWidth,OGHeight, new, original)
window=image.ImageWin(OGWidth,OGHeight, "Seasonal Tree")
new.draw(window)
new.save('fall_tree.jpg')
window.exitOnClick()
def escalar(imagenpequena):
oldw = imagenpequena.getWidth()
oldh = imagenpequena.getHeight()
imagengrande = image.EmptyImage(oldw * 2, oldh * 2)
for row in range(oldh):
for col in range(oldw):
oldpixel = imagenpequena.getPixel(col, row)
imagengrande.setPixel(2*col, 2*row, oldpixel)
imagengrande.setPixel(2*col+1, 2*row, oldpixel)
imagengrande.setPixel(2*col, 2*row+1, oldpixel)
imagengrande.setPixel(2*col+1, 2*row+1, oldpixel)
return (imagengrande)
def double(old_image):
old_w = old_image.getWidth()
old_h = old_image.getHeight()
new_img = image.EmptyImage(old_w * 2, old_h * 2)
for row in range(old_h):
for col in range(old_w):
old_pixel = old_image.getPixel(col, row)
new_img.setPixel(2 * col, 2 * row, old_pixel)
new_img.setPixel(2 * col + 1, 2 * row, old_pixel)
new_img.setPixel(2 * col, 2 * row + 1, old_pixel)
new_img.setPixel(2 * col + 1, 2 * row + 1, old_pixel)
return new_img
def double(oldimage):
oldw = oldimage.getWidth()
oldh = oldimage.getHeight()
newim = image.EmptyImage(oldw * 2, oldh * 2)
for row in range(oldh):
for col in range(oldw):
oldpixel = oldimage.getPixel(col, row)
newim.setPixel(2*col, 2*row, oldpixel)
newim.setPixel(2*col+1, 2*row, oldpixel)
newim.setPixel(2*col, 2*row+1, oldpixel)
newim.setPixel(2*col+1, 2*row+1, oldpixel)
return newim
def double_image(img):
double = image.EmptyImage(img.getWidth() * 2, img.getHeight() * 2)
print(double)
for row in range(img.getHeight()):
for column in range(img.getWidth()):
double.setPixel(125 / 255, 125 / 255, 125 / 255)
# p = img.getPixel(column, row)
#
# double.setPixel(2*column,2*row,p)
# double.setPixel(2*column+1,2*row,p)
# double.setPixel(2*column,2*row+1,p)
# double.setPixel(2*column+1,2*row+1,p)
print(dir(double))
return double
def double_photo(
filename
): #doubles side length of photo, enlarges area by a factor of 4
img = image.Image(filename)
newimg = image.EmptyImage(2 * img.getWidth(), 2 * img.getHeight())
img.setDelay(0)
for row in range(img.getHeight()):
for col in range(img.getWidth()):
p = img.getPixel(col, row)
newimg.setPixel(2 * col, 2 * row, p)
newimg.setPixel(2 * col, 2 * row + 1, p)
newimg.setPixel(2 * col + 1, 2 * row, p)
newimg.setPixel(2 * col + 1, 2 * row + 1, p)
return newimg
def doubleImageSize(imageToChange, scaleFactor):
width = imageToChange.getWidth()
height = imageToChange.getHeight()
newImage = image.EmptyImage(width * scaleFactor, height * scaleFactor)
for col in range(width):
for row in range(height):
currentPixel = imageToChange.getPixel(col, row)
newImage.setPixel(col * scaleFactor, row * scaleFactor,
currentPixel)
newImage.setPixel(col * scaleFactor + 1, row * scaleFactor,
currentPixel)
newImage.setPixel(col * scaleFactor, (row * scaleFactor) + 1,
currentPixel)
newImage.setPixel((col * scaleFactor) + 1, (row * scaleFactor) + 1,
currentPixel)
return newImage
def superposeGreenScreen(minion_img, original_img):
'''
Superposes minion image onto cap u image
'''
green_screen_img = image.EmptyImage(
minion_img.getWidth(), minion_img.getHeight(
)) # Sets up window with same dimensions as minion image
for row in range(green_screen_img.getHeight()):
for col in range(green_screen_img.getWidth()):
p = minion_img.getPixel(col, row)
if isGreen(p):
p = original_img.getPixel(
col, row
) # if pixel from minion image is green, return corresponding pixel from cap u image.
green_screen_img.setPixel(col, row, p)
return green_screen_img
def negative(original_image):
width = original_image.get_width()
height = original_image.get_height()
new_image = image.EmptyImage(width, height)
for row in range(height):
for col in range(width):
p = original_image.get_pixel(col, row)
new_red = 255 - p.get_red()
new_green = 255 - p.get_green()
new_blue = 255 - p.get_blue()
new_pixel = image.Pixel(new_red, new_green, new_blue)
new_image.set_pixel(col, row, new_pixel)
return new_image
def increase_green(original_image, amount_of_green_to_add):
width = original_image.get_width()
height = original_image.get_height()
new_image = image.EmptyImage(width, height)
for row in range(height):
for col in range(width):
p = original_image.get_pixel(col, row)
new_red = p.get_red()
new_green = p.get_green() + amount_of_green_to_add
new_blue = p.get_blue()
new_pixel = image.Pixel(new_red, new_green, new_blue)
new_image.set_pixel(col, row, new_pixel)
return new_image
def enlarge_image(input_image):
st_image = image.EmptyImage(input_image.getWidth()*2, input_image.getHeight()*2)
for row in range(input_image.getHeight()):
for col in range(input_image.getWidth()):
p = input_image.getPixel(col, row)
red = p.getRed()
green = p.getGreen()
blue = p.getBlue()
new_pixel = image.Pixel(red, green, blue)
st_image.setPixel(col*2, row*2, new_pixel)
st_image.setPixel(col*2+1, row*2, new_pixel)
st_image.setPixel(col*2, row*2+1, new_pixel)
st_image.setPixel(col*2+1, row*2+1, new_pixel)
return st_image
def sepia_tone(input_image):
st_image = image.EmptyImage(input_image.getWidth(), input_image.getHeight())
for row in range(input_image.getHeight()):
for col in range(input_image.getWidth()):
p = input_image.getPixel(col, row)
red = p.getRed()
green = p.getGreen()
blue = p.getBlue()
new_r = int((red * 0.393 + green * 0.769 + blue * 0.189))
new_g = int((red * 0.349 + green * 0.686 + blue * 0.168))
new_b = int((red * 0.272 + green * 0.534 + blue * 0.131))
new_pixel = image.Pixel(new_r, new_g, new_b)
st_image.setPixel(col, row, new_pixel)
return st_image
def red_remover(original_image, window):
width = original_image.getWidth()
height = original_image.getHeight()
new_image = image.EmptyImage(width, height)
for x in range(width):
for y in range(height):
this_pixel = original_image.getPixel(x, y)
new_red = 0
new_green = this_pixel.getGreen()
new_blue = this_pixel.getBlue()
new_pixel = image.Pixel(new_red, new_green, new_blue)
new_image.setPixel(x, y, new_pixel)
#comment out the line below to stop animating this
new_image.draw(window)
return new_image
def adjustGrey(img):
"""
Return a copy of given img with in greyscale
"""
# create an empty image of same dimension
filtered_image = image.EmptyImage(img.getWidth(), img.getHeight())
# for each pixel in the image, img
for row in range(img.getHeight()):
for col in range(img.getWidth()):
# get the pixel value
p = img.getPixel(col, row)
# apply contrast filter to the pixel
p = greyTransform(p)
# set the corresponding pixel in the filtered image
filtered_image.setPixel(col, row, p)
return filtered_image
def adjustBrightness(img, brightness):
"""
Return a copy of given img with the contrast adjusted by given factor.
@param contrast values [0..1) reduce contrast; values > 1 increase contrast
"""
# create an empty image of same dimension
filtered_image = image.EmptyImage(img.getWidth(), img.getHeight())
# for each pixel in the image, img
for row in range(img.getHeight()):
for col in range(img.getWidth()):
# get the pixel value
p = img.getPixel(col, row)
# apply contrast filter to the pixel
p = brightnessTransform(p, brightness)
# set the corresponding pixel in the filtered image
filtered_image.setPixel(col, row, p)
return filtered_image
def smooth(img):
print(dir(img))
print(img.getWidth)
print(img.getWidth())
oldw = img.getWidth
oldh = img.getHeight()
newimg = image.EmptyImage(oldw, oldh)
for col in range(oldw):
for row in range(oldh):
p = newimg.getPixel(col, row)
neighbors = []
for i in range(col - 1, col + 2):
for j in range(row - 1, row + 2):
try:
neighbor = img.getPixel(i, j)
neighbors.append(neighbor)
except:
continue
nlen = len(neighbors)
if nlen:
red = 0
green = 0
blue = 0
for i in range(nlen):
red += int(neighbors[i][0])
green += int(neighbors[i][1])
blue += int(neighbors[i][2])
p.red = red / nlen
p.green = green / nlen
p.blue = blue / nlen
newimg.setPixel(col, row, p)
return newimg
def smoothenScaledImage(sourceImage):
width = sourceImage.getWidth()
height = sourceImage.getHeight()
newImage = image.EmptyImage(width, height)
for col in range(width):
for row in range(height):
startPixel = sourceImage.getPixel(col, row)
topLeftPixel = sourceImage.getPixel(col, row + 1)
topRightPixel = sourceImage.getPixel(col + 1, row + 1)
BottomRightPixel = sourceImage.getPixel(col + 1, row)
regAvg = (startPixel.getRed() + topLeftPixel.getRed() +
topRightPixel.getRed() + BottomRightPixel.getRed()) / 4
greenAvg = (startPixel.getGreen() + topLeftPixel.getGreen() +
topRightPixel.getGreen() +
BottomRightPixel.getGreen()) / 4
blueAvg = (startPixel.getGreen() + topLeftPixel.getBlue() +
topRightPixel.getBlue() +
BottomRightPixel.getBlue()) / 4
newPixel = image.Pixel(regAvg, greenAvg, blueAvg)
newImage.setPixel(col, row, newPixel)
return newImage
