Projects and Coursework
View my GPA info
View my summary of classes by year
View my summary of classes by subject

Computer Science classes I have taken (in approximate order within divisions):

Undergraduate Level Courses:
    (600.119) Honors C
    (600.118) Programming in C++
    (600.226) Data Structures
    (600.271) Computational Models
    (600.303) Supercomputing
    (600.333) Computer System Fundamentals

Undergraduate/Graduate Level Courses:
    (600.444) Computer Networks
    (600.457) Computer Graphics
    (600.421) Object Oriented Systems
    (600.456) Rendering Techniques
    (600.461) Computer Vision
    (600.463) Algorithms 1
    (600.460) Virtual Worlds
    (600.504) Independent Study/Research
    (605.204) Intro to Assembly Language and Systems Software
   
Graduate Level Courses:
    (600.657) High-Performance Graphics and Modeling
    (605.437) Multimedia Systems Integration
    (605.451) Principles of Artificial Intelligence
    (600.757) Seminar in Computer Graphics

(600.119) Honors C
-Programming Assignments:
        119hw.zip (undocumented)

-Group Project: Text-based, networked, Pirates!
        119project.zip (undocumented)
          Sail the high-seas and barter with ports around the world. (You get the idea!)
   

(600.118) Programming in C++
-Programming Assignments:
        118hw.zip
          Hw1: Text formatting
          Hw2: Memory/Stack Management   
          Hw3,4: Calendar/Appointment Creation

-Group Project:  MFC-based, networked, CLUE
        118project.zip
          Notes:  My part in the project was the main game functionality, including the entire GUI.
                       The game was never totally runnable though, since the other group members
                        could not get the networking done in time.  (The game was to be a client-server
                        type of game, with a chat option, etc).

          Screenshots:   
                                            Gameboard                                     Game Screen

(600.226) Data Structures
-Programming Assignments: Java Applets that visually demonstrate the operation of
                                            various data structures.
       226hw.zip
          HW1:    Stacks and Queues
          HW2:    Sequences
          HW3:    Priority Queue
          HW4:    Dictionary
          HW5:    URL TXT file word counter

(600.271) Computational Models
    No Projects

(600.303) Supercomputing
    (short course) No Projects

(600.333) Computer System Fundamentals
-Programming Assignments: A few small MIPS assembly language assignments...
        including a fibonacci number generator, a sorting program, and Booth's
        algorithm. (Run using SPIM)
        333hw.zip

(600.444) Computer Networks
    No Projects

(600.457) Computer Graphics
-Programming Assignments:  (More complete descriptions are available in the zip files)
        HW1: 457hw1.zip
                    Allow the user to input a set of points, and scan-convert the points
                       into a filled polygon.  The output is a PPM image file.
                            
        HW2: 457hw2.zip
                    Addition of anti-aliasing to HW1 by way of Supersampling--
                       using a Box, Bartlett, or Gaussian filter.
                            
        HW3: 457hw3.zip
                    A 3D Robot in OpenGL.  The Dimensions of the robot are
                       read in from a file at run-time. The robot can be manipulated with
                       the mouse (body parts can be rotated, translated, etc)
                    Screenshots:
                                   

        HW4: 457hw4.zip
                    A manual implementation of Phong's Illumination Model, but still using OpenGL
                       for transformations and shading.  Parameters are read in from an input file.
                                               

-Final Project:  Fractal Terrain Generator
        457project.zip
          Description: This program generates a height-map using 2 Fractal algorithms.  One
                              creates a height-map that is smooth, and one creates a height-map that
                              varies more.  The terrain is rendered in OpenGL, and GLUT is used
                              for the windowing.  The user can 'fly' over the terrain from a ground
                              view, or see the whole terrain from above.  New terrains can be
                              generated on the fly, and terrains can be saved by simply saving the
                              seed of the random number generator at the time the terrain was
                              created, hence one of the primary reasons for using fractals- storage
                              space of the whole height-map requires a single number!
                
                              There are also some primitive trees, just to show the expandability
                              of the program.

       
          Screenshots: (Blue is water, White symbolizes high mountain-tops, etc)
                              (The middle image is generated with the smoother fractal algorithm)

                           

(600.421) Object Oriented Systems
-Programming Assignments:  (Programming Language: VisualWorks Smalltalk)
        421hw_project.zip
          HW1: Write a Class for grading
          HW2: Boggle -- Text
          HW3: Boggle -- GUI

-Group Project:  Smalltalk Paint Program
        (see above zip file for the code)
           Screenshots:
                                                  

