Held: Monday, 5 October 2015

Back to Outline 21 - Anonymous Procedures, Revisited. On to Outline 23 - Revisiting Lists.

Summary

We consider a simple approach to working with images - looping over the positions in an image and computing a new color based on positional information. We then explore some applications of this approach.

Related Pages

• Reading: Building Images by Iterating Over Positions
• Lab: Building Images by Iterating Over Positions
• EBoard 22 (Source 22)

Overview

• Models of images.
• Iterating over positions: Images as functions from position to color.
• Blends and other positionally-computed images.
• Drawing simple shapes.
• Some strange computations.

Administrivia

• New partners!
• Quiz 5 returned.
• Sending HW questions
  • Don't forget to carbon copy your partner when you submit questions.
  • Don't forget to use topics like HELP NEEDED ON HW5! when you email me questions.
  • Don't forget to include code when you email me questions.
  • Resend the email if I don't answer within 24 hours.

Upcoming Work

• Reading for Tuesday: Heterogeneous Lists
• HW 5 due Tuesday
• Today's Lab writeup (due before class Wednesday)
  • Email to grader-151-01@cs.grinnell.edu
  • Subject: CSC 151 Lab Writeup Class 22 (Your Names)
  • Exercise:
• Exam 2 to be distributed tomorrow.

Extra Credit Opportunities

• If possible, send me these in advance.

Academic

• Any visit to the current show in the Faulconer gallery
• CS Table Tuesday: Barbie and the "Internet of Things"
• CS Extras Thursday: Blake Creasey on Watson

Peer Support

• Pals of PALS, pals@grinnell.edu, normally Saturday at 7:45 am (breakfast included), Sunday at 4:45, and Mondays at 4:45. Requires sign up in advance.
• Pun Club, Saturdays, 4pm, Way over Younker.

Other Good Things

• Friends of Drake Library book sale this weekend.

Quiz 5

You are now at the point that you should be able to notate lists correctly. Please do so in the future.

The last problem caused trouble for many of you. It asked you to identify whether the parameter was a non-zero, even, integer.

• We probably need three tests.
• We learned last week that you can't call even? on a non-integer, so we better make sure that it's an integer before we call even?

Here's one solution

 (define non-zero-even?
   (lambda (num)
     (cond
       [(not (integer? num))
        #f]
       [(not (even? num))
        #f]
       [(zero? num)
        #f]
       [else
        #t])))

However, as ZS says, "If you find yourself explicitly writing #t and #f, you can probably simplify it."

 (define non-zero-even?
   (lambda (num)
     (and (integer? num) (even? num) (not (zero? num)))))

Models of images

• We've seen a variety of models of images.
  • Images that we describe by composing basic shapes.
  • Images that we create by transforming existing images.
  • Images that we create by using the Gimp tools.
  • Images that we create by a combination of techniques.
• But there are certainly other models of image making. We'll learn at least two more this semester.
• Why are we learning so many models of image making? Because the basic operations you have affect the way you think about problem solving.

The image-compute model

• In the image-variant model, we built images with a starting image and a function from colors to colors.
• We will consider a variant of this model - images as functions from positions to colors.
• That is, given an (x,y) pair, use a function to determine a color for the pixel at (x,y).
• Syntax: (image-compute *function* *width* *height*)
  • No exclamation point because we are not changing anything that alread exists; we are simply computing a new image.

Examples

• Color blends are the most natural thing to make.
• We can also make shapes by using conditionals.
• Given that colors are just numbers, we can also just do numeric computations and see what they give us.