Project: A Procedure is Worth a Thousand Pictures

Part One (Proposal) Due: 11 a.m., Wednesday, 17 November 2010

Part Two (Implementation) Due: 11 a.m., Wednesday, 24 November 2010

Summary: At this point in your career, you've learned a number of techniques for making images algorithmically. This project is an opportunity for you to explore some techniques in greater depth.

Purposes: To explore some aspect of image generation in depth. To emphasize the more creative components of this course. To encourage more purposeful image creation and reflection on algorithms.

Collaboration: We encourage you to work in groups of size three. You may, however, work alone or work in a group of size two or size four. You may discuss this assignment with anyone, provided you credit such discussions when you submit the assignment.

Submitting: Email your submissions to <weinman>. The title of your email should have the form Project and should contain your response to the appropriate part of the assignment. Scheme code should be in the body of the message. For part two, you will also submit two sets of three images and your statements following the instructions at the bottom of this assignment.

Warning: So that this assignment is a learning experience for everyone, we will almost certainly spend class time publicly critiquing your work.

Preliminaries

It is highly recommended 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, text, 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. For example, you can

write instructions to create images using the GIMP painting tools;
write instructions for turtle graphics;
describe images as sequences of simple geometric primitives which you can also generate algorithmically;
create a new version of an existing image using image-variant;
create interesting patterns and shapes using image-compute-pixels!;
use numeric recursion to create geometric figures;
create images by recursively dividing and coloring spaces.

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, and techniques for repetition. 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.”

Assignment

Background: Specification

You will write a procedure, (image-series n width height), that generates the nth image in a series of at least 1000 related images. (You should be sure your procedure works for at least the integers between 0 and 999, inclusive; however, you may be more successful if you support a larger range of values.) The images should be reproducible: that is, if a user gives the same n, width, and height twice, the resulting images should be the same. You should not use randomness to vary the images; instead, the differences should be based solely on the choice of n.

In creating these images, you should use at least three different techniques that we have learned this semester.

You should strive to make these “interesting” images, images that will hold the viewer's attention. As Professor Kluber has noted, representational images and completely symmetrical images are less likely to hold the viewer's attention. (For example, in a picture of a cat on a landscape, the viewer is likely to say “yup, that's a cat on a landscape” and move on.)

Your process should scale appropriately. That is, a 1000x1000 image should look similar to a 100x100 image, just bigger (and perhaps slower to compute). We will certainly use your procedure to create relatively large images that we could comfortably print on a full page or use as a desktop background.

Part One: Design Proposal

To begin your project, write a proposal consisting of two major parts.

The first part, which we will call the design statement, is intended for non-programmers and should explain the intent of your series. Are you exploring color? The use of shapes? The illusion of depth or motion? The effects of unpredictability on an image? Why? Where appropriate, use the language Professor Kluber has provided for analyzing two-dimensional images.

After your design statement, include a sketch of at least two images from the series showing what you intend your images to look like and how they are likely to differ. (We would prefer hand-drawn sketches, although you may also generate them on the computer.)

The second part, which we will call the technique statement, is intended for your peers (that is, folks who know about as much programming as you do) and should explain the intended programming and algorithmic aspects of your work: what approach(es) do you plan to use to achieve the result you describe in the design statement? Be sure to mention the three (or more) algorithmic techniques you will use and explain how you plan for your procedure to create at least 1000 distinct images.

Given that the paragraph is the "unit of composition" (according to Strunk and White), and each of these statements asks you to address a few important considerations, it is likely that each statement will consist of more than one paragraph.

We will do our best to respond to your specification in a timely manner.

Part Two: Procedure and Images

After finishing your proposal, you should set to work on implementing your design, making sure to meet all of the specifications outlined above.

Once you complete your procedure, update your design and technique statements to reflect how your project actually turned out. If there are points of divergence, you should explain why you changed your approach.

In addition, be certain your final, revised technique statement mentions the three (or more) algorithmic techniques you are using. It should also explain--via a carefully reasoned process--how you know that your procedure creates at least 1000 distinct images.

Finally, tell us three values of n that, when given as parameters to your procedure, cause it to produce especially interesting (and distinct) images.

Submitting the Project

Part One

Copy your proposal into the body of an email message and send to <weinman>; turn in your sketches at the beginning of class.

Part Two

Email your program, updated statements, and representative values of n to <weinman>.

Because it might take a while to create images, you should also provide us with copies of certain images. We would like two sets of images: one giving the three images you've chosen as particularly nice representatives of your series, and the other showing how well your procedure scales the images to different sizes. Here's how.

From the Desktop, open your home directory. Create a new folder inside that is named after your project group members, e.g., username1-username2.
Save or copy a .scm file containing your Scheme code into this directory.
Create your three favorite images at a large size (at least 500x500).
Pick a single n and create images of size 50x50, 100x100, and 200x200 with that n.
Save each image into the new folder, using JPEG file format and with a filename of the form username1-username2.nnn.size.jpg, where username1, etc., are the usernames of the team members, nnn is the number used to generate the image, and size is the size of the image (e.g., 50x50, 100x100, 200x200, or 500x500).
Save your revised statements as a text file in this new directory, using the name username1-username2.statements.txt.
Again, from the desktop, open your home directory. Open your new folder and verify that it contains the images, design statement, and Scheme code. Then close it.
From your home directory, right click on your new folder and choose Create Archive.... Without changing any of the settings in the dialog, click the Create button.
Attach the .tar.gz file you just created to the email where you turn in your assignment.

Important Evaluation Criteria

Professor Kluber will visit our class the week after this project is due to discuss and assess the aesthetics of your work and your success in meeting the criteria you have stated for yourself.

We will assess your code, your description of the code, and your success in using multiple techniques together. We may consider following criteria:

Are your statements complete, clear, concise, and accurate?
Have you written a procedure that takes as parameters an integer (0 through 999), a width, and a height? Does it produce an image of the given width and height?
Does your procedure generate at least 1000 distinct images?
Have you used at least three techniques you learned this semester?
Are the images reproducible? (Do they vary based solely on n? You should not use randomness.)
Does your procedure scale appropriately? (Do smaller images look similar to larger images produced with the same n?)
Is your code reasonably elegant, concise, and efficient?
Is your code well-documented and easy to understand?

Questions

Can we reuse code from the assignments?: You may certainly reuse code from the assignments, provided you cite that code. However, you should make sure that your project goes beyond what you did for the assignment. Hence, you will likely want to extend or otherwise rewrite that code.
Can we make representational images?: We would prefer that you not make representational images. In our experience, the representational projects are often less interesting. (A thousand cartoonish houses is, well, not all that exciting.)
While we have envisioned a lot in our proposal, we are worried that we will not be able to implement everything we envision. Will we be penalized if we do less than we originally planned?: We would prefer that you aim high in the original proposals and then simplify as necessary. You will be graded primarily on your final results. Note, however, that the quality of your initial proposal will also factor in to your final grade.
Does our procedure have to work equally well for different aspect ratios?: We would prefer that your procedure handle different aspect ratios. However, if you find it appropriate to focus on a particular aspect ratio, that is acceptable. Just make sure that your statements explain why.
There is some fine detail in our image that gets lost at smaller image sizes, making smaller images look identical. Is that okay?: Your images need not be distinguishable at smaller sizes.
Some aspects of my drawing, such as the brush sizes, don't scale. Is that okay?: Yes, that is fine. We only expect you to scale the things that are reasonably scalable (such as the positions and lengths of shapes in your image).