(600.456) Rendering Techniques
-Programming Assignments:   
        HW1: 456hw1.zip
                     Read in a PPM file, and display it using OpenGL and Glut
        HW2: 456hw2.zip
                     Using Java3D, create a rotating scene with:
                       1) Spinning cube texture-mapped with a picture of me!
                       2) 3 Sphere's of different colors and materials
                       3) A colorfull Tetrahedron
                     Screenshots:
                                             
        HW3: 456hw3.zip
                    Ray Caster- supports Warn spotlights, sphere primitives, and a Phong
                        Illumination model.  Everything is specified in eye coordinates.  Only
                        shadow rays are traced, so there is no transparency, etc. Output is a PPM.
            
                    Screenshots:
                                             

        HW4: 456hw4.zip
                    Ray Tracer- (extension to original ray caster from hw3)
                        Recursively traces transmission and reflection rays.  Now supports
                        triangle primitives.

                    Screenshots:
                                     
                                                   

-Final Project:  Adaptive Stochastic Ray Tracer w/Performance Enhancments
        456project.zip
          Description: (Expansion to RayTracer from homeworks, see text file in the zip
                                for a more in depth description)
                              First, anti-aliasing was added by adaptively shooting multiple rays
                              for each pixel, each with a stochastic distribution to make sure it is
                               sufficiently spread about the pixel area.  Then, ray-tracing speed
                               enhancements were put in, including accelerated intersection
                               algorithms, shadow-caching, adaptive ray-depth control, and
                               bounding volume hierarchies.  Planned additions, which time did
                               not allow, were gloss, translucency, extended light sources, and
                               depth of field.  All of the additions that weren't added are an extension
                               to the method of Stochastic Ray Tracing.

          Screenshots: (The second tree includes a bump-mapped triangle, and noise to simulate
                                snow.   The model was created by Brian Lawson.)

                                           
                                                      

(600.461) Computer Vision
-Programming Assignments:
        461hw.zip
          HW1: Gamma correct images, and threshold images
          HW2: Apply Gaussian Template to various edges, Compute Canny Edges of images
          HW3: Label connected 'blobs' of a binary image.  For each blob, compute the Area,
                       Center of Mass, and Second Order Moments about the Center of Mass. Then
                       determine eigenvalues and eigenvectors of each blob, in order to assist in the
                       classification of it.

-Final Project:  Texture Classification
        461project.zip
          Description:  Characterize grey-scale textures using their 2nd-order co-occurrence matrices.
                   See the zip file for the code, gif's and pgm's of the textures that were classified, and
                   an Excel file of graphs of the resulting classification data.

(600.463) Algorithms 1
    No Projects

(600.657) High-Performance Graphics and Modeling
-Project & Presentation:  Progressive Volume Rendering
        657project.zip - See my enclosed presentation and summary paper for a
                         more detailed description of my program and of Volume
                         Rendering in general.
                         Notice: For reasons of space conservation, the data-sets
                             are not included in the zip file. Email me if you want
                             to find out how to access them.  (There is one crappy
                                     small dataset, so you can at least run the program and
                                     see what it does).

          Description:  The assignment was to research our individual project topic, and then
                                give a presentation to the class in order to teach them about the subject.
                                In other words, the second half of the semester was a seminar based
                                upon individual student projects.

                              I chose to research Volume Rendering, and to focus on an individual area
                                of Volume Rendering for my project.  My presentation includes an outline
                                of the major areas of Volume Rendering, including ray-casting, marching
                                cubes, and the Fourier transform.

                              After much research, I decided to implement a form of ray-casting, that
                                progressively renders the volume at different resolutions, in order to
                                allow the user to interact with the volume.  The ray-caster uses a
                                Central Difference Operator to calculate gradients, and basic Linear
                                Interpolation for the sample points.  The rays are cast using an inverse
                                ray transform, which seems to be the fastest method.  There is no color
                                involved, since that would require more information about the data-set
                                than I had available.  The classification is a basic pre-calculated look-up
                                table of alpha values.

                              The program renders the volume at a medium resolution to begin with.
                                The user can select various rendering parameters such as the resolution,
                                the scaling, and the rotations.  Also included is an option to render the
                                volume in a perspective transform.  The modes of composition of sample
                                points include Front-Back, Maximum Intensity Projection, and Average
                                Intensity Projection.  Lastly, there are adjustable clipping planes along
                                the Z axis (relative to the screen).  While rotating or scaling the volume,
                                the program renders the volume at a low resolution to allow for
                                more interactive frame rates.  When the roation stops, the volume is
                                again rendered at the selected resolution. 

                              My implementation was successfull, in that with an average system the
                                user can move the volume with frame rates exceeding a few fps.  The
                                highest resolution rendering usually takes anywhere from 40-90s
                                per frame.  So, the quality of still renderings is sustained, while the
                                program still allows for interactive rotation of the volume.

          Screenshots:  Here are some screenshots taken from the program.  The data-sets are
                                thanks to Introduction to Volume Rendering, by Lichtenbelt, Crane,
                                and Naqvi.  More references and credits can be found in the zip file.
                                Oh, and don't let the seconds per frame fool you in these captures,
                                because the refreshing of the image caused the counter to be reset
                                back to 0.

