def remove_red(p):
new_red = 0
green = p.getGreen()
blue = p.getBlue()
new_pixel = image.Pixel(new_red, green, blue)
return new_pixel
win = image.ImageWin(w, h)
def avg(x):
return sum(x) / len(x)
# for col in range(w):
# for row in range(h):
# p = img.getPixel(col, row)
# newimg.setPixel(2 * col, 2 * row, p)
# newimg.setPixel(2 * col + 1, 2 * row, p)
# newimg.setPixel(2 * col, 2 * row + 1, p)
# newimg.setPixel(2 * col + 1, 2 * row + 1, p)
for col in range(1, w - 1):
for row in range(1, h - 1):
indexes = [0, 0], [0, 1], [1, 0], [-1, 0], [0, -1]
r = []
g = []
b = []
for pixelIndex in indexes:
pixel = img.getPixel(col + pixelIndex[0], row + pixelIndex[1])
r.append(pixel.getRed())
g.append(pixel.getGreen())
b.append(pixel.getBlue())
newpixel = image.Pixel(avg(r), avg(g), avg(b))
newimg.setPixel(col, row, newpixel)
newimg.draw(win)
win.exitonclick()
# WALKTHROUGH -------------------------------------------------------------------
# For this walkthrough, we will write a program to apply a red filter to an image.
# (Note that when you run the code, it will take a few seconds to process.)
import image
import sys
image = image.Image("luther.jpg")
new_img = image.EmptyImage(img.getWidth(), img.getHeight())
win = image.ImageWin(img.getWidth(), img.getHeight())
for i in range(0, img.getWidth()):
for j in range(0, img.getHeight()):
old_p = img.getPixel(i, j)
red = old_p.getRed()
new_p = image.Pixel(red, 0, 0)
new_img.setPixel(i, j, new_p)
new_img.draw(win)
win.exitonclick()
# STUDIO -----------------------------------------------------------------------
# For this studio, your job is to write an algorithm that processes an image to
# make it "fuzzy" looking. SEE TEXTBOOK FOR EXAMPLES / TO RUN YOUR CODE.
#
# The algorithm to achieve this effect is actually fairly simple: for each pixel,
# randomly choose one of its neighboring pixels, and use that pixel's color
# instead.
#
# For example, imagine that the table below is a zoomed-in view of the pixels in
# our image, and that we are trying to alter the center pixel (the one whose color
p = img.getPixel(x+1, y)
r = p.getRed()
g = p.getGreen()
b = p.getBlue()
Gx += 2 * (r + g + b)
p = img.getPixel(x+1, y+1)
r = p.getRed()
g = p.getGreen()
b = p.getBlue()
Gx += (r + g + b)
Gy += (r + g + b)
# calculate the length of the gradient (Pythagorean theorem)
length = math.sqrt((Gx * Gx) + (Gy * Gy))
# normalise the length of gradient to the range 0 to 255
length = length / 4328 * 255
length = int(length)
# draw the length in the edge image
newpixel = image.Pixel(length, length, length)
newimg.setPixel(x, y, newpixel)
newimg.draw(win)
win.exitonclick()
# Q7 remove red
import image
img = image.Image("luther.jpg")
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
win = image.ImageWin()
for col in range(img.getWidth()):
for row in range(img.getHeight()):
p = img.getPixel(col, row)
newred = 0
green = p.getGreen()
blue = p.getBlue()
newpixel = image.Pixel(newred, green, blue)
newimg.setPixel(col, row, newpixel)
newimg.draw(win)
win.exitonclick()
# Q9 convert an image to black and white
import image
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()):
import image
pika = image.Image("pikachu.jpg")
win = image.ImageWin(pika.getWidth(), pika.getHeight(), "shock")
pika.draw(win)
for x in range(pika.getWidth()):
for y in range(pika.getHeight()):
orig = pika.getPixel(x,y)
pika.setPixel(x,y,image.Pixel(255- orig.getRed(),255- orig.getGreen(),255- orig.getBlue()))
pika.draw(win)
win.exit_on_click()
import image
img = image.Image("luther.jpg")
win = image.ImageWin(img.getWidth(), img.getHeight())
for row in range(img.getHeight()):
for col in range(img.getWidth()):
p = img.getPixel(col, row)
avghue = (p.getRed() + p.getGreen() + p.getBlue()) / 3
if avghue < 140:
newpixel = image.Pixel(0, 0, 0)
else:
newpixel = image.Pixel(255, 255, 255)
img.setPixel(col, row, newpixel)
img.draw(win)
# Exercise 6
# Write a program to remove all the red from an image.
img = image.Image("luther.jpg")
win = image.ImageWin(img.getWidth(), img.getHeight())
img.draw(win)
img.setDelay(1,15) # setDelay(0) turns off animation, but appears to freeze while processing...
for row in range(img.getHeight()):
for col in range(img.getWidth()):
p = img.getPixel(col, row)
new_red = 0
new_green = p.getGreen()
new_blue = p.getBlue()
new_pixel = image.Pixel(new_red, new_green, new_blue)
img.setPixel(col, row, new_pixel)
img.draw(win)
win.exitonclick()
# Exercise 7
# Write a function to convert the image to grayscale.
import image
img = image.Image("luther.jpg")
win = image.ImageWin(img.getWidth(), img.getHeight())
img.draw(win)
img.setDelay(1,15) # setDelay(0) turns off animation, but appears to freeze while processing...
import image
img = image.Image("ucd.jpg")
win = image.ImageWin(img.getWidth(), img.getHeight())
print(img.getWidth(), img.getHeight())
img.draw(win)
img.setDelay(1, 15) # setDelay(0) turns off animation
for row in range(img.getHeight()):
for col in range(img.getWidth()):
p = img.getPixel(col, row)
red = p.getRed()
green = p.getGreen()
blue = p.getBlue()
avg = (red + green + blue) / 3
newpixel = image.Pixel(avg, avg, avg)
print(newpixel)
img.setPixel(col, row, (avg, avg, avg))
img.draw(win)
win.exitonclick()
import os
os.system('cls')
print('\n# BEGIN OF THE SCRIPT #############################################')
import image
p = image.Pixel(45, 76, 200)
print(p.getRed())
p.setRed(66)
print(p.getRed())
p.setBlue(p.getGreen())
print(p.getGreen(), p.getBlue())
# Auto git saving #####################################################
save = 1
commitMsg = '1. Image Processing.'
if save:
print('\nAUTO GIT SAVING...')
fileName = os.path.basename(__file__)
os.system('git add '+ fileName)
os.system('git commit -m '+'"'+commitMsg+'"')
os.system('git push')
print('\nFile Name: '+fileName)
print('\nCommit Message: '+commitMsg)
print('\nSAVED AND PUSHED!')
import image
img = image.Image("luther.jpg")
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
win = image.ImageWin()
for col in range(img.getWidth()):
for row in range(img.getHeight()):
p = img.getPixel(col, row)
x = 255 if (p.getRed()+p.getBlue()+p.getGreen())/3 > 140 else 0
newpixel = image.Pixel(x, x, x)
newimg.setPixel(col, row, newpixel)
newimg.draw(win)
win.exitonclick()
#In order to manipulate an image, we need to be able to access individual pixels. This capability is provided by a module called image, provided in ActiveCode 1. The image module defines two classes: Image and Pixel. #If you want to explore image processing on your own outside of the browser you can install the cImage module from http://pypi.org. #Each Pixel object has three attributes: the red intensity, the green intensity, and the blue intensity. A pixel provides three methods that allow us to ask for the intensity values. They are called getRed, getGreen, and getBlue. In addition, we can ask a pixel to change an intensity value using its setRed, setGreen, and setBlue methods. Pixel(20,100,50) #Create a new pixel with 20 red, 100 green, and 50 blue. getRed() example r = p.getRed() #Return the red component intensity. #samefor b g setRed() example p.setRed(100) #Set the red component intensity to 100. #samefor b g #heres a example import image p = image.Pixel(45, 76, 200) print(p.getRed()) p.setRed(66) print(p.getRed()) p.setBlue(p.getGreen()) print(p.getGreen(), p.getBlue()) #that was all about, pixels. now image objects Image(filename) img = image.Image(“cy.png”) Create an Image object from the file cy.png. EmptyImage() img = image.EmptyImage(100,200) Create an Image object that has all “White” pixels getWidth() w = img.getWidth() Return the width of the image in pixels. getHeight() h = img.getHeight() Return the height of the image in pixels. getPixel(col,row) p = img.getPixel(35,86) Return the pixel at column 35, row 86.
'''Take the Luther Bell image and tint it red'''
import image
img = image.Image("luther.jpg")
win = image.ImageWin()
for x in range(img.getWidth()):
for y in range(img.getHeight()):
p = img.getPixel(x, y)
red = p.getRed()
green = p.getGreen()
blue = p.getBlue()
new_p = image.Pixel(255, green, blue)
#or
#new_p=image.Pixel(red,0,0)
img.setPixel(x, y, new_p)
img.draw(win)
win.exitonclick()
import image
img = image.Image("luther.jpg")
win = image.ImageWin(img.getWidth(), img.getHeight())
for row in range(img.getHeight()):
for col in range(img.getWidth()):
p = img.getPixel(col, row)
avghue = (p.getRed()+p.getGreen()+p.getBlue())/3
newpixel = image.Pixel(avghue, avghue, avghue)
img.setPixel(col, row, newpixel)
img.draw(win)
while col > 0 and col < width - 1:
p1 = img.getPixel(col - 1, row - 1)
p2 = img.getPixel(col, row - 1)
p3 = img.getPixel(col + 1, row - 1)
p4 = img.getPixel(col - 1, row)
p5 = img.getPixel(col, row)
p6 = img.getPixel(col + 1, row)
p7 = img.getPixel(col - 1, row + 1)
p8 = img.getPixel(col, row + 1)
p9 = img.getPixel(col + 1, row + 1)
avgRed = (p1.getRed() + p2.getRed() + p3.getRed() +
p4.getRed() + p5.getRed() + p6.getRed() +
p7.getRed() + p8.getRed() + p9.getRed()) / 9
avgGreen = (p1.getGreen() + p2.getGreen() + p3.getGreen() +
p4.getGreen() + p5.getGreen() + p6.getGreen() +
p7.getGreen() + p8.getGreen() + p9.getGreen()) / 9
avgBlue = (p1.getBlue() + p2.getBlue() + p3.getBlue() +
p4.getBlue() + p5.getBlue() + p6.getBlue() +
p7.getBlue() + p8.getBlue() + p9.getBlue()) / 9
newpixel = image.Pixel(avgRed, avgGreen, avgBlue)
newimg.setPixel(2 * col, 2 * row, newpixel)
newimg.setPixel(2 * col + 1, 2 * row, newpixel)
newimg.setPixel(2 * col, 2 * row + 1, newpixel)
newimg.setPixel(2 * col + 1, 2 * row + 1, newpixel)
newimg.draw(win)
win.exitonclick()
width = source_image.get_width() #find the width and
height = source_image.get_height() #height of the image
window = image.ImageWin(width, height) #create a window
source_image.draw(window)
#Set up Loops to Visit every pixel and do some work
for x in range(width):
for y in range(height):
#retrieve the current pixel
current_pixel = source_image.get_pixel(x,y)
#access the R,G,B component values
r = current_pixel.get_red()
g = current_pixel.get_green()
b = current_pixel.get_blue()
if r+g+b < 30:
r = 50
g = y
b = x
new_pixel = image.Pixel(r, g, b) #create a new pixel
source_image.set_pixel(x,y,new_pixel) #create a new pixel
if x % 3 == 0: #to speed up the animation
source_image.draw(window) #animate the manipulation
source_image.draw(window)
import image
img = image.Image("luther.jpg")
win = image.ImageWin()
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
for col in range(img.getWidth()):
for row in range(img.getHeight()):
p = img.getPixel(col, row)
newred = p.getRed() * 0.393 + p.getGreen() * 0.769 + p.getBlue() * 0.189
newgreen = p.getRed() * 0.349 + p.getGreen() * 0.686 + p.getBlue(
) * 0.168
newblue = p.getRed() * 0.272 + p.getGreen() * 0.534 + p.getBlue(
) * 0.131
newpixel = image.Pixel(newred, newgreen, newblue)
newimg.setPixel(col, row, newpixel)
newimg.draw(win)
win.exitonclick()
import image
import sys
import random
img = image.Image("luther.jpg")
new_img = image.EmptyImage(img.getWidth(), img.getHeight())
win = image.ImageWin(img.getWidth(), img.getHeight())
for i in range(1, img.getWidth() - 1):
for j in range(1, img.getHeight() - 1):
# TODO: Randomly choose the coordinates of a neighboring pixel
#random.randint(i - 1, i + 1)
#random.randint(j - 1, j + 1)
p = img.getPixel(((random.randrange(-1, 2, 2)) + i), ((random.randrange(-1, 2, 2)) + j))
red = p.getRed()
green = p.getGreen()
blue = p.getBlue()
# TODO: in the new image, set this pixel's color to the neighbor's color
new_p = image.Pixel(red, green, blue)
new_img.setPixel(i, j, new_p)
new_img.draw(win)
win.exitonclick()
You could use this image referenced by Luther.jpg.
Tips:
Be careful! What happens when you get to an edge?
If you use pixel indexes i and j you can access the neighbors by adding and subtracting one from those numbers, i.e. i+1, i-1, ...
'''
import image
import sys
# Set the timeout to a larger number if timeout is occuring.
sys.getExecutionLimit(30000)
img = image.Image("luther.jpg")
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
win = image.ImageWin()
for i in range(0, img.getWidth()):
for j in range(0, img.getHeight()):
old_p = img.getPixel(i, j)
# TODO: Complete the inner part of this loop to blur the image.
# new_p = image.Pixel(255, old_p.getBlue(), old_p.getGreen())
# newimg.setPixel(i, j, new_p)
red = old_p.getRed()
blue = old_p.getBlue()
green = old_p.getGreen()
new_p = image.Pixel(255, old_p.getBlue(), old_p.getGreen())
newimg.setPixel(i, j, new_p)
newimg.draw(win)
win.exitonclick()
def remove_red(pix):
new_red = 0
new_green = pix.green
new_blue = pix.blue
new_pix = image.Pixel(new_red, new_green, new_blue)
return new_pix
import image
img = image.Image("luther.jpg")
newimg = image.EmptyImage(img.getWidth(), img.getHeight())
win = image.ImageWin()
for col in range(img.getWidth()):
for row in range(img.getHeight()):
p = img.getPixel(col, row)
newred = 0
green = p.getGreen()
blue = p.getBlue()
newpixel = image.Pixel(newred, green, blue)
newimg.setPixel(col, row, newpixel)
newimg.draw(win)
win.exitonclick()
def remove_blue(pix):
new_red = pix.red
new_green = pix.green
new_blue = 0
new_pix = image.Pixel(new_red, new_green, new_blue)
return new_pix
source_image.draw(window)
#Set up Loops to Visit every pixel and do some work
for x in range(1, width):
for y in range(1, height):
#retrieve the current pixel
current_pixel = source_image.get_pixel(x, y)
shifted.set_pixel(x - 2, y - 2, current_pixel)
# if x % 3 == 0: #to speed up the animation
# source_image.draw(window) #animate the manipulation
shifted.draw(window)
for x in range(width):
for y in range(height):
pixel_one = source_image.get_pixel(x, y)
pixel_two = shifted.get_pixel(x, y)
avg_one = (pixel_one.get_red() + pixel_one.get_green() +
pixel_one.get_blue()) / 3
avg_two = (pixel_two.get_red() + pixel_two.get_green() +
pixel_two.get_blue()) / 3
if abs(avg_one - avg_two) > THRESHOLD:
source_image.set_pixel(x, y, image.Pixel(255, 0, 0))
#else:
#source_image.set_pixel(x,y,image.Pixel(255,255,255))
if x % 3 == 0: #to speed up the animation
source_image.draw(window)
source_image.draw(window)
def greyscale(pix):
r, g, b = pix.red, pix.green, pix.blue
avg = r // 3 + g // 3 + b // 3
new_pix = image.Pixel(avg, avg, avg)
return new_pix
def graypixel(oldpixel):
intensitysum = oldpixel.getRed() + oldpixel.getGreen() + oldpixel.getBlue()
aveRGB = intensitysum // 3
newPixel = image.Pixel(aveRGB, aveRGB, aveRGB)
return newPixel
height = img.get_height()
# make a window to draw on
win = image.ImageWin(width, height)
# draw the original image onto the window
img.draw(win)
# use a nested for loop to look at every pixel in the image
for x in range(width):
for y in range(height):
if y <= height / 2:
# get the current pixel
this_pixel = img.get_pixel(x, y)
else:
distance_from_midline = y - height / 2
this_pixel = img.get_pixel(x, height / 2 - distance_from_midline)
# access the amount of red, green and blue for this pixel
r = this_pixel.get_red()
g = this_pixel.get_green()
b = this_pixel.get_blue()
new_pixel = image.Pixel(r, g, b)
# reassign the pixel value in the image to be the changed version
img.set_pixel(x, y, new_pixel)
# draw the changed image to the window
img.draw(win)
import image
fg = image.Image('secret.png')
newIm = image.EmptyImage(fg.getWidth(), fg.getHeight())
for row in range(fg.getHeight()):
for col in range(fg.getWidth()):
fgpix = fg.getPixel(col, row)
fgr = fgpix.getRed()
if fgr % 2 == 0:
newPix = image.Pixel(255, 255, 255)
else:
newPix = image.Pixel(0, 0, 0)
newIm.setPixel(col, row, newPix)
win = image.ImageWin(500, 400)
newIm.draw(win)
win.exitonclick()
import image
img = image.Image("pika.png")
win = image.ImageWin(img.getWidth(), img.getHeight())
img.draw(win)
for y in range(img.getHeight()):
for x in range(img.getWidth()):
p = img.getPixel(x, y)
r = 255 - p.getRed()
g = 255 - p.getGreen()
b = 255 - p.getBlue()
newPixel = image.Pixel(r, g, b)
img.setPixel(x, y, newPixel)
img.draw(win)
win.exitonclick()
"""for i in range(5):
for j in range(3):
print(i,j)
print()
listOfWords = ["hello", "world", "have", "a", "nice", "day"]
for word in listOfWords:
for letter in word:
print(letter)
"""
def __setitem__(self, key, value):
r, g, b = value
x, y = key
self._parent._image.updatePixel(_image_module.Pixel(r, g, b, x, y))
import image
win = image.ImageWin(640, 480, "Image Processing")
myPic = image.EmptyImage(100, 100)
for x in range(myPic.getWidth()):
for y in range(myPic.getHeight()):
myPic.setPixel(x, y, image.Pixel(200, 255, 0))
myPic.draw(win)
win.exit_on_click()
