CST 205 Portfolio

Image Manipulations using JES
This is a showcase of the various image manipulation functions I've written, or worked on with SCSI Logic, from the labs I've done so far in 205.

Rose Colored Glasses
This function reduces the green and blue values of each pixel in the picture in order to give it pink overtones, and then repaints the target photo. 

	# Makes an image appear pink
	def roseColoredGlasses():
	pic = getPic()
	pixels = getPixels(pic)
	for p in pixels:
	myRed = getRed(p)
	myGreen = getGreen(p) * .50
	myBlue = getBlue(p) * .75
	setColor(p, makeColor(myRed, myGreen, myBlue))
	repaint(pic)
	dir = "C:\Users\Cody\Documents\CSUMB\CST 205\CST 205 - Images\Image Functions\Lab 3/rosecolored.jpg"
	writePictureTo(pic, dir)

view raw rosecoloredglasses.py hosted with ❤ by GitHub

Better Black and White
This function turns a photo into grayscale by multiplying the RGB values of each pixel by certain weights in order to get an average of each pixel. In turn, this value is the luminance of each pixel. These new values are then applied to the existing original pixels.

	# improved grayscale function using weights
	def betterBnW():
	pic = getPic()
	pixels = getPixels(pic)
	for p in pixels:
	# Find opposite of color by subtracting from max and multiply by weight
	newColor = (getRed(p) * 0.299 + getGreen(p) * 0.587 + getBlue(p) * 0.114)
	setColor(p, makeColor(newColor, newColor, newColor))
	repaint(pic)
	dir = "C:\Users\Cody\Documents\CSUMB\CST 205\CST 205 - Images\Image Functions\Lab 3/better_grayscale.jpg"
	writePictureTo(pic, dir)

view raw betterbnw.py hosted with ❤ by GitHub

Negative
Turns a photo into its negative by subtracting the RGB value of each pixel from the maximum value allowed (255, since the RGB model is an 8-bit model). JES's wrap around overflow is on by default, which prevents potential errors due to integer under/overflow.

	# Problem 5:
	# Alters the picture so that it is the negative of the original
	def makeNegative():
	pic = getPic()
	pixels = getPixels(pic)
	for p in pixels:
	# Find opposite of color by subtracting from max
	r = 255 - getRed(p)
	g = 255 - getGreen(p)
	b = 255 - getBlue(p)
	setColor(p, makeColor(r, g, b))
	repaint(pic)

view raw negative.py hosted with ❤ by GitHub

	# improved grayscale function using weights
	def betterBnW():
	pic = getPic()
	pixels = getPixels(pic)
	for p in pixels:
	# Find opposite of color by subtracting from max and multiply by weight
	newColor = (getRed(p) * 0.299 + getGreen(p) * 0.587 + getBlue(p) * 0.114)
	setColor(p, makeColor(newColor, newColor, newColor))
	repaint(pic)
	dir = "C:\Users\Cody\Documents\CSUMB\CST 205\CST 205 - Images\Image Functions\Lab 3/better_grayscale.jpg"
	writePictureTo(pic, dir)

view raw betterbnw.py hosted with ❤ by GitHub

Mirror - Bottom to Top
Mirrors the bottom half of an image by copying all the pixels from the bottom half (entire width of image, half height), and then copies it to the top half.

	def mirrorHalfHorizontal():
	file = pickAFile()
	pic = makePicture(file)
	#Get width and height of source image
	width = getWidth(pic)
	height = getHeight(pic)
	#Create empty picture to hold result
	result = makeEmptyPicture(width, height)
	#Get color of pixels from bottom half of image(half height), and full width of image
	for x in range(0, width):
	for y in range(0, height):
	result_pixels = getColor(getPixel(pic, x, y))
	setColor(getPixel(result, x, y), result_pixels)
	setColor(getPixel(result, x, height - y - 1), result_pixels)
	#writePictureTo(result, "C:\Users\Cody\Documents\CSUMB\CST 205\Lab 4\problem1_horzhalf.jpg")
	show(result)

view raw mirrorhalfhorizontal.py hosted with ❤ by GitHub