(600.460) Virtual Worlds
-Programming Assignments:
   HW1: Creation of a Model
      For this homework, we had to create a model of something 'toy-like'.   I created what I called
      a remote control hovercraft, which is pictured below.
   HW2: Animate and Navigate Model
      To follow-up with the last homework and get associated with the VR Hardware, we animated
      our models from HW1, and then made a basic OpenGL program which would allow us to
      navigate around and view the model.

-Final Project: Virtual Reality Wiffleball Simulation
    Though my final project wasn't entirely successful due to hardware limitations, it had a great concept.
    I set out to create a wiffleball simulation in which you would be the batter and wear the VR headset
    in order to see a virtual pitch that you could swing at with a real bat.  The VR hardware, however,
    didn't want me to succeed since it didn't update itself enough, and was not accurate enough to
    do collision detection between the virtual ball and real bat. 

    I have some pictures of the models I was using that I will put up soon, along with the source code
    for the simulation.  However, you would need a system that could run it in order to view what I was
    able to do, and that could be hard to come by.

(600.504) Independent Study/Research
    Currently in Progress
    - Real-time Rendering of Outdoor Scenes through Texture-Based Simplification -

    History:

    I started out with the goal of creating an engine that would interactively render a very realistic outdoor scene.
    This led me to research such algorithms as Image Replacement and Polygonal Simplification in order to reduce
    the complexity of such a scene.  (So that it indeed could be rendered in real-time). 
   
    I found a great paper on the simulation of ecosystems, which had some awesome pictures of outdoor scenes.
    The authors of Realistic Modeling and Rendering of Plant Ecosystems were gracious enough to give me
    access to one of their model files.  The outdoor scene model was composed of around 17 million polygons,
    so it provided a good challenge for rendering in real-time.

    A Framework for the Real-time Walkthrough of Massive Models, helped me choose which method to first
    pursue in order to render the scene as efficiently as possible.   According to the paper, they were able to
    reduce a model of ~15 million poly's down to about 600,000 using Texture Meshes to cull/replace
    geometry. 

    Work:

    A summary of my work, along with screenshots and some code will be posted soon.  I was successful in
    increasing the rendering speed, but when certain parts of the model are being rendered it will still slow
    down to a crawl.  (Primarily an apple tree that is very complex).   There are many possible ways to
    enhance and expand my system, but I do not currently have the time to work on it.

(605.437) Multimedia Systems Integration
-Final Project:  Movie Production w/Special Effects on a small budget
    This class dealt with many aspects of multimedia productions, from distance learning to multimedia
    hardware standards and codecs.  For my final project I decided to create a short movie, and attempt to
    digitize it and add special effects to it using my computer system along with some 'low-cost' video editing
    software.

    Due to major time considerations since I took the course over the summer, I was only able to create a final
    cut of the movie and add a few special effects, but not finish it.   I am still trying to find time to finish it and
    then hopefully put it up here.  It is basically a short Star Wars spoof, and was very fun to film.  I digitized it
    using an ATI All-in-Wonder PRO video card, and then edited it with some of Adobe's programs.  Since the
    raw video is taking up 90% of my hard drive space, it shouldn't be too long before I make the time to finish
    up the production!

(605.204) Intro to Assembly Language and Systems Software
-Programming Assignments:
   Various assignments in MIPS.  Code will be posted once class is over.

(605.451) Principles of Artificial Intelligence
-Programming Assignments:
   Some Lisp/Prolog assignments.  Code will be posted once class is over.

(600.757) Seminar in Computer Graphics
-Presentation:
   In this seminar each student takes a turn presenting a paper pertaining to Computer Graphics.  I presented
    the paper Realistic Modeling and Rendering of Plant Ecosystems, which was also part of the basis of my
    research/independent study. (see above)