Jonathan Bronson

Jonathan Bronson, PhD

University of Utah
School of Computing
bronson at

Old Page
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.
Anisotropic Diffusion
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.
Inverse Kinematics
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
Download Video
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.
XNA Development

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 pulsing glow.

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.
BSP Culling

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.
Basic Raytracer

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.