A simple game made with Unity attempting to recreate the Wii Play Tanks mini game as part of the final project of my Game Design and Development course completed in just a couple days.

Available to play online here.

Use WASD/Arrow keys to move your tank. Point and shoot down all enemy tanks to progress to the next level. There are 5 levels in total. Note: you’ll need to turn on sound, enter full screen mode, then click to play! The game was not made to originally be published online so the WebGL version lacks some of the lighting of the original and seems to have floaty controls.

The following are a few of the most interesting projects completed for the Intro to Computer Vision course which implement several basic computer vision tasks. The results seen in each of these reports were produced by implementing the relevant algorithms from scratch using NumPy. OpenCV was only used for loading images or drawing on top of images.

Canny Edge Detection

The purpose of this project was to implement the Canny Edge detection algorithm which consists of 5 main steps: gaussian smoothing, calculating the image gradient, selecting thresholds for the gradient magnitude, thinning the gradient magnitudes by suppressing non-maxima, and finally, linking strong edges along weaker edges.

This was the final project for a Computational Optics seminar completed in collaboration with Claire Paré. Made in a jupyter notebook with numpy and matplotlib, the first aim of this project was to create a simplified version of this 2D ray-optics simulator. The initial goal was to show the paths of light rays through transparent spheres with various indices of refraction and accurately model Fresnel effects to showcase how the amount of reflected and refracted light depends on the index of refraction and incoming ray angle. Next, we implemented continuous refraction, showcasing the bent paths light rays take as they travel through objects with spatially varying refractive indices. Our implementation of this was based off the paper Path Tracing Estimators for Refractive Radiative Transfer by Pediredle et. al., from whom we also got the idea of modelling Luneberg lenses.

This project was part of an independent study where I, along with a few other students, were extending a pre-existing ray tracer made by a PhD student, Kelly Jiang. What follows is the report I submitted for the project that runs through the different camera systems I implemented with a brief explainer and example results of each.

Introduction

Ray tracing has the unique advantage of easily simulating many different types of cameras. All we need is to provide the appropriate outgoing ray from the camera system and let the ray tracer take care of the rest. The ability to simulate different types of cameras opens up many artistic possibilities when making rendered images or animations. For instance, one of my favorite artistic uses of a realistic camera system can be seen in Toy Story 4. In this movie they modeled several different types of cameras including the simpler spherical lens camera (which are discussed later in this report) as well as more complex split-diopter (fig. 1) and anamorphic lenses. The YouTube channel Nerdwriter has a good explainer on the artistic impact of these lenses in this video. Ofcourse, realistic camera simulations can also be useful for research. For example, the Dahl lab at Northwestern is currently in the process of simulating images from their bubble chamber. The cameras peer into the bubble chamber through a series of relay lenses which need to be accurately simulated for correct results.

This was the second project I completed for my intermediate graphics class and my introduction to ray tracing. The goal of this project was to create a simple ray tracer with implicitly defined shapes such as spheres, cubes, and cylinders with various types of materials that are illuminated using the Phong reflection model. The ray tracer also features recursive reflections, soft shadows, transparency, and shape tranformations such translation, rotation, and scaling along any given axis. The ray tracer was built using typescript and WebGL, and features a wire mesh preview of the scene that exactly matches the ray traced result to help set up the scene and the camera. As with the particle system project, this project also uses dat.gui to create a control panel that allows the user to change every adjustable parameter including resolution, super sampling rate, and light position and color.

The first of two projects completed for my intermediate computer graphics class. The goal of this project was to simulate and render multiple different kinds of particle systems simultaneously in a navigable 3D environment.

The project consists of a cloth simulation, a Reeve’s particle fire, a boids simulation, and a position-dependent force vector field tornado. Almost all input parameters for the different particle systems are adjustable by the user allowing them to play with different combinations of settings and see how they effect the simulations. These particle systems are implemented using a series of force and constraint applying objects and each of them can be numerically integrated using one of several integration methods.