Shrink
This function shrinks a source image by creating a blank target image with the desired dimensions, copies every other pixel in the original photo, and then copies it to the target photo. Essentially, it samples half of the pixels from the original photo.

	# Resizes(shrinks)a copy of a photo.
	def shrink():
	source = makePicture(pickAFile())
	#Get width and height of original picture
	width = getWidth(source)
	height = getHeight(source)
	print("Original width: %d" % width)
	print("Original height: %d" % height)
	result_width = 0
	result_height = 0
	#Get dimensions for resulting image
	for x in range(0,width,2):
	result_width = result_width + 1
	for y in range(0,height,2):
	result_height = result_height + 1
	print("Resulting width: %d" % result_width)
	print("Resulting height: %d" % result_height)
	#Create blank image with target dimensions
	result = makeEmptyPicture(result_width, result_height)
	#Sample half of pixels from original image, and copy to new resized image
	#Result image width
	result_x = 0
	for x in range(0,width,2):
	#Result image height
	result_y = 0
	for y in range(0,height,2):
	result_pixels = getColor(getPixel(source, x, y))
	setColor(getPixel(result, result_x, result_y), result_pixels)
	result_y = result_y + 1 #Increment by 1 in target image
	result_x = result_x + 1 #Increment by 1 in target image
	#writePictureTo(result, "C:\Users\Cody\Documents\CSUMB\CST 205\Lab 4\problem4_shrink.jpg")
	show(source)
	show(result)
	return result

view raw shrink.py hosted with ❤ by GitHub

