Modifying pictures with loops

Transcription

1 Chapter 3 Modifying pictures with loops We are now ready to work with the pictures. From a programming perspective. So far, the only structure we have done is sequential. For example, the following function def pickandshow(): myfile=pickafile() mypict=makepicture(myfile) show(mypict) is executed as a one-pass sequence. Sometimes, we need more general and flexible structures, such as conditional and loop. Let s have a look. 1

2 Control Structures There are three basic structures in any highlevel programs: sequential, conditional and repetitive. Below is an example of a sequential structure. Get up; Having breakfast; Having a class; Having the next class; Having lunch; Having another class; Having one more class; Having supper; Watching TV; Go to bed; 2

3 Conditional operation The conditional operation lets the algorithm to ask a question, and, based on the answer, selects the next operation to perform. Below is the most commonly used structure. If "a true-false" condition is true Then first set of operations Else second set of operations. It evaluates the condition first to see if it is true or false, and then executes the first, or the second set, of operations, accordingly. In either case, continues with the next operation. 3

4 An example 1. Get values for gallons, start and end 2. Set the value of distance to (end start) 3. Set the value of average to (distance/gallons) 4. Print the value of average 5. If average > 25.0 Then 6. Print the massage You are getting good gas mileage. 7. Else Print the massage You are not getting a good gas mileage. 8. Stop 4

5 Iterative operation An iterative operation repeats a block of operations, i.e., Repeat step i to step j until a "condition" becomes true step i: operation step i+1: operation... step j: operation It performs all operations from step i to step j, inclusive, until the condition becomes true. The block from step i to step j is called the loop body, and the condition is called a termination condition, which is used to control the loop. 5

6 An example 1. Repeat step 2 to step 10 until response is no 2. Get values for gallons, start and end 3. Set the value of distance to (end start) 4. Set the value of average to (distance/gallons) 5. Print the value of average 6. If average > 25.0 Then 7. Print the massage You are getting good gas mileage. 8. Else Print the massage You are not getting a good gas mileage. 9. Print the massage Do you want to repeat? 10. Get a value for response from the user 11. Stop 6

7 More iterative structure The following prints out 1 through 10: int count = 1; while (count <= 10){ cout << count; count = count + 1; } It can also be done with the following: for (count=1; count <= 10; count++){ cout << count; } 7

8 Image representation Before discussing media processing, we have to understand better how a picture is represented. JPEG is one way to represent an image, which is an international standard to store images with high quality but less space. It is a lossy representation in the sense that it does not store 100% of the original information by throwing away some of the unnecessary information. For all the practical purposes, a JPEG file works just fine. In a bit more details, a JPEG file is kept in a 2 dimensional matrix, which is a sequence of elements each with an associated index number. When we use such a matrix to represent a picture, each element is called a pixel, i.e., an element of picture, which is identified with a coordinate, such as (231, 125). 8

9 An example Below shows the cursor, and the close-up view of the cursor and that of the line below the cursor. The following Python expression identifies the pixel (10, 100) of a picture pict: getpixl(pict, 10, 100) We can also use the built-in Picture Tool to identify the coordinate of any pixel within a chosen picture. 9

10 How could this happen? It turns out that our sensory apparatus can t distinguish small bits out of a whole. We simply can t see much details as well as an eagle. We also have a different system for processing a color image from that for processing a blackand-white image (luminance). We use the latter to detect motion and size of an object. This lack of resolution is what makes picture digitization possible: We simply break up (digitize) an image to a whole bunch of pixels, and can t really tell the difference between the two, when there are enough of them. 10

11 How about the color? When we use a matrix to represent a color picture, each pixel is also associated with a color, which is a combination of three basic ones, red, green, and blue, according to the RGB Color model. We usually use one byte to represent each color. Thus, using three bytes for three colors, we can come up with 2 24, about 16 million different colors. 11

