Normalized Graph Cuts
The goal of this project was to implement and understand how the
Graph Cut and Normalized Graph Cut algorithms can be used for
image segmentation. Further, we perform an in depth analysis
of the qualitative and quantitative differences between the
two algorithms. A series of test images are created to help
facilitate this process.
The goal of this project was to implement and better understand the
work by Perona & Malik on Anistropic Diffusion. Their framework shows
that a small change to the heat equation or diffusion equation can not
only preserve edges in images, but often enhance them as well. We also
see how a Nonlinear Scale-Space can be created to better capture the
structure of the image for segmentation. This project explores the theory
and implementation of anisotropic diffusion.
This project is my implementation of the inverse kinematics solutions
to animation, using the Jacobian method. Code supports multiple degrees
of freedom, both prismatic and rotational joints.
Watch on YouTube
Physically Based Mesh Deformation
This project is my implemention of the deformable mesh algorithm
from the paper "Interactive Virtual Materials", by Müller and Gross.
This method is physically based and runs at real-time rates for small meshes.
Watch on YouTube
Particle System (Snow/Fire/Smoke)
This project was implemented in order to become familiar with Particle Systems.
The demo displays snowfall, fire, and smoke particle systems. Euler
integration is used to compute timesteps due to forces such as wind,
heat, gravity, and drag. The system is rendered in OpenGL and runs in real time with a few
hundred thousand particles. Particles are rendered as point sprites in GLSL.
Watch on YouTube
Real-Time Caustics on Deformable Meshes
This project combines two techniques, Shah et al.'s
"Caustics Mapping: An Image-space Technique for Real-time Caustics" and Oliveria
et al.'s "Real-Time Refraction Through Deformable Objects." Banking off
our recent familiarization with XNA, we implemented both algorithms using
the framework and developed a small world to test in. The caustics algorithm
works efficiently by avoiding any explicit intersection calculations.
Instead, world positions of the scene are rendered to cubemap from the
perspective of the translucent object. Refraction is then computed from
the view of the lightsource and instead of looking up environment color,
the environment positions are taken. These positions are then rendered as
point sprites using Vertex Texture Fetch.
The goal of this project was to become familiar with the Microsoft's new XNA framework.
The XNA framework is built around DirectX with only a small subset of the API exposed.
The great feature about XNA is that if created carefully, the application or game will run
on both Windows and XBox 360 platforms. I chose to implement a simple projectile based game that
I had originally created in OpenSceneGraph. Porting this project to XNA was relatively simple and
the final implementation was much cleaner code. Shaders are written in HLSL.
Mixed Procedural Shading
The goal of this project was to mimic a real world object, in this case a piece
of granite rock, and then add an other worldly feel to it. To create this effect
I combined procedural techniques with explicit texturing. The model itself was created
to mirror the original rock, using Wings 3D. Procedural normal mapping is achieved using
a 3D noise texture and a novel normal blending technique. The view dependent rune markings
are texture mapped and blended into the procedural shader and varied with time to achieve a
Two Surface Refraction Shader
Implemented a multipass refraction shader using GLSL in OpenGL. The refraction algorithm
used is based off Chris Wyman's 2005 SIGGRAPH paper entitled, "An Approximate Image-Space Approach
for Interactive Refraction." In this method, depth information is used to approximate an exit point
of the refracted ray and apply the second refraction to find the final exit direction.
Implemented using OpenGL/C++. Input at runtime controls the dimensions of the maze. Once generated the user
is placed inside the maze and can find his way through. Features include Texturing, Collision Detection, and BSP culling.
A basic implementation of a RayTracing Engine. Images are rendered from models obtained from the Standard Procedural
Database or other NFF input files. Features include specular highlights, casted shadows, and anti-aliasing.
Renderman and Procedural Shading
As an exercise to introduce renderers, a simple scene of objects was entered programmatically, textured, and lit from several angles to provide a compelling image. Afterwards, several shaders were written in the Renderman Shading Language to model real-world surfaces. Included in the project were shaders for water, ice, concrete, snow, and marble tile.