Exam 2: Control

a. Write, but do not document, a predicate, (simple-drawing? value), that checks whether value meets the form of a simple drawing. That is, your predicate should check whether value has the form described above.

Note: You may not use the procedure drawing? in solving this problem.

> (simple-drawing? drawing-unit-circle)
#t
> (simple-drawing? 4)
#f
> (simple-drawing? (drawing-hshift drawing-unit-square 5))
#t
> (simple-drawing? (drawing-group drawing-unit-circle drawing-unit-square))
#f
> (simple-drawing? (iota 8))
#f
> (simple-drawing? (list 'drawing 'ellipse RGB-BLACK "" 2 3 4 5))
#t
> (simple-drawing? (list 'drawing 'ellipse "black" "" 2 3 4 5))
#f
> (simple-drawing? (list 'drawing 'ellipse RGB-BLACK))
#f

b. Write, but do not document, a predicate, (drawing-ellipse? val), that determines whether val is a drawing and is an ellipse. You can use the simple-drawing? predicate to first check whether a value is a drawing.

> (drawing-ellipse? drawing-unit-circle)
#t
> (drawing-ellipse? (drawing-scale drawing-unit-circle 23))
#t
> (drawing-ellipse? (drawing-hshift drawing-unit-circle -5))
#t
> (drawing-ellipse? drawing-unit-square)
#f
> (drawing-ellipse? "This is a drawing of an ellipse")
#f

Write a predicate, (drawing-circle? val), that determines whether val is a drawing and is a circle. (A circle is an ellipse with equal width and height.)

> (drawing-circle? drawing-unit-circle)
#t
> (drawing-circle? (drawing-scale drawing-unit-circle 5))
#t
> (drawing-circle? (drawing-hscale drawing-unit-circle 3))
#f
> (drawing-circle? (drawing-vshift drawing-unit-circle 18))
#t
> (drawing-circle? (drawing-hscale (drawing-vscale drawing-unit-circle 3) 3))
#t
> (drawing-circle? pi)
#f

Write a procedure, (drawing-area val), that finds the area of a drawing that is a rectangle or a circle. (You need not find the area of any ellipse that is not a circle.)

Be sure to check preconditions and print appropriate error message if those preconditions are not met.

> (drawing-area drawing-unit-square)
1
> (drawing-area drawing-unit-circle)
0.7853981633974483
> (drawing-area (drawing-scale drawing-unit-circle 20))
314.1592653589793
> (drawing-area (drawing-hscale drawing-unit-circle 20))
drawing-area: Don't know how to find the area of that drawing.
> (drawing-area (drawing-hscale drawing-unit-square 20))
20
> (drawing-area (drawing-vscale (drawing-hscale drawing-unit-square 20) 15))
300
> (drawing-area (drawing-group drawing-unit-circle drawing-unit-square))
drawing-area: Don't know how to find the area of that drawing.
> (drawing-area 5)
drawing-area: Expected a drawing, given 5

Write a procedure, (drawings-largest drawings), that takes a list of basic drawings (rectangles and circles) as a parameter and returns the drawing in the list which has the largest area.

Write, but do not document, a procedure, (turtle-shift-polygon! turtle side-length sides shift-angle shift-distance copies), that draws the given number of copies of the specified polygon. Each copy should be offset by the specified shift-angle and shift-distance.

The turtle should be returned to its original position and orientation.

Here is an example of turtle-shift-polygon! in action:

(define world (image-new 200 200)) (define ted (turtle-new world)) (image-show world) (turtle-teleport! ted 100 100) (turtle-shift-polygon! ted 20 3 0 20 3) (turtle-shift-polygon! ted 10 3 -60 15 10) (turtle-shift-polygon! ted 15 3 135 10 10)

You may certainly use your turtle-polygon! procedure from homework 5, but remember to cite it appropriately.

In the past few weeks, you've seen how to select the brightest color in a list or the darkest color in the list. But sometimes our criteria for selecting a color are a bit more complicated.

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

;;; Procedure:
;;;   rgb-distance
;;; Parameters:
;;;   rgb1, an RGB color
;;;   rgb2, an RGB color
;;; Purpose:
;;;   Find the "distance" between two colors, using a simple metric.
;;; Produces:
;;;   distance, a non-negative integer.
;;; Preconditions:
;;;   [No additional.]
;;; Postconditions:
;;;   If rgb1 = rgb2, then distance is 0.
;;;   Given three rgb colors, c1, c2, and c3, if c1 and c2 are likely
;;;     to be perceived as closer than c1 and c3, then
;;;     rgb-distance(c1,c2) < rgb-distance(c1,c3).
(define rgb-distance
  (lambda (rgb1 rgb2)
    (+ (abs (- (rgb-red rgb1) (rgb-red rgb2)))
       (abs (- (rgb-green rgb1) (rgb-green rgb2)))
       (abs (- (rgb-blue rgb1) (rgb-blue rgb2))))))

