Sohail Shafii's IDAV page

Point Processing, Analysis and Visualization

I am currently working on a project related with point processing, analysis and visualization with people from IDAV, research scientist Joshua Viers from the Department of Environmental Science and Policy, and colleagues from the Geology Department at UC Davis. The data sets we are working with are made up of three-dimensional scattered data created using LIDAR. Our long-term goal is to extract information from LIDAR data sets that would be relevant to earth scientists. To start off, we are extracting tree density information from LIDAR data that represents trees.

The first step of the project was to use a Hardy multiquadric interpolating function to get a general understanding of how the tree canopies look like. In our test data sets, the trees resemble lollipops so we developed an upside-down paraboloid filter which would march through our data points in an attempt find points that exist at the top of each canopy. These points would be ideal matches (called candidates) for such a paraboloid since one could conceptually fit a nice paraboloid at the maxima of a canopy as opposed to a points on the canopy edge. The paraboloid filter is run through a filtered data set that has had noise (points beneath canopies) removed -- such noise would slow down our algorithm and change its behavior.

Next, a window walks through the data set and attempts to find the best paraboloid fit on the LIDAR points. This algorithm is based on RANSAC/MSAC. By using this filter, we would have one point per canopy and can easily identify the number of tree canopies in our data set.

I am currently working with various data sets from the Consumnes and Sacramento River regions. After the paraboloid fitter is run, I spit the canopy maxima locations and their corresponding radiuses to a text file.

This information will be updated when necessary.

Multi-Resolution Volume Rendering

This is a volume renderer that renders volume files (MRI/CAT scans) and png slices that would normally be too large for main memory by using out-of-core techniques. This includes main-memory and graphics card caching. It also represents the data in multiple resolutions for higher frame rates.

This (undergraduate) project is currently not being worked on.

These are some school projects (starting from the most current):

Sea Ice Visualizer (ECS 177 -- Team projects)

This is a program that visualizes sea ice concentration at the North Pole from 1978 to the modern day. There is an artifact (a small hole) because there was an area where the satellite could not measure sea-ice concentration. In this case sea ice concentration means "how much ice exists at right now at this point?" In my program's case, not a whole lot.

Like other 177 projects, the UI was created using Qt4.

YouTube video link.

Volume Visualizer (ECS 177 -- Team projects)

This is the first volume renderer that I have written for a class. It reads volume files (MRI/CAT scans) and visualizes them via texture slicing (OpenGL/hardware) and software raycasting.

It has a customizable color and opacity transfer function (unlike my GPU raycaster).

YouTube video link.

Tensor Visualizer (ECS 177 -- Team projects)

A program that visualizes the stress (stretching and compression) of a tectonic plate sinking under another. The original data was simulated. The color scheme allows the user to guage the temperature. The rendering methods employed are: textures to illustrate stretching/compression, vector glyphs to indicate direction, and streamlines.

YouTube video link.

These are some personal projects and are not affiliated with any company or educational institution (starting from the most current):

Software Rendering (rasterization, not raytracing)

I wrote a Software Renderer so I can get a better idea of what a graphics pipeline is. It uses no OpenGL or DirectX functions. Most of the functionality is fairly rudimentary and includes: transformations (rotation, scaling, translation), projection (perspective), clipping before perspective transform, perspective divide, Bresenham line drawing algorithm, and triangle rasterization.

The program can currently draw triangles and lines. I do not plan on working on it further.

Volume Rendering using GPU raycasting

This program is based on the J. Krüger and R. Westermann paper entitled Acceleration Techniques for GPU-based Volume Rendering. It draws rays calculated by the difference of two textures: one representing the back faces of a cube (which you draw inside of) and one representing the front faces of the cube. Please see the paper for more information.

I have also included an axis-aligned slices version. Right now there is no user-customizable transfer function -- I only wrote this program to get a feel for volume rendering and GPU programming. Please look at my class projects sections for a more complete volume renderer (under construction).

Collision Detection

Using some articles as a guide (with a NeHe article as starting point for my code), I created a demo of a ball bouncing off walls. This was a simpler version of the NeHe program and focused just on collision detection and response. The collisions test the ball's center against the walls so the ball tends to "dip" into the walls. I do not feel like fixing this because this program was just a demo of simple collision detection and handling.

After I read Nathan Ostgard's article on Quake 3 collision detection, I then attempted to do collision detection (and handling) on an ugly, but simple Quake 3 level. The article didn't explain the algorithm completely and I was not so successful here...I will get back to this project when I have the chance.