Assignment 4: Drawing Generally and Concisely

(a) Define a procedure that corresponds to the following documentation. Include this documentation along with your definition of the procedure.

;;; Procedure:
;;;   shadow
;;; Parameters:
;;;   drawing, a drawing
;;; Purpose:
;;;   Create a shadow for drawing.
;;; Produces:
;;;   my-shadow, a drawing
;;; Preconditions:
;;;   No additional.
;;; Postconditions:
;;;   my-shadow is the same size as drawing.  That is.
;;;     (drawing-width my-shadow) = (drawing-width drawing)
;;;     (drawing-height my-shadow) = (drawing-height drawing)
;;;   my-shadow is the same "shape" as drawing.  
;;;   my-shadow is colored grey.  
;;;   my-shadow is shifted up by 3 units and left by 6 units
;;;     relative to the position of drawing.  That is,
;;;     (drawing-left my-shadow) = (- (drawing-left drawing) 6)
;;;     (drawing-top my-shadow)  = (- (drawing-top drawing) 3)

Here are some examples of applying this procedure.

(shadow red-eye)

(shadow (hshift-drawing 10 blue-i))

(b) Define, but do not document, a procedure (pair-with-shadow drawing) that groups a drawing together with its shadow. The shadow should appear behind. For example,

(pair-with-shadow (hshift-drawing 20 (vshift-drawing 20 red-eye)))

(pair-with-shadow (hshift-drawing 20 (vshift-drawing 20 blue-i)))

(c) Document pair-with-shadow using the 6Ps. Make sure to specify the width, height, and position of the drawing as part of the postconditions.

(d) Write, but do not document, a procedure, (pair-with-custom-shadow drawing color hoff voff), that behaves much like pair-with-shadow, except that one can specify the color of the shadow and the horizontal and vertical offset of the shadow.

Note: As in the case of pair-with-shadow, you may find it helpful to write a separate procedure to create the shadow.

We often ask students to write a procedure, add-smaller-neighbor, that adds a slightly smaller neighbor to an image.

In solving this problem, many students write something like the following code.

(define add-smaller-neighbor
  (lambda (drawing)
    (drawing-group drawing
                   (hshift-drawing (drawing-width drawing)
                                   (scale-drawing .75 drawing)))))

This procedure works fine if the input drawing is on the left margin of the screen. Unfortunately, if the input drawing is not on the left margin of the screen, the smaller neighbor overlaps the input drawing, rather than being on the side.

(define thingy
 (hshift-drawing
  100
  (vshift-drawing
   60
   (scale-drawing
    80
    (drawing-group
     (recolor-drawing "black" drawing-unit-square)
     (recolor-drawing "red" drawing-unit-circle))))))

(image-show (drawing->image thingy 200 100))

(image-show (drawing->image (add-smaller-neighbor thingy) 200 100))

Why do we have this problem? Because drawing-scale scales everything - not just the shape (or shapes), but also the left and top offset.

How do we solve the problem? There are a variety of options. Here are two. You might choose to temporarily shift the drawing back to the left margin and then shift the pair back after making the neighbor. If that's too much effort, you can come up with a better formula for how much to shift the right neighbor. (The math isn't too hard.)

It will be easiest if we break the problem down into two parts: Making the right neighbor and adding it to the original drawing.

Once we know how to make a right neighbor, adding it is easy.

(define add-smaller-right-neighbor
  (lambda (drawing)
    (drawing-group drawing (smaller-right-neighbor drawing))))

Your goal is therefore to write smaller-right-neighbor. To help you in this endeavor, here's some documentation.

;;; Procedure:
;;;   smaller-right-neighbor
;;; Parameters:
;;;   drawing, a drawing
;;; Purpose:
;;;   Create a smaller version of drawing, situated immediately to the
;;;   right of drawing.
;;; Produces:
;;;   neighbor, a drawing
;;; Preconditions:
;;;   (drawing-width drawing) > 0
;;;   (drawing-height drawing) > 0
;;; Postconditions:
;;;   (drawing-width neighbor) = (* 0.75 (drawing-width drawing))
;;;   (drawing-height neighbor) = (* 0.75 (drawing-height drawing))
;;;   (drawing-top neighbor) = (drawing-top drawing)
;;;   (drawing-left neighbor) = (drawing-right drawing)
;;;   The colors and shapes of neighbor are essentially the same as
;;;     those of drawing.

(a) Implement smaller-right-neighbor. That is, define the procedure.

Make sure that you try your procedure on a variety of drawings, including some drawings that have their left edge to the left of the image (that is, less than zero) and that have their top edge at various places.

(b) What if we want the right neighbor to be something other than 75% of the original drawing? We might add a second parameter to specify the scale factor. Implement, but do not document, a procedure, add-scaled-right-neighbor, that takes as parameters both a drawing and a scale factor. You can assume that the scale factor is positive.

Hint: You will probably want to write a scaled-right-neighbor procedure that also takes as parameters both a drawing and a scale factor. If you do choose to write that procedure, you should document it.

Once again, you should make sure to check a variety of cases, including scale factors both smaller and larger than 1.

(c) Document and implement a procedure, add-scaled-left-neighbor that behaves much like add-scaled-right-neighbor except that the neighbor is on the left, rather than the right.

(d) Implement a procedure, add-scaled-bottom-neighbor that behaves much like add-scaled-right-neighbor, except that (i) the neighbor is below the original drawing, rather than to the side, and (ii) the center of the neighbor is directly below the center of the original drawing.

In the lab on lists of drawings, you observed that we could create interesting patterns by making a list of a simple shape and two lists of horizontal and vertical offsets, and then combining it all with appropriate calls to map.

Let's suppose we want to take some simple shape and make a circle from 36 copies of that shape. Here's the start of a program to do just that.

(define circle-of-drawings
  (lambda (drawing)
    (map hshift-drawing 
         (map circle-ycoord (iota 36))
         (map vshift-drawing
              (map circle-xcoord (iota 36))
              (make-list 36 drawing)))))

Here's a sample use of that procedure.

> (define c5 (scale-drawing 5 drawing-unit-circle))
> (image-show (drawing->image (drawing-compose (circle-of-drawings c5)) 200 200))

As you may have noted, circle-of-drawings requires two procedures, circle-xcoord and circle-ycoord, that each take an integer between 0 and 35, inclusive, as a parameter and return the x or y coordinate of that copy of the drawing in the circle.

Write circle-xcoord and circle-ycoord. You will likely need to use sin and cos, which each take as input angles in radians.

You now know a variety of techniques for manipulating drawings and lists of drawings. Write a procedure that creates interesting drawings. You may choose what to name your procedure and what inputs it takes, provided you have at least one input. You must use map at least once in your procedure (or one of its helpers) and you must programatically change colors of the drawings you use.