Write a procedure, (rgb-closest color candidates), that finds the element of candidates that is closest to color.

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

> (rgb->string (rgb-closest RGB-RED (list RGB-BLACK RGB-WHITE)))
"0/0/0"
> (rgb->string (rgb-closest RGB-YELLOW (list RGB-BLACK RGB-WHITE)))
"255/255/255"
> (rgb->string (rgb-closest RGB-RED (list RGB-BLACK RGB-RED RGB-WHITE)))
"255/0/0"
> (rgb->string (rgb-closest RGB-YELLOW (list RGB-BLACK RGB-BLUE RGB-WHITE)))
"255/255/255"
> (rgb->string (rgb-closest (rgb-new 255 128 0) (list RGB-BLACK RGB-RED RGB-WHITE)))
"255/0/0"

When computers had less memory, it was inefficient to represent each color by three values. More frequently, images were represented using palettes, in which each color was selected from a small list of colors. This approach is still used to send compressed versions of images across the Internet. It can also be used to create interesting variants of images.

Write a procedure, (palettize image colors), that creates a new image by converting the color at each pixel in image to the nearest color in colors.

(palettize kitten (list RGB-BLACK RGB-WHITE))

(palettize kitten (list RGB-BLACK RGB-GREY RGB-WHITE))

(palettize kitten (list RGB-GREY RGB-WHITE))

(palettize kitten (list RGB-RED RGB-WHITE RGB-BLUE))

The Color Scheme Designer we used earlier in the semester has a setting allowing you to view a color palette as an individual with full color blindness might see it. The color blends you saw in an earlier reading might appear very different when given the same treatment.

Therefore, someone implemented a procedure gray-gradient that creates an image of a blend between two gray-scale versions of its arguments, as shown below.

	(image-show (gray-gradient RGB-RED RGB-BLUE 128 64))
	(image-show (gray-gradient RGB-RED RGB-YELLOW 128 64))

Rewrite the implementation below to eliminate as much of the repeated code and computation as you can. You do not need to document the revised procedure.

(define gray-gradient
 (lambda (color1 color2 width height)
   (image-compute 
    (lambda (col row)
      (rgb-new (+ (* (/ col width) 
                     (+ (* 0.30 (rgb-red color1)) 
                        (* 0.59 (rgb-green color1))
                        (* 0.11 (rgb-blue color1))))
                  (* (- 1 (/ col width)) 
                     (+ (* 0.30 (rgb-red color2)) 
                        (* 0.59 (rgb-green color2))
                        (* 0.11 (rgb-blue color2)))))
               (+ (* (/ col width) 
                     (+ (* 0.30 (rgb-red color1)) 
                        (* 0.59 (rgb-green color1))
                        (* 0.11 (rgb-blue color1))))
                  (* (- 1 (/ col width)) 
                     (+ (* 0.30 (rgb-red color2)) 
                        (* 0.59 (rgb-green color2))
                        (* 0.11 (rgb-blue color2)))))
               (+ (* (/ col width) 
                     (+ (* 0.30 (rgb-red color1)) 
                        (* 0.59 (rgb-green color1))
                        (* 0.11 (rgb-blue color1)))) 
                  (* (- 1 (/ col width)) 
                     (+ (* 0.30 (rgb-red color2)) 
                        (* 0.59 (rgb-green color2))
                        (* 0.11 (rgb-blue color2)))))))
    width height)))

(a) Write (drop-ends lst n), a procedure that builds a new list from lst by dropping the first and last n elements.

> (drop-ends (iota 10) 1)
(1 2 3 4 5 6 7 8)
> (drop-ends (list "red" "orange" "yellow" "green" "blue") 2)
("yellow")

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

(b) Add precondition checking to your implementation of drop-ends. Provide a separate error message for each type of error.

You may recall that in the reading on list recursion, revisited, we developed templates for testing whether a predicate holds for any value in a list or for all values in a list. We can implement these templates as new, more general procedures.

a. Write, but do not document, a recursive predicate, (all predicate? lst), that produces #t if predicate? is true for all values in lst, and #f otherwise.

b. Write, but do not document, a recursive predicate, (any predicate? lst), that produces #t if predicate? is true for some value in lst, and #f otherwise.

c. Using the simple-drawing? predicate you wrote for problem 1, write, but do not document, a new function (all-simple-drawings? lst). Make your implementation as concise as possible.