1 / 163

First Courses Workshop Day 1

First Courses Workshop Day 1. Mark Guzdial College of Computing Georgia Institute of Technology guzdial@cc.gatech.edu http://www.cc.gatech.edu/~mark.guzdial http://www.georgiacomputes.org. Workshop Plan-Day 1. 9 am: Introductions and overview of the workshop.

kahlilia
Download Presentation

First Courses Workshop Day 1

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. First Courses WorkshopDay 1 Mark Guzdial College of Computing Georgia Institute of Technology guzdial@cc.gatech.edu http://www.cc.gatech.edu/~mark.guzdial http://www.georgiacomputes.org

  2. Workshop Plan-Day 1 • 9 am: Introductions and overview of the workshop. • 9:30-10:30: Introduction to Media Computation using Python for Pictures: Basic Filters • 10:30-10:45: Break • 10:45-12:00: More Picture methods: Compositing and scaling images. • 12:00-1:00: Lunch • 1:00-2:00: Tackling a homework assignment in Media Computation. Making a collage. • 2:00-3:30: Introducing sound. • 3:30-3:45: Break • 3:45-4:30: Splicing sounds • 4:30-5:30: Tackling a homework assignment in Media Computation. Making music.

  3. Workshop Plan-Day 2 • 9-10:00 am: Explanation of Media Computation class structure. • 10:00-10:15: Break • 10:15-12:00: Movies in Media Computation: Implementing video special effects • 12:00-1:00: Lunch • 1-2:30: Tackling a homework assignment in Media Computation. Making a movie. • 2:30-2:45: Break • 2:45-4:15: Introducing computing through robotics in Python • 4:15-5:30: Tackling a homework assignment in robotics. Follow the light.

  4. Workshop Plan-Day 3 • 9-10:00 am: Overview of results of Media Computation. • Why a contextualized computing education approach for broadening participation in computing. • Support available for teachers for adopting, adapting, and assessing. • 10:00-10:15: Break • 10:15-12:00: Introducing objects in a Media Computation context: Turtles. • 12:00-1:00: Lunch • 1-2:30: Introducing Media Computation in Java: Images and Sounds • 2:30-2:45: Break • 2:45-4:00: Tackling a homework assignment in Media Computation with Java. Making a synchronized turtle dance. • 4:00-5:00: Java Media Computation for movies.

  5. Workshop Plan-Day 4 • 9-10:00 am: Introducing data structures (in Java) in a Media Computation approach • MIDI notes, then linked lists of MIDI. • 10:00-10:15: Break • 10:15-11:15: Linked lists and trees of pictures • A "scene graph" as a first tree. • 11:15-12:15: Simulations. • Using Turtles from the Wednesday lecture • Creating the wildebeests and villagers: Making movies from simulations • 12:15-1:15: Lunch • 1:15-2:30: Tackling a homework assignment in Media Computation with Java. Creating linked list music or Making a movie with sound or Modifying a Simulation. • 2:30-2:45: Break • 2:45-3:15: Introducing Computing in an Engineering Context with MATLAB • 3:15-4:30: Tackling a homework assignment in MATLAB Engineering Computing: Analyzing live Internet data

  6. What’s on your CD • MediaSources: Royalty-free JPEG and WAV files • Material for this workshop • Workshop slides • DrJava: Nice IDE for Java for Students • CS1-Python materials • MediaTools: Squeak-based media exploration tools • Chapters from the Media Computation book in Python • Course slides • Jython Environment for Students (JES) including new 3.0

  7. CS1-Java materials First 6 chapters of Media Computation book in Java Alice+MediaComp slides All slides Exercises with solutions Classes CS2-Java materials Course notes Course slides Java Classes JMusic (MIDI support) CS1-Engineering materials Powerpoint slides GNU Octave Open source form of MATLAB CS1-Robotics materials Myro (Python robotics toolkit) Myro installation information Myro reference manual CS1 Robotics (draft) textbook What’s on your CD - Continued

  8. Introductions • Who are you? • Where are you from? • What do you want to get out of this workshop/

  9. General flow • For Python, treating this like a class • Interspersed with comments for teachers (with blue background titles, like this one) • Tomorrow (Tuesday), overview of both Python and Java courses • Then, rest of Python and robotics in Python • Wednesday: Java Media Computation • Thursday: Java Media Computation Data Structures and MATLAB

  10. Multimedia CS1 in Python • Focus: Learning programming and CS concepts within the context of media manipulation and creation • Converting images to grayscale and negatives, splicing and reversing sounds, writing programs to generate HTML, creating movies out of Web-accessed content. • Computing for communications, not calculation

  11. Installing JES (Jython Environment for Students) • Installing JES and starting it up • Windows users: • Just copy the folder • Double-click JES application • Mac users: • Just copy the folder • Double-click the JES application • There is always Help • Lots and lots of excellent help

  12. We will program in JES • JES: Jython Environment for Students • A simple editor (for entering in our programs or recipes): the program area • A command area for entering in commands for Python to execute.

  13. Python understands commands • We can name data with = • We can print values, expressions, anything with print

  14. Using JES >>> print 34 + 56 90 >>> print 34.1/46.5 0.7333333333333334 >>> print 22 * 33 726 >>> print 14 - 15 -1 >>> print "Hello" Hello >>> print "Hello" + "Mark" HelloMark

  15. Command Area Editing • Up/down arrows walk through command history • You can edit the line at the bottom • and then hit Return/Enter • that makes that last line execute

  16. Demonstrating JES for files and sounds >>> print pickAFile() /Users/guzdial/mediasources/barbara.jpg >>> print makePicture(pickAFile()) Picture, filename /Users/guzdial/mediasources/barbara.jpg height 294 width 222 >>> print pickAFile() /Users/guzdial/mediasources/hello.wav >>> print makeSound(pickAFile()) Sound of length 54757 >>> print play(makeSound(pickAFile())) None >>> myfilename = pickAFile() >>> print myfilename /Users/guzdial/mediasources/barbara.jpg >>> mypicture = makePicture(myfilename) >>> print mypicture Picture, filename /Users/guzdial/mediasources/barbara.jpg height 294 width 222 >>> show(mypicture)

  17. Writing a recipe: Making our own functions • To make a function, use the command def • Then, the name of the function, and the names of the input values between parentheses (“(input1)”) • End the line with a colon (“:”) • The body of the recipe is indented (Hint: Use three spaces) • That’s called a block

  18. Making functions the easy way • Get something working by typing commands in the command window (bottom half of JES) • Enter the def command in the editing window (top part of JES) • Copy-paste the right commands up into the recipe

  19. A recipe for playing picked sound files def pickAndPlay(): myfile = pickAFile() mysound = makeSound(myfile) play(mysound) Note:myfile and mysound, inside pickAndPlay(), are completely different from the same names in the command area.

  20. Blocking is indicated for you in JES • Statements that are indented the same, are in the same block. • Statements in the same block as the cursor are enclosed in a blue box.

  21. A function for playing picked picture files def pickAndShow(): myfile = pickAFile() mypict = makePicture(myfile) show(mypict)

  22. Explaining variables • At this point, we’ll do lots of variations of filenames and function composition. def pickAndShow(): filename = pickAFile() picture = makePicture(filename) show(picture) def pas(): show(makePicture(pickAFile())) • For both pictures and sounds. • This is our “Hello, World!”

  23. Exercise • Write pickAndPlay as a single line function

  24. Image Processing • Goals: • Give you the basic understanding of image processing, including psychophysics of sight, • Identify some interesting examples to use

  25. We perceive light different from how it actually is • Color is continuous • Visible light is in the wavelengths between 370 and 730 nanometers • That’s 0.00000037 and 0.00000073 meters • But we perceive light with color sensors that peak around 425 nm (blue), 550 nm (green), and 560 nm (red). • Our brain figures out which color is which by figuring out how much of each kind of sensor is responding • One implication: We perceive two kinds of “orange” — one that’s spectral and one that’s red+yellow (hits our color sensors just right) • Dogs and other simpler animals have only two kinds of sensors • They do see color. Just less color.

  26. Luminance vs. Color • We perceive borders of things, motion, depth via luminance • Luminance is not the amount of light, but our perception of the amount of light. • We see blue as “darker” than red, even if same amount of light. • Much of our luminance perception is based on comparison to backgrounds, not raw values. Luminance is actually color blind. Completely different part of the brain.

  27. Digitizing pictures as bunches of little dots • We digitize pictures into lots of little dots • Enough dots and it looks like a continuous whole to our eye • Our eye has limited resolution • Our background/depth acuity is particulary low • Each picture element is referred to as a pixel • Pixels are picture elements • Each pixel object knows its color • It also knows where it is in its picture

  28. Encoding color • Each pixel encodes color at that position in the picture • Lots of encodings for color • Printers use CMYK: Cyan, Magenta, Yellow, and blacK. • Others use HSB for Hue, Saturation, and Brightness (also called HSV for Hue, Saturation, and Value) • We’ll use the most common for computers • RGB: Red, Green, Blue

  29. Encoding Color: RGB • In RGB, each color has three component colors: • Amount of redness • Amount of greenness • Amount of blueness • Each does appear as a separate dot on most devices, but our eye blends them. • In most computer-based models of RGB, a single byte (8 bits) is used for each • So a complete RGB color is 24 bits, 8 bits of each

  30. Encoding RGB • Each component color (red, green, and blue) is encoded as a single byte • Colors go from (0,0,0) to (255,255,255) • If all three components are the same, the color is in greyscale • (50,50,50) at (2,2) • (0,0,0) (at position (1,2) in example) is black • (255,255,255) is white

  31. Basic Picture Functions • makePicture(filename) creates and returns a picture object, from the JPEG file at the filename • show(picture) displays a picture in a window • We’ll learn functions for manipulating pictures later, like getColor, setColor, and repaint

  32. Writing a recipe: Making our own functions • To make a function, use the command def • Then, the name of the function, and the names of the input values between parentheses (“(input1)”) • End the line with a colon (“:”) • The body of the recipe is indented (Hint: Use two spaces) • Your function does NOT exist for JES until you load it

  33. Use a loop!Our first picture recipe def decreaseRed(picture): for p in getPixels(picture): value=getRed(p) setRed(p,value*0.5) Used like this: >>> file="/Users/guzdial/mediasources/barbara.jpg" >>> picture=makePicture(file) >>> show(picture) >>> decreaseRed(picture) >>> repaint(picture)

  34. Use a loop!Our first picture recipe def decreaseRed(picture): for p ingetPixels(picture): value=getRed(p) setRed(p,value*0.5) Used like this: >>> file="/Users/guzdial/mediasources/katie.jpg" >>> picture=makePicture(file) >>> show(picture) >>> decreaseRed(picture) >>> repaint(picture)

  35. It’s not iteration—it’s a set operation • Research on developing SQL in the 1970’s found that people are better at set operations than iteration. • For all records, get the last name, and if it starts with “G” then… => HARD! • For all records where the last name starts with “G”… => Reasonable! • Because the Python for loop is a forEach, we can start out with treating it as a set operation: • “For all pixels in the picture…”

  36. How do you make an omelet? • Something to do with eggs… • What do you do with each of the eggs? • And then what do you do? All useful recipes involve repetition - Take four eggs and crack them…. - Beat the eggs until… We need these repetition (“iteration”) constructs in computer algorithms too - Today we will introduce one of them

  37. Decreasing the red in a picture • Recipe: To decrease the red • Ingredients: One picture, name it pict • Step 1: Get all the pixels of pict. For each pixel p in the set of pixels… • Step 2: Get the value of the red of pixel p, and set it to 50% of its original value

  38. Use a for loop!Our first picture recipe def decreaseRed(pict): allPixels = getPixels(pict) for p in allPixels: value = getRed(p) setRed(p, value * 0.5) The loop - Note the indentation!

  39. How for loops are written def decreaseRed(pict): allPixels = getPixels(pict) for p in allPixels: value = getRed(p) setRed(p, value * 0.5) • foris the name of the command • An index variable is used to hold each of the different values of a sequence • The word in • A function that generates a sequence • The index variable will be the name for one value in the sequence, each time through the loop • A colon (“:”) • And a block (the indented lines of code)

  40. What happens when a for loop is executed • The index variable is set to an item in the sequence • The block is executed • The variable is often used inside the block • Then execution loops to the for statement, where the index variable gets set to the next item in the sequence • Repeat until every value in the sequence was used.

  41. getPixels returns a sequence of pixels • Each pixel knows its color and place in the original picture • Change the pixel, you change the picture • So the loops here assign the index variable p to each pixel in the picture picture, one at a time. def decreaseRed(picture): allPixels = getPixels(picture) for p in allPixels originalRed = getRed(p) setRed(p, originalRed * 0.5) or equivalently… def decreaseRed(picture): for p ingetPixels(picture): originalRed = getRed(p) setRed(p, originalRed * 0.5)

  42. Do we need the variable originalRed? • No: Having removed allPixels, we can also do without originalRed in the same way: • We can calculate the original red amount right when we are ready to change it. • It’s a matter of programming style. The meanings are the same. def decreaseRed(picture): for p ingetPixels(picture): originalRed = getRed(p) setRed(p, originalRed * 0.5) def decreaseRed(picture): for p ingetPixels(picture): setRed(p, getRed(p) * 0.5)

  43. Let’s walk that through slowly… Here we take a picture object in as a parameter to the function and call it picture def decreaseRed(picture): for p ingetPixels(picture): originalRed = getRed(p) setRed(p, originalRed * 0.5) picture

  44. Now, get the pixels We get all the pixels from the picture, then make p be the name of each one one at a time def decreaseRed(picture): for p ingetPixels(picture): originalRed = getRed(p) setRed(p, originalRed * 0.5) picture getPixels() Pixel, color r=135 g=131b=105 Pixel, color r=133g=114 b=46 Pixel, color r=134 g=114b=45 … p

  45. Get the red value from pixel def decreaseRed(picture): for p ingetPixels(picture): originalRed = getRed(p) setRed(p, originalRed * 0.5) We get the red value of pixel p and name it originalRed picture getPixels() Pixel, color r=135 g=131b=105 Pixel, color r=133g=114 b=46 Pixel, color r=134 g=114b=45 … … originalRed = 135 p

  46. Now change the pixel def decreaseRed(picture): for p ingetPixels(picture): originalRed = getRed(p) setRed(p, originalRed * 0.5) Set the red value of pixel p to 0.5 (50%) of originalRed picture getPixels() Pixel, color r=67 g=131 b=105 Pixel, color r=133g=114 b=46 Pixel, color r=134 g=114b=45 … originalRed = 135 p

  47. Then move on to the next pixel def decreaseRed(picture): for p ingetPixels(picture): originalRed = getRed(p) setRed(p, originalRed * 0.5) Move on to the next pixel and name itp picture getPixels() Pixel, color r=67 g=131 b=105 Pixel, color r=133g=114 b=46 Pixel, color r=134 g=114b=45 … originalRed = 135 p

  48. Get its red value Get its red value def decreaseRed(picture): for p ingetPixels(picture): originalRed = getRed(p) setRed(p, originalRed * 0.5) Set originalRed to the red value at the new p, then change the red at that new pixel. picture getPixels() Pixel, color r=67 g=131 b=105 Pixel, color r=133g=114 b=46 Pixel, color r=134 g=114b=45 … originalRed = 133 p p p

  49. And change this red value def decreaseRed(picture): for p ingetPixels(picture): originalRed = getRed(p) setRed(p, originalRed * 0.5) Change the red value at pixel p to 50% of value picture getPixels() Pixel, color r=67 g=131 b=105 Pixel, color r=66g=114 b=46 Pixel, color r=134 g=114b=45 … originalRed = 133 p p p

  50. And eventually, we do all pixels • We go from this… to this!

More Related