Stuff to turn in with Final Project
Study Notes for CS32 Final Exam
Final Exam is 2pm in Mudd 206 on Monday May 13th, 1996
This is what I consider to be the minimum acceptable working project
that you can turn in for credit:
Once all these items have been implemented, you should be able to run
the Little Language program that plots out the state of Massachusetts
(file on my web page) as a test and for minimum credit.
- Interpreter: working and parsing commands. You should have it
parsing all commands, even those that are not yet implemented
and exist only as stub procedures, but I will accept an "obviously
extendible" parser that works correctly on all fully implemented commands.
- Correct screen allocation and deallocation: any dynamic memory
allocated with a SCREEN command should be properly deallocated as part
of the next SCREEN command.
- Put_Pixel (with clipping) at screen pixel level.
You should be able to call this routine
with any integer values for X and Y, and have it put the even color into
the appropriate element of the screen array if Odd(X)=Odd(Y), and put
the odd color if Odd(X)<>Odd(Y). Any values of X and Y outside the
screen area should be clipped.
- Bresenham line routine for any two integer coordinates <X1,Y1>
to <X2,Y2>, calling the Put_Pixel routine successfully.
- WINDOW and VIEWPORT commands. Must handle cases where values are
reversed in the WINDOW coordinates (X1 > X2, or Y1 > Y2). Must
correctly map any point from world space onto viewport space.
- PIXEL, MOVE_TO, and LINE_TO commands, at world level. Must
correctly translate and plot lines and points from world space to viewport
space, and call the appropriate pixel-level graphics routines (even if
you don't get wide lines working, a call to LINE_TO must at the
very least translate the endpoints to viewport space and call the
Bresenham line drawing routine).
- PROCEDURE, END, and CALL must work correctly.
- COLOR, EVEN, and ODD must set the correct colors. I would reluctantly
accept a minimal version that uses a single color instead of even and odd,
but it is so easy to do the even and odd colors that there really isn't
any good reason to leave them out.
- At least one of the two following items must work, preferably both:
- SAVE_24 must work, to create final bitmaps.
- VIEW must work, or alternatively must be able to plot the image on
screen at end of Little Language run.
All options beyond the minimum that you managed to implement will be
considered for additional credit. I will check off on my list those
features that you implemented and could successfully demonstrate to me
as operational, including (in rough order of complexity) simple geometric
operators (rectangle, circle, ellipse), polygon fills (including user
fills, line fills, and filled circles, ellipses, and rectangles),
flood fills, Bezier curves, fonts, and dithering, etc.
This is what I expect turned in for your projects, when you submit
them on Monday at the exam:
You must arrange to demonstrate your program to me sometime during
the day on Monday. I will be on campus most of the day, starting around 11am
or so. If you are running on a PC or on a Mac, you must
also turn in to me:
- A printed copy of your source code
- A Mac or PC formatted diskette containing a copy of your source
(preferably in PC format)
- The diskette must also contain copies of the 24 bit .BMP
files produced by your program.
- An executable copy of your program on the diskette that I can run
- A "User Manual": some form of quick reference (on disk and printed)
so I know how to run and test your program.
Most of the exam will be based on material since the midterm.
I will try to write a "stripped down" version of the exam,
so that you can spend the bulk of your time working on the
last minute details of your projects.
These are the topics that I expect you to think about. The exam
will be a subset.
- Basic 3D operations
- 3D transformation matrices
- Rotation (three types: one each for X, Y, Z)
- Perspective and orthographic projection
- Basic ray-casting and synthetic camera models (vectors)
- 3D orthographic projection (i.e., 3D without synthetic
camera or perspective, just using sine and cosine)
- Stereo 3D
- Stereopticon slides (tilting eye angle for each image, deciding
whether to paint for diverged eyes or crossed eyes)
- Red-Blue stereo in same image (gray scale images, one
where gray in one is mapped to red, other mapped to blue,
then images averaged)
- Random dot stereogram (basic ideas, not algorithms)
- Shading models (basic ideas)
- Flat vs. Specular Reflection
- Flat Shading (setting color intensity by calculating
angle between surface normal and vector from light source)
- Phong Shading (Cos^N(of that same angle))
- Gouraud Shading (linear intensity interpolation, pp736-737)
- Hidden Surface elimination
- Back-face elimination (check angle between surface normal and
vector from eye, if angle > 90 degrees then don't paint face
because it is tipped away from you)
- Polygon clipping (project 3D polygons onto 2D plane and clip,
but problem exists when polygons mutually overlap)
- Painter's algorithm (paint back to front, paint over stuff in back)
- Z-buffer (pixel contains color plus depth information)
- Computational Geometry (general concepts)
- Delaunay Triangulations (basic idea about circumcircles)
- Convex Hulls
- In 2D, what are they, how might they be generated?
- How might they be used in 3D for helping with shadows?
- Star Polygons (from the demo I showed in class)
Finally, my thanks to you all for a very interesting and
productive semester! I hope that you have learned as much
from me as I have from you folks; you really kept me on
my toes this Spring! Feel free to stay in contact with me
in the future. I will be around all summer, and look forward
to hearing from you.
Back to CS32 Page
Back to Dr. Bill's Home Page