Chapter 6: Modifying Pixels by Position Introduction to Computing and Programming in Python: A Multimedia Approach 4ed Chapter 6: Modifying Pixels by Position

Chapter Learning Goals

Chapter Learning Goals

There are four conditional statements in this program for turning the red flowers in the arch into moon-colored flowers. One of the generated this image. Which one? #3

Pixels are in a matrix Matrices have two dimensions: A height and a width We can reference any element in the matrix with (x,y) or (horizontal, vertical) We refer to those coordinates as index numbers or indices We sometimes want to know where a pixel is, and getPixels doesn't let us know that.

Arrays vs Matrices

Pixels in a Matrix >>> h = makePicture("horse.jpg") >>> print getHeight(h) 640 >>> print getWidth(h) 480 >>> print getPixel(h,0,0) Pixel red=62 green=78 blue=49 >>> print getPixel(h,479,639) Pixel red=113 green=89 blue=77 >>> print getPixel(h,480,640) getPixel(picture,x,y): x (= 480) is less than 0 or bigger than the width (= 479) The error was: Inappropriate argument value (of correct type). An error occurred attempting to pass an argument to a function.

Indices from the function range Range returns a sequence between its first two inputs, possibly using a third input as the increment >>> print range(1,4) [1, 2, 3] >>> print range(-1,3) [-1, 0, 1, 2] >>> print range(1,10,2) [1, 3, 5, 7, 9] >>> print range(3) [0,1,2] Notice: End value is never included. range(0,10) ends at 9. If you leave out a start value, it's assumed to be zero.

Side Note: That thing in [] is a sequence >>> print a [1, 2, 3] >>> a = a + 4 An attempt was made to call a function with a parameter of an invalid type >>> a = a + [4] [1, 2, 3, 4] >>> a[0] 1 We can assign names to sequences, print them, add items to sequences, and access individual pieces of them. We can also use for loops to process each element of a sequence.

We can use range to generate index numbers We'll do this by working the range from 0 to the height-1, and 0 to the width-1. Using the range function will make it easy to start from 0 and stop before the end value. But we'll need more than one loop. Each for loop can only change one variable, and we need two for indexing a matrix

Working the pixels by number To use range, we'll have to use nested loops One to walk the width, the other to walk the height Be sure to watch your blocks (i.e., indentation) carefully! def increaseRed2(picture): for x in range(0,getWidth(picture)): for y in range(0,getHeight(picture)): px = getPixel(picture,x,y) value = getRed(px) setRed(px,value*1.1)

What's going on here? def increaseRed2(picture): for x in range(0,getWidth(picture)): for y in range(0,getHeight(picture)): px = getPixel(picture,x,y) value = getRed(px) setRed(px,value*1.1) The first time through the first loop, x is the name for 0. We'll be processing the first column of pixels in the picture.

Now, the inner loop def increaseRed2(picture): for x in range(0,getWidth(picture)): for y in range(0,getHeight(picture)): px = getPixel(picture,x,y) value = getRed(px) setRed(px,value*1.1) Next, we set y to 0. We're now going to process each of the pixels in the first column.

Process a pixel def increaseRed2(picture): for x in range(0,getWidth(picture)): for y in range(0,getHeight(picture)): px = getPixel(picture,x,y) value = getRed(px) setRed(px,value*1.1) With x = 0 and y = 0, we get the leftmost pixel and increase its red by 10%

