Project: A Procedure is Worth a Thousand Pictures

We highly recommend that you read and understand all parts of the assignment document before you begin your work on the project.

While the primary focus of this course is on learning how to write, describe, test, and analyze algorithms, our secondary focus is on writing algorithms that generate “interesting” images. We have certainly explored a wide variety of techniques for generating images. We have seen a variety of basic approaches. In particular, you can

You also know a number of other algorithmic techniques that could support creating images, such as various numeric functions, using lists and vectors to store collections of data (e.g., colors and brushes), and techniques for repetition and recursion.

It is now time to challenge yourself to use some of these ideas together to create images of your own design.

Rather than writing code that creates a single image, however, we want to challenge you to think about algorithmic processes that can create many different images depending on the given parameters. Hence the title, “a procedure is worth a thousand pictures.”

Making your image scale correctly is one of the more difficult aspects of this assignment, but the requirement is there to help ensure that you consider important computational aspects of the problem.

Some parts of your image should be relatively straightforward, if not not necessarily simple. For the Gimp tools procedures like image-select-ellipse! and image-draw-line!, you will need to calculate parameters based on the width and height of the image. For parts of your drawing based on procedures like image-compute, you should modify the column and row in such a way that you take the width and height into account. And if we scale both width and height by the same amount, your calls to turtle-forward! can scale by that amount

Other parts may be slightly more difficult, particularly when the aspect ratio changes. For example, suppose we double the width of an image, and keep the height the same. It's hard to take a turtle-generated polygon and make it twice as wide. And it's equally hard to make a brush twice as wide without making it twice as tall. For cases like this, you still need to “scale” your computation, but you can do it in terms of a computed value of the image (e.g., just the width, just the height, the maximum of the two, the minimum of the two, the arithmetic or geometric average, or something similar). Whatever choice you make, you need to document.

A few parts may be essentially impossible to scale. For example, Gimp provides some useful and interesting brushes whose size it seems difficult to change. You may certainly use such brushes, but you should take the time and effort to explain their use and the ways in which their use affects your ability to scale and stretch.

Note that there is a procedure that resizes and rescales any image. You may not use that procedure (except to resize or rescale a source image).

The (image-save image path-to-file) procedure lets you save an image you've made. By calling it with appropriate parameters, you can save large swaths of your series (at least until GIMP or DrRacket crashes).

;;; Procedure:
;;;   num->id
;;; Parameters:
;;;   num, an integer in the range 0 to 999
;;; Purpose:
;;;   Compute a string id (typically for file names)
;;; Produces:
;;    id, a string
;;; Preconditions:
;;;   [No additional]
;;; Postconditions:
;;;   (string-length id) = 3
;;;   (string->number id) = num
;;; Practica:
;;;   > (num->id 5)
;;;   "005"
;;;   > (num->id 55)
;;;   "055"
;;;   > (num->id 555)
;;;   "555"
(define num->id
  (lambda (num)
    (let ([idplus (string-append "00" (number->string num))])
      (substring idplus (- (string-length idplus) 3)))))

;;; Procedure:
;;;   image-series-file
;;; Parameters:
;;;   prefix, a string (e.g., "/home/student/Desktop/student")
;;;   n, an integer in the range 0 .. 999, inclusive
;;;   width, a positive integer
;;;   height, a positive integer
;;; Purpose:
;;;   Create the nth image in the series at the specified size,
;;;   and save in an appropriate file
;;; Produces:
;;;   [Nothing; called for the side effect]
;;; Practica:
;;;   > (for-each (lambda (i)
;;;                 (image-series-file "/home/student/Desktop/student" 
;;;                                    i 200 200))
;;;               (iota 100))
(define image-series-file
  (lambda (prefix n width height)
    (let ([filename (string-append prefix 
                                   "." (num->id n)
                                   "." (number->string width)
                                   "x" (number->string height)
                                   ".png")]
          [image (image-series n width height)])
      (image-save image filename)
      (gimp-image-delete image))))

In class, we will have two discussions, one about the aesthetics of your work and your success in meeting the criteria you have stated for yourself, and another about the techniques you use to create your images.

Your grade will be based on your statements, your code, and your success in combining multiple techniques. We will use this rubric (or a slight variant) to assess your project.

While we appreciate clever and interesting images, if you read the rubric carefully, you'll note that most of the points depend on your success at meeting the basic requirements: Do you have 1000 distinct images? Do your images scale properly? Are you using at least three different techniques? Make sure that you are sure that you've addressed each of these requirements.

Here are some issues that normally lead to teams losing points. Make sure that you check these issues.