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 MonteCarloPotts 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, GLUT  Links: 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 physicallybased model describing the top's behavior consists of a system of nonlinear secondorder differential equations and is solved numerically using the classical RungeKutta method. A first prototype was implemented in MATLAB, ultimately to develop this threedimensional realtime simulation, which is visualized by a 3D model of a "Brummkreisel". Plots of a few timedependent physical quantities give additional information about the oscillation, its amplitude and the rotational speed.

Tech: C, OpenGL, GLUT, MATLAB  Links: 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 usercontrollable 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 RungeKutta 4 integration scheme, both are done parallel per particle from CUDA kernels. The particles are then drawn as colorcoded ellipsoids or arrow glyphs oriented in the flow.

Tech: CUDA, OpenGL  Links: 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, OpenGL  Links: 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 framerates. Raw 8bit 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, GLUT  Links: 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 bounceback 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, GLUT  Links: 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, Allegro  Links: video screen shots 
Mesh Forging
Mesh Processing seminar talk
My seminar talk about editing 3Dmeshes using implicitly defined occluders, a freeform deformation technique called mesh forging. A threedimensional 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++, VTK  Links: screen shots 
Imagebased 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++, Allegro  Links: win32 binaries + source code screen shots 
FeatureIDE
FeatureIDE is an Eclipse plugin to support the FeatureC++ language, both developed at the OttovonGuerickeUniversitä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 plugins 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, Eclipse  Links: 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 RungeKutta method has been employed in combination with finite differences for the second order derivative of the height profile.

Tech: Java  Links: 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: Java  Links: java binary + source code 
Basic CANbus
A simple CANbus protocol was implemented under Linux in the Realtime Systems class using the Xenomai API. Over a selfmade single wire line connected to the PC's parallel port, bitwise communication is realized between several participating computers. Transmission errors are detected by bitstuffing and collisions are handled as well. The implementation allows sending and receiving data with a unique userdefined ID using separate realtime threads.

Tech: C, Xenomai  Links: source code 