Collage
To create a collage, this function takes six photos of the same size and copies them to the appropriate coordinate values on the image. Additionally, it applies a random image effect from the ones previously shown before it adds the image to it. It's fun to play around with it to see how many different types of collages result because of the random image effects. The most difficult part was getting the dimensions right for each image in the collage.

	# Cody Young
	# CST 205
	# Lab 5
	# 2018-11-6
	import random
	#Warmup
	#Copies a source image to a bigger target image.
	def simpleCopy(source):
	source = makePicture(pickAFile())
	#Create empty target picture
	width = getWidth(source)
	height = getHeight(source)
	result = makeEmptyPicture(width * 2, height * 2)
	#Copy all pixels from source to target
	for x in range (0, width):
	for y in range (0,height):
	result_pixels = getColor(getPixel(source, x, y))
	setColor(getPixel(result, x, y), result_pixels)
	show(source)
	show(result)
	return source
	return result
	# Problem 1
	# Copies a source image to a new location in a blank target image.
	def pyCopy(source, target, targetX, targetY):
	#Target width variable
	resultX = targetX
	for x in range(0, getWidth(source)):
	#Target height variable
	resultY = targetY
	for y in range(0, getHeight(source)):
	target_pixels = getColor(getPixel(source, x, y))
	setColor(getPixel(target, resultX, resultY), target_pixels)
	resultY += 1
	resultX += 1
	return target
	# Problem 2
	# Creates a 8.5 x 11 collage from source photos and applies random effects.
	def makeCollage():
	#Create blank target image
	target = makeEmptyPicture(2550,3300)
	target_width = getWidth(target)
	target_height = getHeight(target)
	#Get images for collage, place in array(list) of pixel objects
	pictures = list()
	for i in range(0,8):
	pictures.append(getSource())
	#Apply random effect to image
	j=0
	for pics in pictures:
	randomEffect(pictures[j])
	j+=1
	#Add pictures to collage
	#Left column
	target = pyCopy(pictures[0], target, 0, 0)
	target = pyCopy(pictures[1], target, 0, 825)
	target = pyCopy(pictures[2], target, 0, 1650)
	target = pyCopy(pictures[3], target, 0, 2475)
	#Right column
	target = pyCopy(pictures[4], target, 1275, 0)
	target = pyCopy(pictures[5], target, 1275, 825)
	target = pyCopy(pictures[6], target, 1275, 1650)
	target = pyCopy(pictures[7], target, 1275, 2475)
	# Note: Change the dir variable to reflect your own working directory
	dir = "C:\Users\Cody\Documents\CSUMB\CST 205\Lab 5\collage.jpg"
	writePictureTo(target,dir)
	return target
	# ----------------
	# Helper Functions - Image Manipulations
	# ----------------
	# Applies a random effect to a source image. Returns image.
	def randomEffect(source):
	choice = random.randint(0,8)
	if choice == 0:
	roseColoredGlasses(source)
	elif choice == 1:
	mirrorHalfVertical(source)
	elif choice == 2:
	mirrorHalfHorizontal(source)
	elif choice == 3:
	fourWayMirror(source)
	elif choice == 4:
	makeNegative(source)
	elif choice == 5:
	betterBnW(source)
	elif choice == 6:
	moreRed(source, 75)
	elif choice == 7:
	lessRed(source, 50)
	else:
	return source
	# Improved grayscale function using weights
	def betterBnW(pic):
	pixels = getPixels(pic)
	for p in pixels:
	# Find opposite of color by subtracting from max and multiply by weight
	newColor = (getRed(p) * 0.299 + getGreen(p) * 0.587 + getBlue(p) * 0.114) / 3
	setColor(p, makeColor(newColor, newColor, newColor))
	return pic
	# Does a four way mirror. Executes a horizontal half mirror first, then a vertical half mirror.
	def fourWayMirror(pic):
	#Get width and height of source image
	width = getWidth(pic)
	height = getHeight(pic)
	#Horizontal half mirror
	for x in range(0, width):
	for y in range(0, height):
	result_pixels = getColor(getPixel(pic, x, y))
	setColor(getPixel(pic, x, height - y - 1), result_pixels)
	#Vertical half mirror
	for x in range(0, width/2 + 1):
	for y in range(0, height):
	result_pixels = getColor(getPixel(pic, x, y))
	setColor(getPixel(pic, width - x - 1, y), result_pixels)
	return pic
	# Does a vertical half mirror. Copies left hand side of image to right hand side.
	def mirrorHalfVertical(pic):
	#Get width and height of source image
	width = getWidth(pic)
	height = getHeight(pic)
	#Get color of pixels from half left side of image(width) and full height of image
	for x in range(0, width/2 + 1):
	for y in range(0, height):
	result_pixels = getColor(getPixel(pic, x, y))
	setColor(getPixel(pic, width - x - 1, y), result_pixels)
	return pic
	# Does a horizontal half mirror. Copies bottom half of the image to the top half.
	def mirrorHalfHorizontal(pic):
	#Get width and height of source image
	width = getWidth(pic)
	height = getHeight(pic)
	#Get color of pixels from bottom half of image(half height), and full width of image
	for x in range(0, width):
	for y in range(0, height):
	result_pixels = getColor(getPixel(pic, x, y))
	setColor(getPixel(pic, x, height - y - 1), result_pixels)
	return pic
	# Reduces amount of redness by the percentage passed in to the parameter
	def lessRed(pic, percent):
	pixels = getPixels(pic)
	for p in pixels:
	r = getRed(p)
	# Reduce red value and set new value
	setRed(p, r - (r * (percent/100)))
	return pic
	# Increases amount of redness by the percentage passed in to the parameter
	def moreRed(pic, percent):
	pixels = getPixels(pic)
	for p in pixels:
	r = getRed(p)
	setColorWrapAround(0)
	newRed = r + (r * (percent/100))
	setRed(p, newRed)
	return pic
	# Alters the picture so that it is the negative of the original
	def makeNegative(pic):
	pixels = getPixels(pic)
	for p in pixels:
	# Find opposite of color by subtracting from max
	r = 255 - getRed(p)
	g = 255 - getGreen(p)
	b = 255 - getBlue(p)
	setColor(p, makeColor(r, g, b))
	return pic
	# Makes an image appear pink
	def roseColoredGlasses(pic):
	pixels = getPixels(pic)
	for p in pixels:
	myRed = getRed(p)
	myGreen = getGreen(p) * .50
	myBlue = getBlue(p) * .75
	setColor(p, makeColor(myRed, myGreen, myBlue))
	return pic
	# Gets a picture from a directory and creates a picture object.
	def getSource():
	return makePicture(pickAFile())

view raw collage.py hosted with ❤ by GitHub

Red Eye Reduction
This red eye reduction function works by calculating the "distance" between a red pixel and the pixels in a designated region. If the difference between red values is too high, then the pixel is set to the color black. Adjusting the threshold values and finding the best one depends on the image and the targeted region.

	############################################
	# Warmup: Remove red-eye
	############################################
	def removeRedEye(pic, x1, x2, y1, y2):
	for x in range (x1, x2):
	for y in range(y1, y2):
	p = getPixel(pic, x, y)
	if distance(red, getColor(p)) < 180:
	setColor(p, black)
	show(pic)
	return pic

