Archive for category Projects
Chi-Puzzle
Super chi-puzzle. Features to be listed (if I every finish)
Broken Glass
Simulate broken glass on the iPod touch screen. Thought this would be a neat little app, so I spent a couple hours working on it and tried to sell it on the app store. After a long review period Apple denied it. Oh well.
Might as well upload the source code. It just simulates the break randomly by creating fracture lines and stopping fractures when other intersections are encountered.
Sliles
A small sliding tile iPhone app. Play up to the 6×6 puzzle. Use your own image for the tiles, or remove the numbers for the tiles. App also saves the state of your game, so you can close and resume playing at a later time. Also keeps track of how many games played to date, and how many you finished or aborted.
This project was co-authored by Stephen Eliuk. Search the App store for Sliles Tile Puzzle…and buy it!.
Windows Jumble Solver
I used to play Jumble in the morning (you know, the word game?) with my Grandma. This was a while back, and at the time I was tired of getting stuck on some of the puzzles and decided to write some code to solve it for me. This was the result.

Legacy
I finally got around to pulling out some old code for test apps that I had written some years ago.
Arkanoid
First one is arkanoid (break-out):

I miss living with my parents and working at a dead end job. It gave me motivation to work on little things like this. At the time I believe I was in my third year of my undergrad degree and it was either Christmas holidays or spring break. I had just finished spraining my thumb to the point where it had dislocated and the bone came through the skin. I started working on this gem and probably only spent maybe a day or two on it. Obviously never finished but it still may be fun to play. Download the windows binary (doesn’t work in wine) and try it out.
Bomberman
Next on the list is of course Bomberman. I still have some hidden obsession with bomberman. In this case, I totally ripped off the icons for the bomberman from the game, but I remember creating the textures for the fire (and most likely the board). This piece of work features randomly generated levels, partial multi-player support, mp3 player support (not sure how to use it anymore, using fmod sound). And of course some crappy AI. When I started this project (some time in the summer of 2002), I was interested in the AI for the game. The method I implemented used a strategy where the agent keeps track of the utility of places where a bomb will explode and ignores these positions while trying to break as many bricks. He is not much of an opponent as his primary goal is to destroy the bricks, but it was fun playing around with nonetheless. Thanks to Nathan Matthews for making a title screen:

See some of the screenshots below. If you try it out, make sure that you select player1 as keyboard1 and player2 as AI. Use ‘a’, ‘w’, ‘s’, and ‘d’ to move the player; ‘z’ to drop bombs, and ‘x’ to kick/detonate when you have a special.
Pacman
Not too much interesting with this one. Sounds real, I guess. The textures of the tiles are dependent on the underlying board, which is kind of neat I guess. The space key will chomp through the walls, so you can see what I mean. I can’t remember exactly when this project was concieved, but I would have to guess around christmas time.
tile world
Contract work. A simple environment (search the web) for agents to learn in.
The core functionality was implemented, but to my knowledge no learning agents were actually implemented in the environment.
More details, and potentially source to come.
Image-Based Face Tracking for VR
Not so much of a research topic as it was an attempt to duplicate some YouTube video that did Head Tracking for VR using a WiiMote (This wasn’t just some YouTube Video, but actually quite a popular one.)
There is a company seeingmachines that has a commercial version of a head tracker that they use for a similar purpose.
The non-pattern based one uses a 4DOF SSD tracker. I’m currently working on a port of the demo for the Mac.
Bomerman 4k
Yep, looks pretty crappy. It isn’t that easy to make a game fit into 4096 bytes. I thought it was easier, but once you set up a region to draw and get your keyboard input you really don’t have much space to work with. Not to mention the overhead from extra files in the jar-file nor the extra space taken by having multiple classes.
There are some real contenders for these types of games up at Java unlimited, which hosts a 4k game contest.
![]() |
Executable (bomb.jar) |
![]() |
Source Code |
Phd Progress
Vision-based Modeling of dynamic Appearance and Deformation of Human Actors
![]()
|
|
Abstract:
The goal of the proposed research is to capture a concise representation of
human deformation and appearance in a low-cost environment that can be seamlessly integrated
into entertainment and Virtual Reality applications–applications that often require
relighting, high levels of realism, and rendering from novel viewpoints. Geometric modeling
techniques exist in the current state of the field, but they focus solely on
geometric deformation and ignore the appearance component. I propose
a combined model of both geometric and appearance deformation, leading
to a more compact representation while still achieving high levels of realism.
Furthermore, many existing methods require input data from artists or expensive
Laser scanners. The proposed vision-based method is less expensive
and requires only limited manual intervention.In a controlled environment, several cameras will be used to acquire a dense
static geometry and a basic appearance model of a street-clothed human (e.g., a texture mapped model).
A skeletal model is manually aligned with the existing geometry,
and the actor performs a sequence of predefined motions. Multi-image vision-based
tracking techniques are used to extract the kinematic motion parameters that account for the
gross motion of the object. Multi-view stereo and silhouette cues, and temporal
coherence are used to extract the time-varying residual geometric deformation. These time-dependent
geometric quantities, and the time and view-dependent photometric quantities are used to create
the final compact model of appearance and geometric variation. Following several graphics techniques
for modeling articulated deformation and leveraging existing tools for image-based rendering,
the deformation model is built on top of linear blend skinning. Appearance and geometric variation
are modeled together as a function of abstract interpolating parameters
that include, e.g., relative joint angles and view angles. Examples of deformation include muscle bulging
and some forms of cloth budging. We model this compactly using a dimensionality
reduction and sparse data interpolation, where several low-dimensional subspaces and corresponding
interpolation spaces are used, effectively clustering
portions of the surface that are affected by the same abstract interpolators. Contrast to many of the
vision-based human modeling techniques, our complete model can be re-rendered under novel viewpoint,
novel animation, and even novel illumination when the illumination during capture is calibratedThe specified model also has potential applications in the use of appearance and
deformation transfer between different subjects. Furthermore, the combined geometric and appearance
model will almost directly transfer to similar domains, such as modeling hand deformations, or
related domains, as facial deformations. An improved model of geometry and appearance could also
be used to improve markerless vision-based motion capture. This work also hopes to better identify the
range of clothing and deformations that can be both captured and satisfactory modeled as a function
of relative joint angles neighboring rigid body velocities and other related external factors, such as direction
of gravity, and wind.
Documents
The third version of candidacy report is now available. The document is currently
a work in progress and should not be redistributed candidacy.pdf (Updated: Wed Apr 18 12:01)
Update: I passed my candidacy, more relevant details to the exam are on a separate page
Media
Multi-view tracking preliminary results.
Testing of collision bounding representation
ben_collision.avi
levset
This library contains classes that implement 2D/3D levelsets (full and narrow-band).
Features:
- explicit and implicit schemes for basic evolution equations.
- marching squares/cubes to obtain a surface.
- fast marching method (FMM) for re-initialization
- loading/saving data
There are also SIP python bindings, making it easy to prototype a solution. For example, to perform chen-vese segmentation, you would define a function that defines the evolution:
# evolution function, returns how much to move and maximum time step.
def fun(levset, image, stats, x, y):
l, d, k = levset(x,y), dirac(levset[x,y],2.0), levset.getCurvature(x,y)
pix = (image.pixel(x,y)&0xFF)/255.0
pin, pout = (pix-stats[0])**2, (pix-stats[1])**2
upd = d*(ak*k+(pin-pout))
return (upd, 0.98/(math.fabs(d*(2.0*ak/(xsp*xsp)+2.0*ak/(ysp*ysp))) + 0.01))
And then you would interleave this function call (bound with extra parameters using a lambda function), with the levelset motion and re-initialization calls
func = lambda levset,x,y: fun(levset, self.image, stats, x, y)
while not done:
stats = computeStats()
for i in xrange(0,3):
levset.moveWithCurvature(func)
levset.ensureSignedDistanceFMM()
#...

nmath
Basic math and vector routines. Features:
- Special classes for common vector/matrix sizes. General matrix class with interface to lapack for numerical routines.
- Minpack for non-linear least squares.
- Smart pointered data; all copies are shallow.
- Python interface.
nimage
Basic c++ image library. Features:
- Templated image classes (integer, floating)
- Smart-pointered; copies are all shallow.
- Plugins for input/output (jpeg, png, movies)
- Basic filtering operations (signed distance function).
- Python wrappers.
JShape