12 Other models CMYB is another model for color in which any color is decomposed as a combination of four basics ones: Cyan, Magenta, Yellow, and Black. It is often used in the printers. Yet another one is the HSV, in which a color is represented as a combination of three ingredients: Hue (type of the color), Saturation (gray to dark) and Value (brightness): 12

13 Different colors For example, (0, 0, 0) represents black; (255, 255, 255) represents white; (50, 50, 50) represents dark gray; and (100, 100, 100) a bit lighter. Below shows a matrix of 8 pixels, with different colors and their codes. 13

14 How big is it? Once we have identified a picture object (How?), we can find out its size, i.e., its width and height in terms of the number of pixels, with the getwidth and getheight commands as follows: >>>print getwidth(pict) >>>print getheight(pict) In general, given a picture pict, getwidth(pict) finds out the number of columns and getheight finds out the number of rows. Let s check it out with, e.g., arch.jpg. 14

15 Get and set the color We manipulate a picture in Python by making a picture object out of a JPEG file, then changing the properties, mainly the colors, of the pixels of that picture. To get the color of a pixel of a picture object, pict, we use the following expression: >>>pixel1=getpixel(pict, 1, 100) >>>print getcolor(pixel1) To get just the green component, we say >>>print getgreen(getpixel(pict, 1, 100)) To set the color of the above pixel to yellow, we can do the following: >>>setcolor(pixel1, yellow) Question: Did we do it? 15

16 Another example Let s see what does the following sequence do, with the Picture Tool. Assume that we have picked an image file to work with, we might have the following session: >>>pixel2=getpixel(pict, 1, 1) >>>print pixel2 Pixel, color=color r=214 g=165 b=132 >>>print getx(pixel2) 1 >>>print gety(pixel2) 1 >>>print getred(pixel2)

17 >>>color=getcolor(pixel2) >>>print color color r=214 g=165 b=132 >>>newcolor=makecolor(0, 100, 0) >>>print newcolor color r=0 g=100 b=0 >>>setcolor(pixel2, newcolor) >>>print getcolor(pixel2) color r=0 g=100 b=0 >>>show(pict) 17

18 A bit more yellow If we want to set the colors of five adjacent pixels to yellow, we could do the following: def ABitYellow(): file=pickafile() pict=makepicture(file) show(pict) setcolor(getpixel(pict, 11, 100), yellow) setcolor(getpixel(pict, 11, 101), yellow) setcolor(getpixel(pict, 11, 102), yellow) setcolor(getpixel(pict, 11, 103), yellow) setcolor(getpixel(pict, 11, 104), yellow) repaint(pict) show(pict) It is clear that the above is just a sequential structure. Let s check out if it works. 18

19 How to work on the whole thing? We often want to process the whole picture, i.e., all the pixels. It will be pretty boring, even impossible, to process one pixel at a time, for 10,000 pixels. Now, the iterative structure kicks right in, which takes over the boring part. For example, we can use the following program to make a picture less red. def decreasered(picture): for pixel in getpixels(picture): value = getred(pixel) setred(pixel, value*0.5) The above code, for all the pixels, one by one, gets the red component of its color, cuts it by half, then sends it back. Homework: 3.3,

20 A bit more details The key instruction in the above program is the following: for pixel in getpixels(picture): value = getred(pixel) setred(pixel, value*0.5) In the above the first line for pixel in getpixels(picture): specifies what data to process within the loop. Here we want to process all the pixels we may get out of the picture object picture. The variable name pixel refers to a value returned by the function getpixel, which is to get each and every pixel from the picture. Although we can use any name, such as p, x, y, etc to refer to a pixel, pixel looks pretty natural. 20

21 The loop structure Moreover, the word for in this first line indicates a loop. In fact, all the pixels are lined up in a sequence, all the pixels in the first line, followed by all in the second line,..., followed by all the pixels in the last line. With the for loop, all the pixels will be taken in in this order: the loop begins with the first one, do something with it, then moves to the next pixel, do exactly the same thing,..., until it gets the last pixel, do the same thing, and quits. Question: How does the computer know what to do with a pixel when it is taken in? Answer: The next part takes care of it. 21