view raw redeye_reduction.py hosted with ❤ by GitHub

Artify
After getting all the RGB pixel values in an image, these values are then set to either red, green or blue according to which range they fall in. This causes sharp, discrete regions of color instead of continuous regions, causing the pixelated, exaggerated colorizing effect seen below.

	def artify(pic):
	for p in getPixels(pic):
	r = getRed(p)
	g = getGreen(p)
	b = getBlue(p)
	#Red adjustment
	if r < 64:
	setRed(p, 31)
	elif r < 128:
	setRed(p, 95)
	elif r < 192:
	setRed(p, 159)
	else:
	setRed(p, 223)
	#Green adjustment
	if g < 64:
	setGreen(p, 31)
	elif g < 128:
	setGreen(p, 95)
	elif g < 192:
	setGreen(p, 159)
	else:
	setGreen(p, 223)
	#Blue adjustment
	if b < 64:
	setBlue(p, 31)
	elif b < 128:
	setBlue(p, 95)
	elif b < 192:
	setBlue(p, 159)
	else:
	setBlue(p, 223)
	show(pic)
	return pic

view raw artify.py hosted with ❤ by GitHub

Green Screen (chroma key)
Similar to the red eye reduction function, this function looks for pixels with values that fall within certain shades of green. If the pixel is within this range, it replaces it with a pixel/color of choice.

	############################################
	# Problem 3: Implement chromakey
	############################################
	# Parameters: pic is a greenscreen image, back is
	# the background image.
	def chromaKey(pic, back):
	for x in range (0, getWidth(pic)):
	for y in range(0, getHeight(pic)):
	pic_p = getPixel(pic, x, y)
	back_p = getPixel(back, x, y)
	if distance(makeColor(110, 181, 125), getColor(pic_p)) < 75:
	setColor(pic_p, getColor(back_p))
	show(pic)
	return pic

view raw greenscreen.py hosted with ❤ by GitHub

Thanksgiving Card
This function superimposes three images on top of another, and uses the chroma key function to make it happen. Because JES does not work with alpha channels directly, and displays transparent backgrounds as black pixels, Ryan came up with the brilliant idea to use the chroma key function to replace black pixels with the pixels from the desired source image. In fact, the leaf border is the first image copied to the canvas, and then its corresponding black pixel regions are then chroma keyed with the actual image in the middle.

	# Makes a custom Thanksgiving card.
	def thanksCard():
	#Get first photo for background (leaf border, need to use it for chroma key)
	pic = getPic()
	width = getWidth(pic)
	height = getHeight(pic)
	#Get second photo for border (photo)
	family = getPic()
	#Get face photo
	face = getPic()
	#Copy first photo onto empty canvas(leaf border), overlay photo
	canvas = makeEmptyPicture(width, height)
	canvas = pyCopy(pic,canvas,0,0)
	canvas = chromaKey(canvas,family)
	canvas = facePlant(face, canvas)
	addTextWithStyle(canvas,280,580,"Happy Thanksgiving!",makeStyle(serif,bold,48),red)
	#Note: Change directory to your working directory, and uncomment the following 2 lines
	#dir = "C:\Users\Cody\Documents\CSUMB\CST 205\CST 205 - Images\Image Functions\Lab 7\output/thanksgivingcard.png"
	#writePictureTo(canvas, dir)
	return canvas
	# Returns the picture given a directory
	def getPic():
	return makePicture(pickAFile())
	# Makes empty picture
	def simpleCopy(pic):
	width = getWidth(pic)
	height = getHeight(pic)
	canvas = makeEmptyPicture(width, height)
	for x in range (0, width):
	for y in range (0, height):
	color = getColor(getPixel(pic, x, y))
	setColor(getPixel(canvas, x, y), color)
	return canvas
	# Copies a source image to a new location in a blank target image.
	def pyCopy(source, target, targetX, targetY):
	#Target width variable
	resultX = targetX
	for x in range(0, getWidth(source)):
	#Target height variable
	resultY = targetY
	for y in range(0, getHeight(source)):
	target_pixels = getColor(getPixel(source, x, y))
	setColor(getPixel(target, resultX, resultY), target_pixels)
	resultY += 1
	resultX += 1
	return target
	############################################
	# Parameters: pic is a greenscreen image, back is
	# the background image.
	def chromaKey(pic, back):
	for x in range (0, getWidth(pic)):
	for y in range(0, getHeight(pic)):
	pic_p = getPixel(pic, x, y)
	back_p = getPixel(back, x, y)
	if distance(makeColor(0, 0, 0), getColor(pic_p)) < 75:
	setColor(pic_p, getColor(back_p))
	return pic
	############################################
	# Parameters: pic is a greenscreen image, back is
	# the background image.
	def facePlant(pic, back):
	for x in range (0, getWidth(pic)):
	for y in range(0, getHeight(pic)):
	pic_p = getPixel(pic, x, y)
	back_p = getPixel(back, x, y)
	if distance(makeColor(255, 255, 255), getColor(pic_p)) < 20:
	setColor(pic_p, getColor(back_p))
	show(pic)
	return pic