Next pixel def increaseRed2(picture): for x in range(0,getWidth(picture)): for y in range(0,getHeight(picture)): px = getPixel(picture,x,y) value = getRed(px) setRed(px,value*1.1) Next we set y to 1 (next value in the sequence range(0,getHeight(picture))

Process pixel (0,1) def increaseRed2(picture): for x in range(0,getWidth(picture)): for y in range(0,getHeight(picture)): px = getPixel(picture,x,y) value = getRed(px) setRed(px,value*1.1) x is still 0, and now y is 1, so increase the red for pixel (0,1) We continue along this way, with y taking on every value from 0 to the height of the picture (minus 1).

Finally, next column def increaseRed2(picture): for x in range(0,getWidth(picture)): for y in range(0,getHeight(picture)): px = getPixel(picture,x,y) value = getRed(px) setRed(px,value*1.1) Now that we're done with the loop for y, we get back to the FOR loop for x. x takes on the value 1, and we go back to the y loop to process all the pixels in the column x=1.

Lightening a Picture with Nested Loops def lighten2(picture): for x in range(0,getWidth(picture)): for y in range(0,getHeight(picture)): px = getPixel(picture,x,y) color = getColor(px) color = makeLighter(color) setColor(px,color)

A B Which function did A? #1 is A. #3 is B

Reducing Red Eye with Nested Loops def removeRedEye2(pic,sX,sY,eX,eY,endColor): for x in range(sX,eX): for y in range(sY,eY): px = getPixel(pic,x,y) if (distance(red,getColor(px)) < 165): setColor(px,endColor) This version is far faster than the previous version

Timing from time import clock def yellowbox1(pict): start = clock() for px in getPixels(pict): x = getX(px) y = getY(px) if 10 <= x < 20 and 10 <= y < 20: setColor(px,yellow) print "Time:",clock()-start def yellowbox2(pict): for x in range(10,20): for y in range(10,20): setColor(getPixel(pict,x,y),yellow) >>> b = makePicture("bridge.jpg") >>> b Picture, filename /Users/guzdial/Desktop/mediasources-4ed/bridge.jpg height 640 width 480 >>> yellowbox1(b) Time: 1.317775 >>> yellowbox2(b) Time: 0.00316000000001

What can you do if you know where the pixels are? One answer: Mirroring Imagine a mirror horizontally across the picture, or vertically What would we see? How do generate that digitally? We simply copy the colors of pixels from one place to another

Work it out with matrices mirrorPoint is halfway across: getWidth(picture)/2 If left pixel is at (x,y), right pixel is at (width-x-1,y)

Recipe for mirroring def mirrorVertical(source): mirrorPoint = getWidth(source) / 2 width = getWidth(source) for y in range(0,getHeight(source)): for x in range(0,mirrorPoint): leftPixel = getPixel(source,x,y) rightPixel = getPixel(source,width - x - 1,y) color = getColor(leftPixel) setColor(rightPixel,color)

Can we do it with a horizontal mirror? def mirrorHorizontal(source): mirrorPoint = getHeight(source) / 2 height = getHeight(source) for x in range(0,getWidth(source)): for y in range(0,mirrorPoint): topPixel = getPixel(source,x,y) bottomPixel = getPixel(source,x,height - y - 1) color = getColor(topPixel) setColor(bottomPixel,color)

Of course!

What if we wanted to copy bottom to top? Very simple: Swap the order of pixels in the bottom lines def mirrorBotTop(source): mirrorPoint = getHeight(source) / 2 height = getHeight(source) for x in range(0,getWidth(source)): for y in range(0,mirrorPoint): topPixel = getPixel(source,x,y) bottomPixel = getPixel(source,x,height - y - 1) color = getColor(bottomPixel) setColor(topPixel,color)

Mirroring bottom to top

Doing something useful with mirroring Mirroring can be used to create interesting effects, but it can also be used to create realistic effects. Consider this image from a trip to Athens, Greece. Can we “repair” the temple by mirroring the complete part onto the broken part?

Figuring out where to mirror Use MediaTools to find the mirror point and the range that we want to copy

Writing functions for specific files…generally The function to mirror the temple needs to work for one and only one file. But we still don't want to write out the whole path. setMediaPath() allows us to pick a directory where our media will be stored. getMediaPath(filename) will generate the entire path for us to the filename in the media directory THIS ONLY WORKS WHEN WE'RE ACCESSING FILES IN THE MEDIA DIRECTORY AND WHERE WE HAVE SET THE PATH FIRST!

Some Utility Functions If you know the name of the file, searching for it with pickAFile() feels tedious You can set and get a media folder (path) for remembering a place where your media will be coming from (or going to) setMediaPath() lets you pick a file in your media folder getMediaPath(basefilename) lets you generate a complete filename out of only the last part

Example >>> setMediaPath() New media folder: C:\Documents and Settings\Mark Guzdial\My Documents\mediasources\ >>> getMediaPath("barbara.jpg") 'C:\\Documents and Settings\\Mark Guzdial\\My Documents\\mediasources\\barbara.jpg' >>> barb=makePicture(getMediaPath("barbara.jpg"))

Program to mirror the temple def mirrorTemple(): source = makePicture(getMediaPath("temple.jpg")) mirrorPoint = 276 for x in range(13,mirrorPoint): for y in range(27,97): pleft = getPixel(source,x,y) pright = getPixel(source,mirrorPoint + mirrorPoint - 1 - x,y) setColor(pright,getColor(pleft)) show(source) return source

Did it really work? It clearly did the mirroring, but that doesn't create a 100% realistic image. Check out the shadows: Which direction is the sun coming from?

Understanding the Temple Fix What is the very first transfer of pixels from and to? Which (x,y) pixel from? Which (x,y) pixel to? What is second? How many pixels get copied?

Adding print statements to see what's happening def mirrorTemple(): source = makePicture(getMediaPath("temple.jpg")) mirrorPoint = 276 for x in range(13,mirrorPoint): for y in range(27,97): print "Copying color from",x,y, " to ",mirrorPoint + mirrorPoint - 1 - x, y pleft = getPixel(source,x,y) pright = getPixel(source,mirrorPoint + mirrorPoint - 1 - x,y) setColor(pright,getColor(pleft)) show(source) return source

First pixels are either side of the mirrorpoint, then moving down >>> p2=mirrorTemple() Copying color from 13 27 to 538 27 Copying color from 13 28 to 538 28 Copying color from 13 29 to 538 29

Counting pixels def mirrorTemple(): source = makePicture(getMediaPath("temple.jpg")) mirrorPoint = 276 count = 0 for x in range(13,mirrorPoint): for y in range(27,97): pleft = getPixel(source,x,y) pright = getPixel(source,mirrorPoint + mirrorPoint - 1 - x,y) setColor(pright,getColor(pleft)) count = count + 1 show(source) print "We copied",count,"pixels" return source

Counting pixels Where did that come from? >>> p2=mirrorTemple() We copied 18410 pixels Where did that come from? How many rows? Y goes from 27 to 97 = 70 rows of pixels How many columns? X goes from 13 to 276 = 263 columns of pixels 70 * 263 = 18410

A Which function did A? #1 is A.

A B The same function below did the two pictures, but with one line difference. Which one did which picture? #2 is A. #3 is B

Replacing colors in a range def turnRedInRange(): brown = makeColor(57,16,8) file=“/Users/guzdial/mediasources/barbara.jpg" picture=makePicture(file) for x in range(70,168): for y in range(56,190): px=getPixel(picture,x,y) color = getColor(px) if distance(color,brown)<50.0: redness=getRed(px)*1.5 setRed(px,redness) show(picture) return(picture) Get the range using MediaTools

Walking this code Like last time: Don't need input, same color we want to change, same file, make a picture def turnRedInRange(): brown = makeColor(57,16,8) file=“/Users/guzdial/mediasources/barbara.jpg" picture=makePicture(file) for x in range(70,168): for y in range(56,190): px=getPixel(picture,x,y) color = getColor(px) if distance(color,brown)<50.0: redness=getRed(px)*1.5 setRed(px,redness) show(picture) return(picture)

The nested loop I used MediaTools to find the rectangle where most of the hair is that I want to change def turnRedInRange(): brown = makeColor(57,16,8) file=“/Users/guzdial/mediasources/barbara.jpg“ picture=makePicture(file) for x in range(70,168): for y in range(56,190): px=getPixel(picture,x,y) color = getColor(px) if distance(color,brown)<50.0: redness=getRed(px)*1.5 setRed(px,redness) show(picture) return(picture)

Same thing as last time (could raise threshold now) Then we're looking for a close-match on hair color, and increasing the redness def turnRedInRange(): brown = makeColor(57,16,8) file=“/Users/guzdial/mediasources/barbara.jpg“ picture=makePicture(file) for x in range(70,168): for y in range(56,190): px=getPixel(picture,x,y) color = getColor(px) if distance(color,brown)<50.0: redness=getRed(px)*1.5 setRed(px,redness) show(picture) return(picture)

Could we do this without nested loops? Yes, but complicated IF def turnRedInRange2(): brown = makeColor(57,16,8) file=“/Users/guzdial/mediasources/barbara.jpg“ picture=makePicture(file) for p in getPixels(picture): x = getX(p) y = getY(p) if x >= 70 and x < 168: if y >=56 and y < 190: color = getColor(p) if distance(color,brown)<100.0: redness=getRed(p)*2.0 setRed(p,redness) show(picture) return picture

Moving pixels across pictures We've seen using index variables to track the pixel position we're working with in a picture. We can copy between pictures, if we keep track of: The source index variables Where we're getting the pixels from The target index variables Where we're putting the pixels at (Not really copying the pixels: Replicating their color.)

What can you do then? What can you do when copying from one picture to another? Collages: Copy several pictures onto one Cropping: You don't have to take the whole picture Scaling: Make a picture smaller, or larger when copying it

Copying pixels In general, what we want to do is to keep track of a sourceX and sourceY, and a targetX and targetY. We increment (add to them) in pairs sourceX and targetX get incremented together sourceY and targetY get incremented together The tricky parts are: Setting values inside the body of loops Incrementing at the bottom of loops

Copying Barb to a canvas def copyBarb(): # Set up the source and target pictures barbf=getMediaPath("barbara.jpg") barb = makePicture(barbf) canvasf = getMediaPath("7inX95in.jpg") canvas = makePicture(canvasf) # Now, do the actual copying targetX = 0 for sourceX in range(0,getWidth(barb)): targetY = 0 for sourceY in range(0,getHeight(barb)): color = getColor(getPixel(barb,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 show(barb) show(canvas) return canvas

Comments Python ignores from “#” through the rest of the line If you start a line with “#”, the whole line is ignored Why do we want lines to be ignored? To be able to leave notes to ourselves or someone else about how the program works

Walking through the copying function First, get the source (barb) and target (canvas) files and pictures as names we can use later. def copyBarb(): # Set up the source and target pictures barbf=getMediaPath("barbara.jpg") barb = makePicture(barbf) canvasf = getMediaPath("7inX95in.jpg") canvas = makePicture(canvasf) # Now, do the actual copying targetX = 0 for sourceX in range(0,getWidth(barb)): targetY = 0 for sourceY in range(0,getHeight(barb)): color = getColor(getPixel(barb,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 show(barb) show(canvas) return canvas

The actual copy We get the color of the pixel at sourceX and sourceY def copyBarb(): # Set up the source and target pictures barbf=getMediaPath("barbara.jpg") barb = makePicture(barbf) canvasf = getMediaPath("7inX95in.jpg") canvas = makePicture(canvasf) # Now, do the actual copying targetX = 0 for sourceX in range(0,getWidth(barb)): targetY = 0 for sourceY in range(0,getHeight(barb)): color = getColor(getPixel(barb,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 show(barb) show(canvas) return canvas We get the color of the pixel at sourceX and sourceY We set (copy) the color to the pixel in the target picture at targetX and targetY

Setting up the copy loop def copyBarb(): # Set up the source and target pictures barbf=getMediaPath("barbara.jpg") barb = makePicture(barbf) canvasf = getMediaPath("7inX95in.jpg") canvas = makePicture(canvasf) # Now, do the actual copying targetX = 0 for sourceX in range(0,getWidth(barb)): targetY = 0 for sourceY in range(0,getHeight(barb)): color = getColor(getPixel(barb,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 show(barb) show(canvas) return canvas targetX gets set to 0 at the beginning sourceX will range across the width of the source picture INSIDE the loop, we set targetY to 0 Inside because we want it to start at 0 each time we do a new X sourceY will range from 0 to one less height of source

Ending the loop def copyBarb(): # Set up the source and target pictures barbf=getMediaPath("barbara.jpg") barb = makePicture(barbf) canvasf = getMediaPath("7inX95in.jpg") canvas = makePicture(canvasf) # Now, do the actual copying targetX = 0 for sourceX in range(0,getWidth(barb)): targetY = 0 for sourceY in range(0,getHeight(barb)): color = getColor(getPixel(barb,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 show(barb) show(canvas) return canvas Just before we end the sourceY loop, we increment targetY It's now set up for the next time through the loop It's set correctly for the next value of sourceY Just before we end the sourceX loop, we increment the targetX Note carefully the indentation to figure out which goes with which loop

What's this naming something as itself? targetX = targetX + 1 This isn't really naming something as itself targetX + 1 is evaluated It will result in the number after targetX targetX = then sets the value of targetX The result is that targetX gets incremented by 1

Ending the copy function def copyBarb(): # Set up the source and target pictures barbf=getMediaPath("barbara.jpg") barb = makePicture(barbf) canvasf = getMediaPath("7inX95in.jpg") canvas = makePicture(canvasf) # Now, do the actual copying targetX = 0 for sourceX in range(0,getWidth(barb)): targetY = 0 for sourceY in range(0,getHeight(barb)): color = getColor(getPixel(barb,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 show(barb) show(canvas) return canvas At the very end, we show the source and target And return the modified target.

Works either way def copyBarb2(): # Set up the source and target pictures barbf=getMediaPath("barbara.jpg") barb = makePicture(barbf) canvasf = getMediaPath("7inX95in.jpg") canvas = makePicture(canvasf) # Now, do the actual copying sourceX = 0 for targetX in range(0,getWidth(barb)): sourceY = 0 for targetY in range(0,getHeight(barb)): color = getColor(getPixel(barb,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) sourceY = sourceY + 1 sourceX = sourceX + 1 show(barb) show(canvas) return canvas As long as we increment sourceX and targetX together, and sourceY and targetY together, it doesn't matter which is in the for loop and which is incremented via expression

Copying into the middle of the canvas def copyBarbMidway(): # Set up the source and target pictures barbf=getMediaPath("barbara.jpg") barb = makePicture(barbf) canvasf = getMediaPath("7inX95in.jpg") canvas = makePicture(canvasf) # Now, do the actual copying targetX = 100 for sourceX in range(0,getWidth(barb)): targetY = 100 for sourceY in range(0,getHeight(barb)): color = getColor(getPixel(barb,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 show(barb) show(canvas) return canvas

Copying a Horse to a Canvas def copyHorse(): # Set up the source and target pictures src = makePicture("horse.jpg") canvas = makeEmptyPicture(1000,1000) # Now, do the actual copying targetX = 0 for sourceX in range(0,getWidth(src)): targetY = 0 for sourceY in range(0,getHeight(src)): color = getColor(getPixel(src,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 show(src) show(canvas) return canvas

Copying another way def copyHorse2(): # Set up the source and target pictures src = makePicture("horse.jpg") canvas = makeEmptyPicture(1000,1000) # Now, do the actual copying sourceX = 0 for targetX in range(0,getWidth(src)): sourceY = 0 for targetY in range(0,getHeight(src)): color = getColor(getPixel(src,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) sourceY = sourceY + 1 sourceX = sourceX + 1 show(src) show(canvas) return canvas

Copying to a new Location def copyHorseMidway(): # Set up the source and target pictures src = makePicture("horse.jpg") canvas = makeEmptyPicture(1000,1000) # Now, do the actual copying targetX = 100 for sourceX in range(0,getWidth(src)): targetY = 200 for sourceY in range(0,getHeight(src)): color = getColor(getPixel(src,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 show(src) show(canvas) return canvas

Cropping just the Face def copyHorseFace(): # Set up the source and target pictures src = makePicture("horse.jpg") canvas = makeEmptyPicture(1000,1000) # Now, do the actual copying targetX = 100 for sourceX in range(104,267): targetY = 200 for sourceY in range(114,422): color = getColor(getPixel(src,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 #show(src) show(canvas) return canvas

Same cropping, different loops def copyHorseFace2(): # Set up the source and target pictures src=makePicture("horse.jpg") canvas = makeEmptyPicture(1000,1000) # Now, do the actual copying sourceX = 104 for targetX in range(100,100+163): sourceY = 114 for targetY in range(200,200+308): color = getColor(getPixel(src,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) sourceY = sourceY + 1 sourceX = sourceX + 1 show(canvas) return canvas

Copying: How it works Here's the initial setup:

Copying: How it works 2 After incrementing the sourceY and targetY once (whether in the for or via expression):

Copying: How it works 3 After yet another increment of sourceY and targetY: When we finish that column, we increment sourceX and targetX, and start on the next column.

Copying: How it looks at the end Eventually, we copy every pixel

Making a collage Could we do something to the pictures we copy in? Sure! Could either apply one of those functions before copying, or do something to the pixels during the copy. Could we copy more than one picture! Of course! Make a collage!

Page 170-171 (4ed edition) #Third picture, flower1 negated negative(flower1) targetX=200 for sourceX in range(0,getWidth(flower1)): targetY=getHeight(canvas)-getHeight(flower1)-5 for sourceY in range(0,getHeight(flower1)): px=getPixel(flower1,sourceX,sourceY) cx=getPixel(canvas,targetX,targetY) setColor(cx,getColor(px)) targetY=targetY + 1 targetX=targetX + 1 #Fourth picture, flower2 with no blue clearBlue(flower2) targetX=300 for sourceX in range(0,getWidth(flower2)): targetY=getHeight(canvas)-getHeight(flower2)-5 for sourceY in range(0,getHeight(flower2)): px=getPixel(flower2,sourceX,sourceY) #Fifth picture, flower1, negated with decreased red decreaseRed(flower1) targetX=400 show(canvas) return(canvas) def createCollage(): flower1=makePicture(getMediaPath("flower1.jpg")) print flower1 flower2=makePicture(getMediaPath("flower2.jpg")) print flower2 canvas=makePicture(getMediaPath("640x480.jpg")) print canvas #First picture, at left edge targetX=0 for sourceX in range(0,getWidth(flower1)): targetY=getHeight(canvas)-getHeight(flower1)-5 for sourceY in range(0,getHeight(flower1)): px=getPixel(flower1,sourceX,sourceY) cx=getPixel(canvas,targetX,targetY) setColor(cx,getColor(px)) targetY=targetY + 1 targetX=targetX + 1 #Second picture, 100 pixels over targetX=100 for sourceX in range(0,getWidth(flower2)): targetY=getHeight(canvas)-getHeight(flower2)-5 for sourceY in range(0,getHeight(flower2)): px=getPixel(flower2,sourceX,sourceY) Page 170-171 (4ed edition)

Can we make that easier? The collage code is long, yet simple. It's the same thing over-and-over. We can generalize that copying loop, and with parameters, use it in many places. def copy(source, target, targX, targY): targetX = targX for sourceX in range(0,getWidth(source)): targetY = targY for sourceY in range(0,getHeight(source)): px=getPixel(source,sourceX,sourceY) tx=getPixel(target,targetX,targetY) setColor(tx,getColor(px)) targetY=targetY + 1 targetX=targetX + 1

Exact same collage! def createCollage2(): flower1=makePicture(getMediaPath("flower1.jpg")) print flower1 flower2=makePicture(getMediaPath("flower2.jpg")) print flower2 canvas=makePicture(getMediaPath("640x480.jpg")) print canvas #First picture, at left edge copy(flower1,canvas,0,getHeight(canvas)-getHeight(flower1)-5) #Second picture, 100 pixels over copy(flower2,canvas,100,getHeight(canvas)-getHeight(flower2)-5) #Third picture, flower1 negated negative(flower1) copy(flower1,canvas,200,getHeight(canvas)-getHeight(flower1)-5) #Fourth picture, flower2 with no blue clearBlue(flower2) copy(flower2,canvas,300,getHeight(canvas)-getHeight(flower2)-5) #Fifth picture, flower1, negated with decreased red decreaseRed(flower1) copy(flower1,canvas,400,getHeight(canvas)-getHeight(flower2)-5) return canvas

Make sure you have this Typed IN to Work From: Copy Any Pic

Bigger or Smaller? Does this function make the src bigger or smaller on the canvas? Increases size by 50% Decreases size by 50% Decreases size by 50% and skips some pixels in target Increases size by 50% and skips some pixels in target #4.

>>> c = makePicture("caterpillar >>> c = makePicture("caterpillar.jpg") >>> copyPicDifferent(c,c1,10,10) >>> explore(c1) >>> copyAnyPic(c,c1,10,10)

Transformation = Small changes in copying Making relatively small changes in this basic copying program can make a variety of transformations. Change the targetX and targetY, and you copy wherever you want Cropping: Change the sourceX and sourceY range, and you copy only part of the program. Rotating: Swap targetX and targetY, and you end up copying sideways Scaling: Change the increment on sourceX and sourceY, and you either grow or shrink the image.

Copying face to small canvas def copyHorseFaceSmall(): # Set up the source and target pictures src = makePicture("horse.jpg") canvas = makeEmptyPicture(163,308) # Now, do the actual copying targetX = 0 for sourceX in range(104,267): targetY = 0 for sourceY in range(114,422): color = getColor(getPixel(src,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 show(canvas) return canvas

Changing while copying def copyHorseFaceSmallBlack(): hcol = makeColor(216,169,143) # Set up the source and target pictures src = makePicture("horse.jpg") canvas = makeEmptyPicture(163,308) # Now, do the actual copying targetX = 0 for sourceX in range(104,267): targetY = 0 for sourceY in range(114,422): color = getColor(getPixel(src,sourceX,sourceY)) if distance(color,hcol) < 40: setColor(getPixel(canvas,targetX,targetY), black) else: setColor(getPixel(canvas,targetX,targetY), color) targetY = targetY + 1 targetX = targetX + 1 show(canvas) return canvas

Copying vs. Referencing >>> a = 100 >>> b = a >>> print a,b 100 100 >>> b = 200 100 200 >>> a = 300 300 200

Referencing works differently >>> pictureBarb = makePicture("barbara.jpg") >>> pixel1 = getPixelAt(pictureBarb,0,0) >>> print pixel1 Pixel red=168 green=131 blue=105 >>> anotherpixel = pixel1 >>> print anotherpixel >>> setColor(pixel1,black) Pixel red=0 green=0 blue=0

Making a collage Could we do something to the pictures we copy in? Sure! Could either apply one of those functions before copying, or do something to the pixels during the copy. Could we copy more than one picture! Of course! Make a collage!

Page 91-92 (2ed edition) #Third picture, flower1 negated negative(flower1) targetX=200 for sourceX in range(0,getWidth(flower1)): targetY=getHeight(canvas)-getHeight(flower1)-5 for sourceY in range(0,getHeight(flower1)): px=getPixel(flower1,sourceX,sourceY) cx=getPixel(canvas,targetX,targetY) setColor(cx,getColor(px)) targetY=targetY + 1 targetX=targetX + 1 #Fourth picture, flower2 with no blue clearBlue(flower2) targetX=300 for sourceX in range(0,getWidth(flower2)): targetY=getHeight(canvas)-getHeight(flower2)-5 for sourceY in range(0,getHeight(flower2)): px=getPixel(flower2,sourceX,sourceY) #Fifth picture, flower1, negated with decreased red decreaseRed(flower1) targetX=400 show(canvas) return(canvas) def createCollage(): flower1=makePicture(getMediaPath("flower1.jpg")) print flower1 flower2=makePicture(getMediaPath("flower2.jpg")) print flower2 canvas=makePicture(getMediaPath("640x480.jpg")) print canvas #First picture, at left edge targetX=0 for sourceX in range(0,getWidth(flower1)): targetY=getHeight(canvas)-getHeight(flower1)-5 for sourceY in range(0,getHeight(flower1)): px=getPixel(flower1,sourceX,sourceY) cx=getPixel(canvas,targetX,targetY) setColor(cx,getColor(px)) targetY=targetY + 1 targetX=targetX + 1 #Second picture, 100 pixels over targetX=100 for sourceX in range(0,getWidth(flower2)): targetY=getHeight(canvas)-getHeight(flower2)-5 for sourceY in range(0,getHeight(flower2)): px=getPixel(flower2,sourceX,sourceY) Page 91-92 (2ed edition)

Can we make that easier? The collage code is long, yet simple. It's the same thing over-and-over. We can generalize that copying loop, and with parameters, use it in many places. def copy(source, target, targX, targY): targetX = targX for sourceX in range(0,getWidth(source)): targetY = targY for sourceY in range(0,getHeight(source)): px=getPixel(source,sourceX,sourceY) tx=getPixel(target,targetX,targetY) setColor(tx,getColor(px)) targetY=targetY + 1 targetX=targetX + 1

Exact same collage! def createCollage2(): flower1=makePicture(getMediaPath("flower1.jpg")) print flower1 flower2=makePicture(getMediaPath("flower2.jpg")) print flower2 canvas=makePicture(getMediaPath("640x480.jpg")) print canvas #First picture, at left edge copy(flower1,canvas,0,getHeight(canvas)-getHeight(flower1)-5) #Second picture, 100 pixels over copy(flower2,canvas,100,getHeight(canvas)-getHeight(flower2)-5) #Third picture, flower1 negated negative(flower1) copy(flower1,canvas,200,getHeight(canvas)-getHeight(flower1)-5) #Fourth picture, flower2 with no blue clearBlue(flower2) copy(flower2,canvas,300,getHeight(canvas)-getHeight(flower2)-5) #Fifth picture, flower1, negated with decreased red decreaseRed(flower1) copy(flower1,canvas,400,getHeight(canvas)-getHeight(flower2)-5) return canvas

Rotating the copy def flipHorseSideways(): # Set up the source and target pictures src = makePicture("horse.jpg") canvas = makeEmptyPicture(1000,1000) # Now, do the actual copying targetX = 0 for sourceX in range(0,getWidth(src)): targetY = 0 for sourceY in range(0,getHeight(src)): color = getColor(getPixel(src,sourceX,sourceY)) # Change is here setColor(getPixel(canvas,targetY,targetX), color) targetY = targetY + 1 targetX = targetX + 1 show(canvas) return canvas

Rotating: How it works We increment the same, but we use targetX for the Y coordinate and targetY for the X coordinate

Rotate: How it ends Same amount of increment, even same values in the variables, but a different result.

Doing a real rotation def rotateHorseSideways(): # Set up the source and target pictures src = makePicture("horse.jpg") canvas = makeEmptyPicture(1000,1000) # Now, do the actual copying targetX = 0 width = getWidth(src) for sourceX in range(0,getWidth(src)): targetY = 0 for sourceY in range(0,getHeight(src)): color = getColor(getPixel(src,sourceX,sourceY)) # Change is here setColor(getPixel(canvas,targetY,width - targetX - 1), color) targetY = targetY + 1 targetX = targetX + 1 show(canvas) return canvas

Scaling Scaling a picture (smaller or larger) has to do with sampling the source picture differently When we just copy, we sample every pixel If we want a smaller copy, we skip some pixels We sample fewer pixels If we want a larger copy, we duplicate some pixels We over-sample some pixels

Scaling the horse face down def copyHorseFaceSmaller(): # Set up the source and target pictures src=makePicture("horse.jpg") canvas = makeEmptyPicture(82,155) # Now, do the actual copying sourceX = 104 for targetX in range(0,int(163/2)): sourceY = 114 for targetY in range(0,int(308/2)): color = getColor(getPixel(src,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) sourceY = sourceY + 2 sourceX = sourceX + 2 show(canvas) return canvas

Scaling the picture down def copyBarbsFaceSmaller(): # Set up the source and target pictures barbf=getMediaPath("barbara.jpg") barb = makePicture(barbf) canvasf = getMediaPath("7inX95in.jpg") canvas = makePicture(canvasf) # Now, do the actual copying sourceX = 45 for targetX in range(100,100+((200-45)/2)): sourceY = 25 for targetY in range(100,100+((200-25)/2)): color = getColor(getPixel(barb,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY), color) sourceY = sourceY + 2 sourceX = sourceX + 2 show(barb) show(canvas) return canvas

Scaling Up: Growing the picture To grow a picture, we simply duplicate some pixels We do this by incrementing by 0.5, but only use the integer part. >>> print int(1) 1 >>> print int(1.5) >>> print int(2) 2 >>> print int(2.5)

def copyHorseLarger(): # Set up the source and target pictures src = makePicture("horse.jpg") w = getWidth(src) h = getHeight(src) canvas = makeEmptyPicture(w*2,h*2) srcPixels = getPixels(src) trgPixels = getPixels(canvas) trgIndex = 0 # Now, do the actual copying for pixel in srcPixels: color = getColor(pixel) # Once trgPixel = trgPixels[trgIndex] setColor(trgPixel,color) trgIndex = trgIndex + 1 # Twice show(canvas) return canvas Scaling up

Scaling up just the Face def copyHorseFaceLarger(): # Set up the source and target pictures src=makePicture("horse.jpg") canvas = makeEmptyPicture(163*2,308*2) # Now, do the actual copying sourceX = 104 for targetX in range(0,163*2): sourceY = 114 for targetY in range(0,308*2): srcpx = getPixel(src,int(sourceX),int(sourceY)) color = getColor(srcpx) setColor(getPixel(canvas,targetX,targetY), color) sourceY = sourceY + 0.5 sourceX = sourceX + 0.5 show(canvas) return canvas

Scaling the picture up def copyBarbsFaceLarger(): # Set up the source and target pictures barbf=getMediaPath("barbara.jpg") barb = makePicture(barbf) canvasf = getMediaPath("7inX95in.jpg") canvas = makePicture(canvasf) # Now, do the actual copying sourceX = 45 for targetX in range(100,100+((200-45)*2)): sourceY = 25 for targetY in range(100,100+((200-25)*2)): color = getColor(getPixel(barb,int(sourceX),int(sourceY))) setColor(getPixel(canvas,targetX,targetY), color) sourceY = sourceY + 0.5 sourceX = sourceX + 0.5 show(barb) show(canvas) return canvas

Scaling up: How it works Same basic setup as copying and rotating:

Scaling up: How it works 2 But as we increment by only 0.5, and we use the int() function, we end up taking every pixel twice. Here, the blank pixel at (0,0) in the source gets copied twice onto the canvas.

Scaling up: How it works 3 Black pixels gets copied once…

Scaling up: How it works 4 And twice…

Scaling up: How it ends up We end up in the same place in the source, but twice as much in the target. Notice the degradation: Gaps that weren't there previously Curves would get “choppy”: Pixelated

What to do? How do we clear up the degradation of scaling up? Variety of techniques, but mostly following the same basic idea: Use the pixels around to figure out what color a new pixel should be, then somehow (e.g., by averaging) compute the right color. Different techniques look at different pixels and compute different averages in different ways.

A simple Blur def blur(source): target=duplicatePicture(source) for x in range(1, getWidth(source)-1): for y in range(1, getHeight(source)-1): top = getPixel(source,x,y-1) left = getPixel(source,x-1,y) bottom = getPixel(source,x,y+1) right = getPixel(source,x+1,y) center = getPixel(target,x,y) newRed=(getRed(top)+ getRed(left) + getRed(bottom) + getRed(right) + getRed(center))/5 newGreen=(getGreen(top) + getGreen(left) + getGreen(bottom)+getGreen(right)+getGreen(center))/5 newBlue=(getBlue(top) + getBlue(left) + getBlue(bottom) + getBlue(right)+ getBlue(center))/5 setColor(center, makeColor(newRed, newGreen, newBlue))

A different blur We'll see pass and else later, but you can probably get a sense here of what's going on. def blur(pic,size): for pixel in getPixels(pic): currentX = getX(pixel) currentY = getY(pixel) r = 0 g = 0 b = 0 count = 0 for x in range(currentX - size,currentX + size): for y in range(currentY - size, currentY + size): if(x<0) or (y<0) or (x >= getWidth(pic)) or (y >=getHeight(pic)): pass # Skip if we go off the edge else: r = r + getRed(getPixel(pic,x,y)) g = g + getGreen(getPixel(pic,x,y)) b = b + getBlue(getPixel(pic,x,y)) count = count + 1 newColor = makeColor(r/count,g/count,b/count) setColor(pixel,newColor)

Blurring out the pixelation

Average from four sides, to compute new color

Things to try: Can you come up with general copy, rotate, copy, and scale functions? Take input pictures and parameters Return the canvas the correct transformation applied Also think about generalizing the transformations: Scaling up and down by non-integer amounts Rotating by something other than 90 degree increments

Blending pictures How do we get part of one picture and part of another to blur together, so that we see some of each? It's about making one a bit “transparent.” Video cards sometimes support this transparency in hardware, called an alpha level to each pixel. We do it as a weighted sum If it's 50-50, we take 50% of red of picture1's pixels + 50% of red of picture2's pixels, and so on for green and blue, across all overlapping pixels.

Example blended picture Blended here

Blending code (1 of 3) def blendPictures(): barb = makePicture(getMediaPath("barbara.jpg")) katie = makePicture(getMediaPath("Katie-smaller.jpg")) canvas = makePicture(getMediaPath("640x480.jpg")) #Copy first 150 columns of Barb sourceX=0 for targetX in range(0,150): sourceY=0 for targetY in range(0,getHeight(barb)): color = getColor(getPixel(barb,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY),color) sourceY = sourceY + 1 sourceX = sourceX + 1 Straightforward copy of 150 column's of Barb's picture

Blending code (2 of 3) #Now, grab the rest of Barb and part of Katie # at 50% Barb and 50% Katie overlap = getWidth(barb)-150 sourceX=0 for targetX in range(150,getWidth(barb)): sourceY=0 for targetY in range(0,getHeight(katie)): bPixel = getPixel(barb,sourceX+150,sourceY) kPixel = getPixel(katie,sourceX,sourceY) newRed= 0.50*getRed(bPixel)+0.50*getRed(kPixel) newGreen=0.50*getGreen(bPixel)+0.50*getGreen(kPixel) newBlue = 0.50*getBlue(bPixel)+0.50*getBlue(kPixel) color = makeColor(newRed,newGreen,newBlue) setColor(getPixel(canvas,targetX,targetY),color) sourceY = sourceY + 1 sourceX = sourceX + 1 Here's the trick. For each pixel, grab 50% of each red, green and blue

Blending code (3 of 3) # Last columns of Katie sourceX=overlap for targetX in range(150+overlap,150+getWidth(katie)): sourceY=0 for targetY in range(0,getHeight(katie)): color = getColor(getPixel(katie,sourceX,sourceY)) setColor(getPixel(canvas,targetX,targetY),color) sourceY = sourceY + 1 sourceX = sourceX + 1 show(canvas) return canvas

Drawing lines on Carolina def lineExample(): img = makePicture(pickAFile()) verticalLines(img) horizontalLines(img) show(img) return img def horizontalLines(src): for x in range(0,getHeight(src),5): for y in range(0,getWidth(src)): setColor(getPixel(src,y,x),black) def verticalLines(src): for x in range(0,getWidth(src),5): for y in range(0,getHeight(src)): setColor(getPixel(src,x,y),black) We can use the color name “black” – it's pre-defined for us.

Yes, some colors are already defined Colors defined for you already: black, white, blue, red, green, gray, lightGray, darkGray, yellow, orange, pink, magenta, and cyan

That's tedious That's slow and tedious to set every pixel you want to make lines and text, etc. What you really want to do is to think in terms of your desired effect (think about “requirements” and “design”)

New functions addText(pict,x,y,string) puts the string starting at position (x,y) in the picture addLine(picture,x1,y1,x2,y2) draws a line from position (x1,y1) to (x2,y2) addRect(pict,x1,y1,w,h) draws a black rectangle (unfilled) with the upper left hand corner of (x1,y1) and a width of w and height of h addRectFilled(pict,x1,y1,w,h,color) draws a rectangle filled with the color of your choice with the upper left hand corner of (x1,y1) and a width of w and height of h

The mysterious red box on the beach def addABox(): beach = makePicture(getMediaPath("beach-smaller.jpg")) addRectFilled(beach,150,150,50,50,red) show(beach) return beach

Example picture def littlepicture(): canvas=makePicture(getMediaPath("640x480.jpg")) addText(canvas,10,50,"This is not a picture") addLine(canvas,10,20,300,50) addRectFilled(canvas,0,200,300,500,yellow) addRect(canvas,10,210,290,490) return canvas

A thought experiment Look at that previous page: Which has a fewer number of bytes? The program that drew the picture The pixels in the picture itself. It's a no-brainer The program is less than 100 characters (100 bytes) The picture is stored on disk at about 15,000 bytes

Vector-based vs. Bitmap Graphical representations Vector-based graphical representations are basically executable programs that generate the picture on demand. Postscript, Flash, and AutoCAD use vector-based representations Bitmap graphical representations (like JPEG, BMP, GIF) store individual pixels or representations of those pixels. JPEG and GIF are actually compressed representations

Vector-based representations can be smaller Vector-based representations can be much smaller than bit-mapped representations Smaller means faster transmission (Flash and Postscript) If you want all the detail of a complex picture, no, it's not.

But vector-based has more value than that Imagine that you're editing a picture with lines on it. If you edit a bitmap image and extend a line, it's just more bits. There's no way to really realize that you've extended or shrunk the line. If you edit a vector-based image, it's possible to just change the specification Change the numbers saying where the line is Then it really is the same line That's important when the picture drives the creation of the product, like in automatic cutting machines

How are images compressed? Sometimes lossless using techniques like run length encoding (RLE) Instead of this: B B Y Y Y Y Y Y Y Y Y B B We could say “9 Y's” like this: B B 9 Y B B Lossy compression (like JPEG and GIF) loses detail, some of which is invisible to the eye.

When changing the picture means changing a program… In a vector-based drawing package, changing the drawing is changing a program. How could we reach in and change the actual program? We can using string manipulation The program is just a string of characters We want to manipulate those characters, in order to manipulate the program

Example programmed graphic If I did this right, we perceive the left half as lighter than the right half In reality, the end quarters are actually the same colors.

Building a programmed graphic def greyEffect(): file = getMediaPath("640x480.jpg") pic = makePicture(file) # First, 100 columns of 100-grey grey = makeColor(100,100,100) for x in range(1,100): for y in range(1,100): setColor(getPixel(pic,x,y),grey) # Second, 100 columns of increasing greyness greyLevel = 100 for x in range(100,200): grey = makeColor(greyLevel, greyLevel, greyLevel) greyLevel = greyLevel + 1 # Third, 100 colums of increasing greyness, from 0 greyLevel = 0 for x in range(200,300): grey = makeColor(greyLevel, greyLevel, greyLevel) for y in range(1,100): setColor(getPixel(pic,x,y),grey) greyLevel = greyLevel + 1 # Finally, 100 columns of 100-grey grey = makeColor(100,100,100) for x in range(300,400): return pic

Another Programmed Graphic def coolpic(): canvas=makePicture(getMediaPath("640x480.jpg")) for index in range(25,1,-1): color = makeColor(index*10,index*5,index) addRectFilled(canvas,0,0,index*10,index*10,color) show(canvas) return canvas

And another def coolpic2(): canvas=makePicture(getMediaPath("640x480.jpg")) for index in range(25,1,-1): addRect(canvas,index,index,index*3,index*4) addRect(canvas,100+index*4,100+index*3,index*8,index*10) show(canvas) return canvas

Why do we write programs? Could we do this in Photoshop? Maybe I'm sure that you can, but you need to know how. Could I teach you to do this in Photoshop? Maybe Might take a lot of demonstration But this program is an exact definition of the process of generating this picture It works for anyone who can run the program, without knowing Photoshop

We write programs to encapsulate and communicate process If you can do it by hand, do it. If you need to teach someone else to do it, consider a program. If you need to explain to lots of people how to do it, definitely use a program. If you want lots of people to do it without having to teach them something first, definitely use a program.