3D graph visualization, pt. 2

Just some minor addition to my previous post. A nice video showing a quick flight through such a 3D graph:

Please excuse the poor quality. There was quite something involved in producing this video:

  1. Find a way to capture the render content. So the app now copies the OpenGL buffer to a
    Java2D buffer and writes it to disk using ImageIO (and that is done per frame with a fixed framerate).
  2. Secondly finding a binary of ffmpeg or mencoder for MacOSX is not easy if you don’t know where to look (yep, I know: ask google).
  3. As I wanted the video to look nice, I wrote some kind of director mechanism. So one can now automate actions within the 3D space using Groovy. Behind the scenes there is a fully timed command cue

All in all this is becoming really cool stuff :-)

Arduino based object tracking

This is a little weekend project I made some time ago. It basically tries to identify the closest object (using a scan from 0 to 180 degrees) and tries to follow it afterwards. If the LED is green, the device is currently homing on some object, once it’s red it has lost its tracking. A blue LED means the device is doing a full scan.

3D graph visualization

After I’ve started playing arround with the JME, there actually was something useful to do with it: visualizing complex UML models in the three-dimensional space. When I say complex, I’m talking about roughly 250 packages (making the vertices) and about 1500 edges (depencies and containment relationships between the packages). So there is quite some data to visualize.
Unfortunately the model I used for testing (and which is the main use-case) is confidential, so I’m not allowed to post screenshots or a demo of it. But as I wanted to show this thing I had to come up with another data source. And here it comes, the WikiCircle. After some minor modifications, a script transforming the YAML dump into some neat XML format and an importer to read that XML file I got some neat graph working.
One can highlight a specific vertex and it’s edges accordingly. As the graph shown here is always considered to be directed, one can highlight the from and to edges. As the program was initially intended to visualize pretty complex models, it is capable of showing the containment hierarchy using the Y axis (the lower the depper in the containment graph). For the wikipedia data, the rule is: the lower, the more irrelevant.
Maybe some other day I’ll post an interactive demo of this (especially once it is really interactive, like browse Wikipedia in 3D space). Until that there are only screenshots:

Yet another game of life

I’ve always wanted to do something with Java and 3D. Therefore a few years ago, I bought myself a book called “Killer Game Programming in Java“, but honestly only came to like the fifth page. Doing OpenGL or similiar just sucks when don’t even know what a (spatial) vector or matrix is.

A few years later and another year of school later, I do know what those stuff is. And I’m not going to mess around with Java3D anymore. This time it’s the Java Monkey Engine. And just to get my hands on this thing I wrote a small Game of Life implementation. Nothing fancy, and actually it’s just a few GOLs stacked up to become a cube. But nice anyway.

You wanna see this thing? Click here then and hope you’ve got Java WebStart at your fingertips.

Ahh, I forgot the keybindings:

ESC Exit
G Add a glider
R Add some random population
C Clear the population (like kill everyone)
RETURN Let there be evolution

The screenshot is not as much fun as the real “product” is, as you can’t see things evolving.

There’s no place like

As I’m going to study at the Hochschule Furtwangen University, I had to get a new place to stay (which is not necesarily something negative, but I also liked the place I lived before :-) )

Here are some pictures of my new flat

All in all, the room is bigger than I thought

Fork me on GitHub