Exam 2: Control

Topics: Conditionals, predicates

Unlike other programming languages, Scheme is not particularly careful about types. Therefore, it might be helpful for programmers to know what kind of value they might be working with. Write, but do not document, a procedure, (type-of value), that produces

Recall that a symbolic value can be generated by prefacing a name with the single quote, as in 'rose.

Topics: Conditionals, RGB colors, color transformations

So far the behavior of many RGB transformations you have seen and/or implemented has not explicitly been dependent on qualities of the input color. We can also explore color transformations that involve conditionals.

Write and document an RGB transformation (rgb-stronger rgb) that applies rgb-redder to rgb when red is the largest component of rgb, rgb-greener when green is the largest component, or rgb-bluer when blue is the largest component.

Topics: Image transformations, conditionals, RGB colors as integers

In this problem, we consider an approach to keeping messages secret. Steganography is the process of hiding a message in an image such that no one, other than the sender and receiver, even knows there is any hidden information. One simple approach is to hide a black-and-white image inside of a full-color image. No one is likely to notice if a photo has been changed by only 1/255 from the original brightness values.

Here is the algorithm we used to create a steganographic image.

(a) Write, but do not document, a procedure, (image-steg-decode steg-image), that takes a steganographic image produced using this algorithm and produces the secret image.

Hints: Use image-variant in your procedure. Observe that if the color is represented by an odd number, this corresponds to a white pixel in the secret image. If the color is represented by an even number, this corresponds to a black pixel in the secret image.

