Hello and welcome to my personal student showcase. This website is meant to be my own small portfolio, so feel free to explore some of my projects provided on this page. Please enjoy your stay.

Halfedge Data Structure

A halfedge data structure allows efficient adjacency queries on meshes. These queries are linear in time with the number of items found, while the data structure is constant in space. For my final thesis project I needed an easy to use halfedge data structure to represent surface meshes. I also wanted to store additional information per face and per edge. However, I couldn't find any suitable existing implementation and ended up writing my own tiny halfedge class, which I want to share. Class heds is my implementation of a simple and tiny halfedge data structure for triangle meshes. It is easy to use and provides basic adjacency queries for vertices, edges and faces. Currently it supports triangle meshes only, which may have boundaries or contain holes.
Tech: C++Links: source code

Grain Growth Simulation

Cuggs is the CUDA Grain Growth Simulation, a tool for simulating normal grain growth in the recrystallization process of fused metals. It is based on the Monte-Carlo-Potts model and has been implemented using CUDA for parallel execution on the GPU to increase performance. Cuggs allows to simulate and visualize both 2D and 3D grain structures, loading and storing of grain structures and performing statistical analysis on the grain distribution. The program was developed in collaboration with Dr. Dana Zöllner and Stefan Schäfer of the Department of Material Physics / Institute for Experimental Physics at the University of Magdeburg.
Tech: CUDA, OpenGL, GLUTLinks: win32 binaries + source code video screen shots

Photon Relaxation

Photon Mapping seminar talk
Using Photon Relaxation the visual quality of caustics can be improved by redistributing the photons after Photon Tracing directly on the Photon Map. By equally distributing or relaxing the photons, noise in caustics can be reduced drastically, while also detected features and discontinuities are preserved. The better distribution of photons allows to consider less photons in the Radiance Estimate and therefore reducing rendering times as well.
Links: slides handout original paper

Spinning Top

Brummkreisel (German for spinning toy top) is a small demo simulating the motions of a spinning top, after it has been nudged. The underlying physically-based model describing the top's behavior consists of a system of non-linear second-order differential equations and is solved numerically using the classical Runge-Kutta method. A first prototype was implemented in MATLAB, ultimately to develop this three-dimensional real-time simulation, which is visualized by a 3D model of a "Brummkreisel". Plots of a few time-dependent physical quantities give additional information about the oscillation, its amplitude and the rotational speed.
Tech: C, OpenGL, GLUT, MATLABLinks: win32 binaries + source code video prototype video screen shots

Particle Tracing

An unsolved question in cumulus cloud research was, where all the warm air rising inside a cloud is descending again: either distributed over the whole area after dispersing in a higher layer or directly at the boundary shell of the cloud. Particle tracing has helped answering this question and has been implemented for visualizing the air flow in the GALES simulation. Within the simulation domain a number of randomly distributed massless particles can be released inside a user-controllable box or plane. The particles then move with the wind velocity field, indicating how the flow behaves. To advect the particles trilinear interpolation on the staggered grid is used combined with the Runge-Kutta 4 integration scheme, both are done parallel per particle from CUDA kernels. The particles are then drawn as color-coded ellipsoids or arrow glyphs oriented in the flow.
Tech: CUDA, OpenGLLinks: ellipsoids video arrows video screen shots

Cloud Rendering

Clouds being in the focus of atmospheric research using the GALES simulation, they have to be displayed of course to provide the context of simulation and visualization. When visualizing different physical quantities their relation to the clouds is of great interest. A rendering method was implemented supporting realistic shading and shadowing. A physically based lighting model helps recognize the shape of a cloud, distinguish between separate clouds and enhances depth perception. The implementation consists of three steps performed in parallel on the GPU using CUDA. At first the direct incident light is computed, next the amount of light scattered towards each point is computed and finally the clouds are drawn as gaussian splats with the sum of both direct and scattered light as intensity.
Tech: CUDA, OpenGLLinks: video screen shots

Volume Renderer

Mass Carver is my attempt at a basic volume renderer utilizing hardware accelerated 3D textures on graphics cards to display volume datasets at interactive frame-rates. Raw 8-bit volume datasets can be processed and an accompanying metafile provides necessary additional information to built up the 3D texture. Among a description and resolution of the dataset, the metafile also contains an opacity and color transfer function. In the rendering cycle view aligned slices crossing the 3D texture are blended together creating a direct volume image or a maximum intensity projection, corresponding to the render mode selected.
Tech: C++, OpenGL, GLUTLinks: win32 binaries + source code additional datasets screen shots

Lattice Boltzmann Fluid Simulation