22 The loop body The next segment is the loop body. value = getred(pixel) setred(pixel, value*0.5) This part tells what to do in each iteration of this loop. For this specific example, it states that, for each value of pixel, or for each pixel, we want to get out its red component, chop it off by 50%, then set this value back. This is equivalent to say we decrease the red component of each pixel by half. Let s see what it does. 22

23 How does it work? Below is the original picture of a fish pond: Now the changed picture Homework: 3.2,

24 Take out the blue We can also clear away the blue component of all the pixels, by setting the blue component of all the pictures to 0, as follows: def clearblue(picture): for p in getpixels(picture): setblue(p, 0) Question: What will the picture look like? Answer: Let s see. Homework: 3.7 and

25 Add something on It is pretty easy to use Python to do some image doctoring. For example, we might want to add a sunset effect to a beach picture, using the following code. def makesunset(picture): for p in getpixels(picture): value=getblue(p) setblue(p, value*0.7) value=getgreen(p) setgreen(p, value*0.7) The idea is to take off 30% of the blue and green to let the red stand out. Let s see what it does to a picture. Question: What happens if we simply add on more red, rather than taking off both green and blue, say, by 30%? Homework:

26 Add a bit sunshine Below is the original picture of a beach: and the same one at sunset: 26

27 An alternative way An important concept in programming is called modular programming, which means that one function does one and only one thing. Thus, we might solve the sunset problem as follows: def makesunset(picture): reduceblue(picture) reducegreen(picture) def reduceblue(picture): for p in getpixels(picture): value=getblue(p) setblue(p, value*0.7) def reducegreen(picture): for p in getpixels(picture): value=getgreen(p) setblue(p, value*0.7) 27

28 A couple of notes 1. We call such an idea hierarchical decomposition, or divide and conquer. This is a pretty useful concept. To solve something big and/or complicated, we cut it into a bunch of smaller and/or easier ones, solve them one by one, and then combine the solution. 2. Although the same name p occurs in all the three functions, they have nothing to do with each other. They are local in each function. 3. The three functions constitute one program, thus, they should be entered in the same file, and get loaded together. 28

29 Python also provides two functions, makelighter and makedarker that lighten and darken the color of a pixel, respectively. Below shows a program that makes use of the makelighter feature. def lighten(picture): for px in getpixels(picture): color=getcolor(px) makelighter(color) setcolor(px, color) 29

30 Create a negative image It is pretty easy to write a program to get the negative image of a picture object, as follows. It simply get the negative value of the color of each and every pixel of the involved picture. def negative(picture): for px in getpixels(picture): red=getred(px) green=getgreen(px) blue=getblue(px) negcolor=makecolor(255-red,255-green,255-blue) setcolor(px, negcolor) 30

31 Convert to grayscale Nowadays, when we take a picture, we often use a color camera. But, sometimes we really miss the old-fashioned black-and-white picture. It turns out pretty easy to do such a conversion if you have digitized that picture. What we could do is to average the three color components for all the pixels as follows: def grayscale1(picture): for px in getpixels(picture): in=(getred(px)+getgreen(px)+getblue(px))/3 setcolor(px, makecolor(in, in, in)) It does work, but it turns out that we could do better, if we take into consideration that we perceives blue to be darker than red, even if they share the same amount. Thus, we should give blue less weight, and more to red, and even more to green, when calculating the average. 31

32 A better way We thus come to the following revised program for the gray scale conversion. def grayscale(picture): for px in getpixels(picture): newred=getred(px)*0.299 newgreen=getgreen(px)*0.587 newblue=getblue(px)*0.114 luminance = newred+newgreen+newblue setcolor(px, makecolor (luminance, luminance, luminance)) Homework: 3.9 and