artist - 3D scanner

(11/2009 – 05/2010)
Title: Software Lead
Members: 4
Language: Open Frameworks, OpenGL (C++)

We built a device to scan 3D objects and render them digitally. We designed Artist to use a webcam and line laser to read 2D points along an illuminated line. The base was manufactured to include a rotating platform and hardware to control the stepper motor and laser.

Tim (hardware) also created a custom serial driver to recieve messages from the software to turn on/off the laser and rotate the platform. The hardware also included an Arduino microcontroller to control messages from the software side (via USB), the line laser, and stepper motor.

The software side renders the object by capturing the webcam image, filtering the laser line, tracing the line and translating the points in a 3D space. It also features custom settings (background color, render by points or solid texture, render with/without color, etc) and a multiple window interface. Windows are draggable and resizeable, and files can be loaded and saved with a ".artist" extension.

Our challenges with this project came with the software. There were many different ideas on how exactly to implement each part. For example, both software developers (myself being one) developed the line tracer algorithm.

My line tracer was to create a bightness and contrast filter to darken the dark pixels and illuminate the pixels of the line. My method was fast and lightweight, yet we realized later that our webcam would auto-adjust the lighting (an aggrivation).

Ava (other software) created an algorithm that took webcam data with the line laser turned off, then captured the webcam data again with the laser turned on. She then compared the pixels from the two sets and calculated the line using a threshold difference and a cubic spline. Her method, though efficient, was slow not only on the software side, but the hardware couldn't keep up with the software.

Overall, our product was very successful, but we had less time for unit testing than we had originally planned.

ebook reader

(04/2010 – 05/2010)
Language: Ruby

This is an Open-Source, GUI eBook reader in written in Ruby. The project is intended to be a back-end BitTorrent client based on the BitTorrent protocol. It searches for a given author, book and parses torrent files for torrent location and file information. the eBook then sends a request to the announce (the tracker), connects to the peers, then downloads the file pieces from peers.

Usually eBooks come in PDF format, and this uses a PDF reader to parse and display the PDF book contents. The GUI allows the user to search for a book by author and title, read the book by turning pages, and load/save functionality will be also included.

There were many challenges with this project, mainly with the torrents that I was using. I was searching and parsing torrents found on, and I didn't realize that they had taken down their trackers. Also, Ruby can easily create a PDF, but has trouble parsing PDF's. All other difficulties are described in the README.

squirrely ice adventure

(01/2010 – 04/2010)
Title: Software Developer & Art Director
Members: 5
Language: C#

We built a side-scrolling video game with the XNA framework and a team of five. I created custom artwork to animate the main characters, Scrat and Scratte (from the movie series Ice Age), and the software can be played with a keyboard or Xbox controller. It features load/save options, character choice, enemy intelligence, hazards, multiple movements, custom interface screens and levels.

I will package the executable as soon as possible, but the developer who added the animations directly linked to a folder on C:\ drive. I need to finish compressing all of the images, and should have this by Monday June 7, 2010. Also, the XNA Framework 3.1 is necessary to run the executable, and that can be downloaded on the Microsoft Downloads - XNA 3.1 page.

duck hunt

(03/2009 – 04/2009)
Title: Lead Software/Hardware Developer
Language: Motorola Assembly, VHDL
(basic), (full)

This version of Duck Hunt was implemented using an FPGA and a Motorola Microcontroller in a team of two. We created a custom VGA video driver to display the duck animation and user’s target. The video driver would construct pixel colors relative to the duck and target’s location using conditional logic, making each appear dynamically. The assembly would control mouse input (the gun), and keyboard input (a gun fire), and flush the information to display a target crosshair. The duck would fly in nearly random flight patterns in directions, and collision detection was implemented.

cat catch

April 2009
Language: C#
(basic), (full), (exe)catcatch.exe

This project is another animated game. You play as a cat that can walk and jump in the clouds to try and catch ice-cream. Who really knows how this concept came to me, but the cat can never actually catch the ice-cream because it will vanish and reappear somewhere else. The real merit in this project isn't in the simple animations and movements, but that the game is networked. As long as one player starts a new game and another player joins the game by entering the IP address of the first, the two can play together.

This was my first attempt at C# client/server sending and recieving messages, so it has plenty of flaws. This was only my second project developing in C#, so you can easily find flaws. You'll notice that the game isn't multi-threaded (only one cat can move at a time). You'll also see that the ice-cream location isn't the same for each player. These are all fixible, but I wanted to leave the game as I had created it back in April, 2009.

To play, use the arrow control keys. For example:

run left: left arrow key
run right: right arrow key
jump: spacebar
jump up: up arrow key + spacebar
jump down: down arrow key + spacebar

java solitaire

March 2008
Language: Java

This project is the GUI Solitaire game. Card, Deck, Stack, Solitaire and SolitaireGUI are classes included in this project, and the GUI is implemented with the swing package. Cards are clickable and dragable, and it is draw three. There is also a really simple toolbar, and you can double-click a card to the bank, but cards can't be removed from the bank once put there.

Run the project by compiling all classes and the class steps into main, not the SolitaireGUI. A simple, lightweight Java compiler is JGrasp, found at

google drinks

August 2009
Language: Frontal code, (Flash/Actionscript/XML)
(demo)googledemo, (source)site.xml

This little demo was supposed to be featured along with other demos that I developed on the frontal website, but at the time, Google did not allow cross-domain access of Google Docs and Spreadsheets. What this demo does is build a custom CMS from a Google Document and a Google Spreadsheet. Like the Flickr and Twitter demo, this is meant to show the ease that a user can integrate with online technologies.

This is a real-time drink recipes website. It shows how Frontal send/recieve requests and can parse encoded data. There are two Cosmopolitan recipes to show how the code can handle duplicate data, and there are transitions that show how a simple idea can be made into elegant eye-candy.

I actually just realized that Google now allows Flash access to Google Docs, and I let Basik know. They posted a topic in the Frontal forums. The real Google spreadsheet is found at

ers - egyptian rat slap

March 2009
Language: C#
(source), (exe)ERS.exe, (cards)cards.dll

This is a card game inspired by my absolute favorite card game to play in a group. As it turns out, it is less fun to play on the computer. To win the game, the player needs to "slap" the deck to grab the cards, and this was a bit difficult to implement with computer players (and the many try/catch exceptions thrown). This was my first project in C#, and because I used the XP cards.dll, this executable can only be run on Windows XP. I added the cards.dll to the above, but don't know for sure if moving them to C:/Windows/system32 will allow the executable to run.

There are three different speeds that the player can select, and any of the different card backs can be selected and played.