Home
Contact Information
Office Hours
Announcements
LMS (Discussion Forum)
Syllabus
Prerequisites
References
Grading
Assigned Readings
Paper Discussant
Calendar
Lecture notes
Readings
Homework
Practice Quizzes
Homework
Collaboration Policy
Homework Late Policy
Compilers
Graphics library notes
CMake notes
memory debugging
Submitty
Final Project
Spring '15 Projects
Spring '14 Projects
Spring '13 Projects
Spring '12 Projects
Spring '11 Projects
Spring '10 Projects
Spring '09 Projects
Spring '08 Projects
Spring '07 Projects
Academic Integrity

Homework 0: Transformations & OpenGL Warmup
The goal of this warmup assignment is to get comfortable with the
programming environment you will be using for this class and
familiarize yourself with a simple library that we will use for linear
algebra. It's also an opportunity for a crash course in C++ and
OpenGL (if you're not already familiar with them). This
assignment is only worth 1/4 of the points of a regular homework
assignment. Please try to finish this assignment by the end of the
first week of classes, and see the TA and instructor in office hours
ASAP if you have problems with OpenGL installation.
The incidental goal is also to have fun with bizarre fractal objects.
IFS are selfsimilar fractals: a subpart of the object is similar to
the whole. The classic example of an IFS is Barnsley's fern, where
each subpart of the fern is exactly the same as the whole fern. IFS
are described by a set of affine transformations (rotations,
translations, scale, skew, etc.) These transformations capture the
selfsimilarity of the object. IFS can be defined in any dimension,
and we will play with both twodimensional and threedimensional ones.
Formally, an IFS is defined by n affine transformations. Each
transformation f_{i} must be contractive: The
distance between points must be reduced. An attractor of the
IFS is the object such that A = U f_{i} (A).
A is unchanged by the set of transformations: It is a fixed
point.
We can render an IFS by iterating the transform on random input points
from the unit square. We approximate the fixed point by applying the
transformation many times. The algorithm is as follows:
for "lots" of random points (x_{0}, y_{0})
for k=0 to num_iters_{ }
pick a random transform f_{i}
(x_{k+1}, y_{k+1}) = f_{i}(x_{k}, y_{k})
display a dot at (x_{k}, y_{k})
To minimize the number of points necessary to make an image of
reasonable quality, probabilities are assigned to each transformation,
instead of choosing a transformation with uniform probability.
Tasks
Download the provided source code and set up your C++
development environment. To receive full credit, your homework
assignments must compile and run without errors using our build
instructions on Linux, Mac OSX, or Windows. Please follow these
instructions closely for installation on your system and compiling the
code:
A CMakeLists.txt file is provided and has been tested on
Linux(gcc), MacOSX(llvm/clang), and Windows(Visual Studio). Please
see the TA or instructor in office hours ASAP if you have trouble setting
up your development environment.

The initial executable from the provided code should launch an
OpenGL window and draw a cube of noisy points or a solid cube.
Try these commands:
./ifs input ../src/sierpinski_triangle.txt
./ifs input ../src/sierpinski_triangle.txt cubes
Note: You need to specify an input file (even though that data is
ignored in the provided code) so that the program can find the
fragment & vertex shaders (which are assumed to be in the same
directory as the input file).
You
should be able to navigate the scene with the mouse: left button
rotates, middle button or control+mouse translates, and shift+mouse
zooms.
Now you're ready to start coding. Study the IFS class and
extend it to store the transformations & probabilities from the input
file.
Edit the drawing code to use
the GLM  OpenGL
Mathematics Library to transform the points and create and render
multiple cubes to visualize the IFS.
Consider the performance of your programming environment.
How many polygons/points can you render interactively? What
improvements could you make to your code? Discuss in your README.
Possible Extensions
Extra credit is available for creative extensions. Examples include:

design a new IFS  figure out the transformations and probabilities,

implement an interesting, non trivial color scheme,

implement antialiasing,

experiment with depthfirst vs. breadthfirst, etc.
Include a short paragraph in your README.txt file describing
your extension(s).
Hints
To debug your code, set the number of iterations to one. This
will allow you to check that you got the transformations right.

Be careful, arrays are indexed from 0 to n1 in
C++. Reading beyond the bounds of the array will probably result in a
segmentation fault.
Use assert() to check function preconditions, array
indices, etc.
Parsing code for commandline arguments and input files (argparser.h)
The program takes a number of command line arguments to specify the
input file (input), number of points (points),
number of iterations (iters), window height & width
(size), and switch from orthographic to perspective camera (perspective). Your program should render points by default, or
cubes if cubes is specified. Examples are shown below.
Code to parse input files and command line arguments is provided.
OpenGL and main code (main.cpp, ifs.h, ifs.cpp, glCanvas.h,
glCanvas.cpp, camera.h, camera.cpp)
OpenGL programs can be tricky to set up from scratch. This base code
should do all that work for you.
Simple Shaders (ifs.vertexshader and ifs.fragmentshader)
Data files (fern.txt, dragon.txt, sierpinski_triangle.txt, and giant_x.txt)
The input data for an IFS is a file which contains n,
the number of transforms, followed by the probability of choosing each
transform and a 4x4 floating point matrix representation of the
transform.
Files for compilation (CMakeLists.txt)
Follow the Graphics library installation &
CMake compilation instructions for your operating
system.
Files for submission (README.txt and hw0_gradesheet.txt)
Fill out these files before submitting your assignment.
Sample Results
./ifs input ../src/sierpinski_triangle.txt points 10000 iters 0 size 200
./ifs input ../src/sierpinski_triangle.txt points 10000 iters 1 size 200
./ifs input ../src/sierpinski_triangle.txt points 10000 iters 2 size 200
./ifs input ../src/sierpinski_triangle.txt points 10000 iters 3 size 200
./ifs input ../src/sierpinski_triangle.txt points 10000 iters 4 size 200
./ifs input ../src/sierpinski_triangle.txt points 10000 iters 30 size 200
./ifs input ../src/fern.txt points 50000 iters 30 size 400
./ifs input ../src/giant_x.txt points 10000 size 400 iters 0
./ifs input ../src/giant_x.txt points 10000 size 400 iters 1
./ifs input ../src/giant_x.txt points 10000 size 400 iters 2
./ifs input ../src/giant_x.txt points 10000 size 400 iters 3
./ifs input ../src/giant_x.txt points 10000 size 400 iters 4
Now here's an example using the cubes argument. Each cube
represents the bounding box of the cloud of random 3D points that are
transformed in each iteration. There are a couple different ways to
implement this rendering mode.
./ifs input ../src/giant_x.txt size 400 iters 0 cubes
./ifs input ../src/giant_x.txt size 400 iters 1 cubes
./ifs input ../src/giant_x.txt size 400 iters 2 cubes
./ifs input ../src/giant_x.txt size 400 iters 3 cubes
./ifs input ../src/giant_x.txt size 400 iters 4 cubes
Please read the homework information page again before submitting.
