Jon Volkmar

HTML5 Canvas Memory Game

2015-10-11T00:00:00+00:00

This is a little memory tiles game that is programmed in CoffeeScript and uses the HTML5 canvas API for simple 2D rendering and animations. It was originally made in a hackathon designed to interact with an Arduino robot - if you won the game, the robot would do a little dance. Unfortunately I do not have a video of the dancing robot. The code is up on my GitHub.

The object of the game is to flip over matching pairs of tiles until all the tiles are flipped over.

Pyro - The Anti-Social Game Where the Object is to Burn Down a Forest

2015-09-28T00:00:00+00:00

Pyro was developed by myself, Claudia Goldberg, and Mehrdad Dehdashti during a hackathon in January, 2012. The game invites you to attempt to burn down a forest by clicking on trees and watching the fire spread. This version is a prototype - the gameplay aspects are not anywhere near polished - but there is something perversely satisfying in watching a the pixelated trees burn in front of your eyes.

Pyro is programmed in CoffeeScript and uses the HTML5 Canvas control. The code is up on GitHub.

You can try it out below. Note that there may be some glitches when playing on your phone or tablet.

PYRO: The Environmentally-Unfriendly, Anti-Social Game

FaceBulge - Make Faces Pop!

2015-09-28T00:00:00+00:00

FaceBulge is a hack created by Jon Volkmar, José Tomás Albornoz, Daniel Snider, and Tina Yang. Submit an image containing one or more faces, and FaceBulge will use our special algorithm make them bulge! It may not work as expected on mobile platforms.

We used face detection algorithms from OpenCV on the backend, WebGL for 3d graphics on the frontend, and Node.js as our web framework.

Our code is on GitHub: https://github.com/j-v/FaceBulge

Content-Based Image Retrieval Using the Earth Mover's Distance Algorithm

2015-09-20T00:00:00+00:00

As a course project during my time at Freie Universität Berlin, my teammate Martí Griera Jorba and I experimented with various algorithms relating to shape matching and feature extraction in images. The project was coded in C++, making extensive use of the OpenCV library for computer vision. The image below illustrates some of the algorithms we used to extract features from input images, resulting in a representation of the image as a weighted point set.

Data from edge detection done using the Canny algorithm, corner detection using the MinEigenVal algorithm, and the intensity gradient computed using the Sobel operator were combined to generate the resultant point set. We used OpenCV implementations of all three algorithms.

To compare the weighted point sets, we used the Earth Mover’s Distance (EMD) algorithm, as implemented by Yossi Rubner.

Visualization of EMD computed on two images of simple shapes. Larger points indicated larger weights, and thicker lines indicate higher flow between points

With the feature extraction and comparison algorithms in place, we can query a database of images, and retrieve the closest matches.

Closest matches to the query image, as reported by our EMD comparison engine. Dataset: Brown Shape Indexing of Images Database (SIID)

The EMD image retrieval engine effectively returns matches for a database of simple images, such as the dataset of silhouettes shown above. For more complex datasets, the results are… mixed.

Image retrieval results of a larger, more complex dataset. Dataset: 500 image subset of the Caltec 101 Categories Dataset

It can be interesting to visualize an image database globally to examine the computed similarities of the images. We did this using a multidimensional scaling algorithm, which plots each image into 3D space. Images which are computed to be most similar to each other wind up closest to each other in the 3D space. We used the freely available MDSJ - Multidimensional Scaling for Java library, and created a 3D visualization using Processing.

The SIID image dataset visualized in 3D space. Each image class is given a different color. Images nearest to eachother in 3D space are most similar as computed by EMD.

Real-Time Velocity Field Estimation with Kinect

2015-08-23T00:00:00+00:00

As part of McGill course COMP558 - Fundamentals of Computer Vision, my teammate Beomjoon Kim and I used a Kinect sensor and the “optical flow” algorithm from OpenCV to obtain a velocity field of the sensor’s surroundings. The intended application is for a autonomous robot to be able to detect the flow of pedestrian traffic around it, in order to aid it in navigation.

The implementation is coded in C++, and the computations are performed in real-time.

Famous Faces - An Experiment in Quad-Trees and Image Processing

2015-08-23T00:00:00+00:00

Famous faces are amongst the most recognizable subjects to human eyes, but what happens when photos of famous faces are mangled using algorithms that re-imagine their composition?

Image processing is done using my custom-made ImageMirage Python scripts. The ImageMirage algorithms break up images into rectangular regions based on color, then replace the regions with snipped images of roughly similar colors. The effect is a dazzling mosaic of disparate subjects, but the original famous face is still quite recognizable.

Find ImageMirage on GitHub.

Clinton Series

Jesus Series

Mona Series