(b) Download this image of a cute little kitty (Professor Davis's cat, Sprite, when he was a kitten), and test your procedure on it. Describe the secret image hidden inside it.

Topics: RGB colors, color transformations, local bindings

Consider the following procedure.

;;; Procedure:
;;;   rgb-greyer
;;; Purpose:
;;;   To make a color greyer while preserving its hue.
;;; Parameters:
;;;   color, an rgb color
;;;   weight, a real number
;;; Produces:
;;;   greyer, an rgb color
;;; Preconditions:
;;;   0 <= weight <= 1
;;; Postconditions:
;;;   If weight is 0, then greyer is equal to color
;;;   If weight is 1, then greyer is equal to (rgb-greyscale color)
;;;   (rgb->hue greyer) = (rgb->hue color)
;;;     (unless weight is 1; then the hue of greyer will be 0)
;;;   (rgb->value greyer) <= (rgb->value color)
;;;   (rgb->saturation greyer) <= (rgb->saturation color)
;;; Process:
;;;   Each component of the color is blended with the color's grey value
;;;     in proportion to weight.
(define rgb-greyer
  (lambda (color weight)
    (rgb-new (+ (* (- 1 weight) (rgb-red color))
                (* weight
                   (+ (* 0.30 (rgb-red color))
                      (* 0.59 (rgb-green color))
                      (* 0.11 (rgb-blue color)))))
             (+ (* (- 1 weight) (rgb-green color))
                (* weight
                 (+ (* 0.30 (rgb-red color))
                    (* 0.59 (rgb-green color))
                    (* 0.11 (rgb-blue color)))))
           (+ (* (- 1 weight) (rgb-blue color))
              (* weight
                 (+ (* 0.30 (rgb-red color))
                    (* 0.59 (rgb-green color))
                    (* 0.11 (rgb-blue color))))))))

Notice that this procedure is very repetitive. Using let and/or let*, rewrite this procedure as concisely as you can.

Topics: Image transformations, anonymous procedures

Write, but do not document, a procedure (image-greyer image weight), which transforms all of the pixels in image using rgb-greyer. Note that providing 0 for the weight parameter will result in no change to the image, whereas providing 1 will result in a greyscale image.

Again, be concise.

Topics: Turtles, iteration, anonymous procedures

Most of the turtle procedures you have been writing so far use the same turtle to iterate a process. For instance, the procedure turtle-spiral! from the reading on iteration iterates the process of moving one turtle forward and turning by an increasing angle.

  (define turtle-action-02!
  (lambda (turtle angle)
    (turtle-forward! turtle 5)
    (turtle-turn! turtle angle)))

  (define turtle-spiral!
  (lambda (turtle steps)
    (for-each (l-s turtle-action-02! turtle)
              (list-drop (iota (+ 1 steps)) 1))))

While repeatedly drawing polygons is interesting and useful because the turtle always returns to its original position, there are situations in which we may not want to rely on this postcondition. Those situations will often call for using multiple turtles.

Using turtle-spiral! as a helper, write, but do not document, a procedure, (turtles-spin-longer-spirals! turtles initial-steps scale-factor angle), that uses turtle-spiral! with each turtle in the list turtles. Before drawing its spiral, each turtle should be turned by angle degrees more than its previous turtle.

For example, if angle were 30, the first turtle would turn by zero, the second by 30, the third by 60, and so on.

In addition, each turtle's spiral should have a number of steps that is approximately scale-factor times the the previous turtle's number of steps. (Because the number of steps needs to be an integer, you may need to round.)

Here is an example of turtle-spin-longer-spirals! in action:

(define forest (image-new 200 200)) (define tiffany (turtle-new forest)) (turtle-teleport! tiffany 100 100) (define clones (map turtle-clone (make-list 8 tiffany))) (turtles-spin-longer-spirals! clones 4 1.5 45)

Topics: Drawings, recursion

On the previous exam, you may have written procedures like the following to calculate the center of a drawing.

(define drawing-center-x
  (lambda (drawing)
    (+ (drawing-left drawing)
       (/ (drawing-width drawing) 2))))

(define drawing-center-y
  (lambda (drawing)
    (+ (drawing-top drawing)
       (/ (drawing-height drawing) 2))))

Consider the following procedure that computes one metric for the “distance” between two drawings.

;;; Procedure:
;;;   drawing-distance
;;; Parameters:
;;;   drawing1, a drawing
;;;   drawing2, a drawing
;;; Purpose:
;;;   Find the "distance" between two drawings, using a simple metric.
;;; Produces:
;;;   distance, a non-negative number.
;;; Preconditions:
;;;   [No additional.]
;;; Postconditions:
;;;   If (x1,y1) is the center of drawing1, and 
;;;    (x2,y2) is the center of drawing2, then
;;;    distance = sqrt( (x1-x2)^2 + (y1-y2)^2 )
(define drawing-distance
  (lambda (drawing1 drawing2)
    (sqrt (+ (square (- (drawing-center-x drawing1)
                        (drawing-center-x drawing2)))
             (square (- (drawing-center-y drawing1)
                        (drawing-center-y drawing2)))))))

Write and document a procedure, (drawing-closest drawing candidates), that finds the element of candidates that is closest to drawing.

Note: You are likely to find it helpful to write a local helper procedure, drawing-closer, that determines which of two candidates is closer to drawing.

Topics: Lists

Write and document a procedure (take-ends lst) that returns a list containing the first and last item in lst.

> (take-ends (iota 10))
(0 9)
> (take-ends (list "red" "orange" "yellow" "green" "blue"))
("red" "blue")

Hint: Do not use recursion. Instead, use existing list procedures.

Topics: Recursion, predicates, and, or

Write, but do not document, a procedure (increasing? numbers) that returns #t if every number in the list (except the last) is less than or equal to the number immediately after it, and returns #f otherwise.

> (increasing? (iota 10))
#t
> (increasing? (reverse (iota 10)))
#f
> (increasing? (list 1/10 1/2 1/3 5/6))
#f
> (increasing? (list 0 1 1 2 3 3 10))
#t

Make this procedure definition easier to read as follows.

First, reformat the procedure so that the indentation properly demonstrates nesting. That is, you should choose appropriate points to put in carriage returns. Remember that MediaScheme will re-indent for you after you put in those returns, as long as you select the text and type Control-Tab.

Then, figure out what the procedure does. After doing so, change the names in the procedure to clarify the roles of various things. You should certainly rename the procedure f and the parameters p and x. (As a hint, start by figuring out what types p and x should be.)

Finally, write introductory comments (the six P's) to explain the purpose (and the other P's) of the procedure formerly named f. Pay particular attention to the preconditions.

When you format your exam, please put the introductory comments before the revised procedure definition.