This demo shows my implementation of the Lattice Boltzmann Method in two dimensions (D2Q9) with the BGK collision model and bounce-back boundary conditions. The Lattice Boltzmann equations are solved on a 256x256 cartesian grid and the computations are performed on multiple processor cores if available utilizing OpenMP. Using the mouse you can steer a fluid within its rectangular container. You can also draw additional boundaries to create more complex geometries affecting the flow. Advected particles indicate the direction of flow while the speed of the flow is colorized with a blue to white color scale. This demo is also used in an educational course of the Intel Academic Program.
Tech: C++, OpenMP, OpenGL, GLUTLinks: win32 binaries + source code video screen shots intel course

Paciana Dones

My upcoming computer game, a 2D Indiana Jones parody in the good old Pacman style with a little bit of Boulder Dash. You have to find your path out of a labyrinth, collecting all the required items without getting to close to the mummy. Push or blast away rocks blocking your way. Explore hidden routes without closing known paths. Catch the mummy in a dead end with a rock or instead with some dynamite. ;) And prick your ears to help you avoid the mummy in the dark. Realistic lighting and particle effects put you in the right atmosphere between cold walls and unknown paths.
Tech: C, AllegroLinks: video screen shots

Mesh Forging

Mesh Processing seminar talk
My seminar talk about editing 3D-meshes using implicitly defined occluders, a free-form deformation technique called mesh forging. A three-dimensional model is deformed according to a "magnetic anvil" (the occluder) put into the editing space. The mesh's vertices are transformed using a prior defined displacement under the influence of the attracting force field induced by the occluder. This results in a deformation of the whole model.
Links: slides original paper

Flow Visualization of Bay Area

Visualizing the flow of water in the Greifswalder Bodden bay area was the assignment in the flow visualization class. Given was a dataset, containing the stream function as scalar field of an unsteady 2D vector field, simulating the flow in 25 time slices on a regular grid. The simulation was done by Kurt Frischmuth (University of Rostock, Germany). After deriving the vector field from the stream function and converting it into a steady 3D vector field the visualization is realized using VTK as Streamlines, Streamtubes and Illuminated Streamlines and different distributions of seed points were examined.
Tech: C++, VTKLinks: screen shots

Image-based Flow Visualization

An implementation of a few techniques for visualizing 2D vector fields, including extraction of critical points. Besides a modified version of Arrow Plots the visualization methods used are: Line Integral Convolution (LIC), Spot Noise, Texture Advection and simple Integrate & Draw. In my demo program a random vector field on a regular 5x5 grid is created, vectors inside of a grid cell will be interpolated. The output of the program will finally be an image generated with either visualization method chosen by the user, also showing the critical points if desired.
Tech: C++, AllegroLinks: win32 binaries + source code screen shots


FeatureIDE is an Eclipse plug-in to support the FeatureC++ language, both developed at the Otto-von-Guericke-Universität Magdeburg. In a group of two our students software project was to port, improve and extend the existing FeatureIDE implementation. The sparsely available documentation for writing Eclipse plug-ins slowed down the process of porting the old Eclipse version dependent code to a new independent code basis. Afterwards we added syntax highlighting of FeatureC++ source code and greatly improved GUI dialog control besides fixing glitches in the feature tree visualization.
Tech: Java, EclipseLinks: project page

Vertically Driven Pendulum

This special pendulum is not only swinging due to an initial displacement, but it is also excited by vertical motions of the pendulum's mount. Two java applets demonstrate this pendulum's nonlinear dynamics. The first applet shows the swinging motion for a user defined excitation function, dampening and initial displacement. The second applet generates a stability diagram, indicating whether the pendulum will fall back into its equilibrium position for different amplitudes and frequencies of the excitation function. To solve the pendulum's equations of motion numerically the classical Runge-Kutta method has been employed in combination with finite differences for the second order derivative of the height profile.
Tech: JavaLinks: applets java binaries + source code

Simple Arithmetic Processor

Arpro is a simple arithmetic processor, parsing and evaluating mathematical expressions, written in Java. It supports the main arithmetic operators and most common mathematical functions. Values and results of evaluated expressions can be assigned to variables, which then can be used in subsequent expressions.
Tech: JavaLinks: java binary + source code

Basic CAN-bus

A simple CAN-bus protocol was implemented under Linux in the Real-time Systems class using the Xenomai API. Over a self-made single wire line connected to the PC's parallel port, bit-wise communication is realized between several participating computers. Transmission errors are detected by bit-stuffing and collisions are handled as well. The implementation allows sending and receiving data with a unique user-defined ID using separate real-time threads.
Tech: C, XenomaiLinks: source code

Privacy notice. Content provided without warranty. Contact me at .