view raw thanksgivingcard.py hosted with ❤ by GitHub

Advanced Technique - Line Drawing
This function takes an image, converts it to black and white, and then calculates and compares the luminance value of each pixel in the image, along with the pixels 1 pixel to the right and below. If the difference is larger than the luminance threshold, it sets the color of the pixel to black, otherwise it turns it white. Designing the function was relatively straightforward, but I had to write the getLuminance() helper function in order to avoid code deprecation and to keep clean design in mind. Initially, my threshold values were too high and the line drawn effect was quite muted - after playing around with several values, I settled on the current value seen below as the best balance between too much "black pixel" noise, and distinct, clean lines. The most difficult part of the algorithm was ensuring that the for loops did not go out of bounds of the photo. Additionally, I thought adding the print statements was good practice for debugging.

	# Cody Young
	# Line Drawing Function - JES
	# 2018-11-13
	import math
	# Converts an image to black and white, and then turns pixels to black or white to simulate a pencil/pen drawn sketch.
	def lineDraw():
	#Input picture, get height and width variables
	pic = getPic()
	show(pic)
	height = getHeight(pic)
	width = getWidth(pic)
	print("Height: %d" % height)
	print("Width: %d" % width)
	#Convert to grayscale and return pic
	betterBnW(pic)
	#Threshold value for luminance (difference)
	threshold = 10
	for x in range (0, width-1):
	for y in range(0, height-1):
	source = getPixel(pic, x, y) #Get current pixel
	source_lum = getLuminance(source) #Luminance of current pixel
	if x >= width:
	target_right = getLuminance(getPixel(pic, x, y)) #If at last pixel on border, use it instead
	else:
	target_right = getLuminance(getPixel(pic, x+1, y)) #Pixel one to right (width + 1)
	if y >= height:
	target_below = getLuminance(getPixel(pic, x, y)) #If at last pixel on border, use it instead
	else:
	target_below = getLuminance(getPixel(pic, x, y+1)) #Pixel one below (height + 1)
	diff_right = abs(source_lum - target_right)
	diff_below = abs(source_lum - target_below)
	#If luminance difference of right and below pixels are greater than threshold, set pixel to black, else set to white
	if diff_right > threshold and diff_below > threshold:
	setColor(source, black)
	else:
	setColor(source, white)
	repaint(pic)
	#Note: Change 'dir' to your working directory
	dir = "C:\Users\Cody\Documents\CSUMB\CST 205\CST 205 - Images\Image Functions\linedrawn.jpg"
	writePictureTo(pic, dir)
	return pic
	# ----------------
	# Helper Functions
	# ----------------
	# Returns the luminance value of a pixel
	def getLuminance(pixel):
	r = getRed(pixel)
	g = getGreen(pixel)
	b = getBlue(pixel)
	luminance = (0.299 * r) + (0.587 * g) + (0.114 * b)
	return luminance
	# Converts an image to grayscale
	def betterBnW(pic):
	pixels = getPixels(pic)
	for p in pixels:
	grayscale = ((getRed(p) * 0.299) + (getGreen(p) * 0.587) + (getBlue(p) * 0.114))
	setColor = (p, makeColor(grayscale, grayscale, grayscale))
	return pic
	def getPic():
	return makePicture(pickAFile())

view raw linedraw.py hosted with ❤ by GitHub