to the presentation and documentation web pages of the Gottorfium project. Here you can learn

Happy reading!

Sebastian Bechtold and Nils Weiher,

May 2008

What is Gottorfium?

Gottorfium is a software application that aims to be a realistic visual simulation of sky. It draws stars, planets, moons and other things in outer space as they can be seen from any given location in the planetary system at a given point in time within ca. +/- 5000 years from now. You can move through the planetary system in free-fly mode or place youself on a specific geographic location on any celestial body that is simulated and watch the skies from there.

The program was developed at Heidelberg University's Interdisciplinary Institute for scientific Computing (Interdisziplinäres Zentrum für wissenschaftliches Rechnen, IWR) from November 2007 until April 2008 by two students of applied computer science, going for a Bachelor of Science degree.

The relation to the Gottorf giant globe

The original goal of the project was to extend an already existing application, an interactive virtual model of the Gottorf Giant Globe, which has been developed at the IWR during the last two(?) years, with a celestial mechanics simulation, so that phenomena like day/night, seasons and the paths of various celestial bodies across the sky could be visualized within the context of the globe model.

After analyzing the source code of this application, it became clear that implementing these features on top of the existing code base would not be practical for a number of reasons. Instead, we decided to develop a new program from scratch and re-implement the features of the old virtual globe application (or at least a subset of them) back into this new software.

Because our personal interests focused clearly on the visualisation of the celestial objects, and not so much on the Gottorf globe, the result of the development process was basically a rather conventional solar system simulator, while the visualisation of the Gottorf Globe degenerated into an optional feature that isn't even activated by default (and the required textures not included in the downloadable simulation data package, but this is primarily because of copyright reasons). Aside from perhaps a few screen shots, the documentation on these web pages does not cover the features of the program which are related to the Gottorf globe.

The Moon, rendered by Gottorfium
Image: The Moon, rendered by Gottorfium with high-resolution surface texture. Note the surface feature markers.

Implemented astronomical concepts

As already stated above, there are two classes of objects that are simulated by Gottorfium: Objects that belong to the planetary system, like planets, moons, asteroids and spacecraft, and objects that are located (far) outside of the planetary system, like other stars, nebulae and galaxies (so called deep-sky objects).

Computation of planetary orbits and positions (also known as "ephemeris calculation")

The planetary system and the objects that belong to it are simulated in realistic three-dimensional space, with the correct relation between distances and sizes. The orbits of the eight major planets (Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus and Neptune) are calculated using VSOP87 (Variations séculaires des orbites planétaires), one of the most accurate methods for ephemeridis calculation that are freely available today. The orbit of the Earth's Moon is calculated using another highly accurate method called ELP2000. The orbits of other objects (asteroids, spacecraft etc. - there aren't yet many of them implemented) are calculated from static orbital element values using the Kepler equations.

Orientation of objects in space

To completely describe an object's spatial situation, you do not only have to say where it is located, but also how it is orientated, that means, in which directions its three axes are pointed. For celestial bodies, this means for a given point in time: "Towards which celestial coordinates it the object's rotation axis pointed right now?" and "What is the current progress of the object's rotation?" (in other words, what is the current time of day at, for example, the prime meridian). To answer these questions and model the situation as accurately as possible, Gottorfium uses the tables and formulae published in the Report of the IAU/IAG working group on cartographic coordinates and rotational elements (release of 2006), which seems to be some kind of quasi-official source for this data (at least, it looks very serious). This allows us to model each planet's orientation at a given point in time at very high precision.

Outer view of the solar system, rendered by Gottorfium
Image: The outer view of the solar system with all information layers, rendered by Gottorfium..

The final frontier: Objects outside the solar system

In Gottorfium, three-dimensional space is limited to the planetary system. While you can travel away from the sun and the planets as far as you wish (this is only limited by your computer's number representation capabilities), it is not possible to travel to other stars, galaxies, or, generally spoken, anything that is located outside of the planetary systems at incredibly huge distances. The program can display such objects, but if you try to move towards them, you'll never arrive. In the simulation, their distance is infinite. This can be seen assome kind of analogon to the ancient conception of the "celestial sphere": All the stars, galaxies, nebulae and other things sit on the edge of this sphere, and whereever you go, the sphere is always centered on you and/or its radius is infinite.

The circumstance described above leads to the effect that the starry sky looks exactly the same from any place in the solar system: The so-called parallax effect (the apparent motion of an object in the field of view, relative to the position of another object) is not simulated. While this is clearly a lack of accuracy of our model, it's effect on the overall result is less than marginal: The parallax of objects outside the solar system when observed from different places in the solar system is so small that it is not noticeable to the naked eye.

Mars rendered by Gottorfium
Image: The planet Mars, rendered by Gottorfium with high-resolution surface textures

Program architecture and applied technologies

The whole program is written in C++, using OpenGL for graphics output and GLUT/FreeGLUT as the window manager interfacing library. We made extensive use of object oriented programming concepts, so the code is highly modular and extensible. Almost every main component is defined by an abstract class and can be replaced by other implementations. One thing that I'm proud of is that we have a strict seperation of the code that is responsible for the physical simulation from the code that is responsible for the graphical visualisation. In other words, it would be quite easy to replace the current OpenGL graphics code with something else (for example, a front-end that generates static sky chart images) or move the simulation code to a separate library. No other comparable program, of which we know the source code, has such a clean separation in its architecture.

Simplified UML diagram of the program
Image: Simplified UML diagram of the Gottorfium application

The simulation data set

What's in it by default

Almost all source data that is used as the basis for the simulation (i.e. orbital elements of the simulated objects, constellation lines, geographic surface locations etc.) is stored in XML files. This allows easy modification of practically every aspect of the simulation even for non-developers. The default simulation data set models our solar system (the sun, the eight major planets, the Earth's Moon and a few other objects) and the ca. 4000 stars that are listed in the Yale Bright Star Catalogue (YBSC). The YBSC is contained in the default data in the form of a simple text file. Currently it is the only source for star data that is supported by the program, but, as stated under "Program architecture and applied technologies", it would be easy to add support for other star catalgoues, respectively the file formats in which they are distributed.

Possibilities for modification and extension

As already stated above, it is easy to extend or totally replace the default data set by something else. You could, for example, recreate some extrasolar planetary system or an imaginary planetary system from your favourite science-fiction story. As long as the system is not too exotic (like irregular, non-elliptic orbits, which are not supported at the moment), there are only few limitations.

Earth, rendered by Gottorfium
Image: Earth, rendered by Gottorfium with high-resolution surface textures

What's missing

Although we invested a lot of time into the development of the program during the last six months (as of May 2008), its overall "look and feel" is still quite rudimentary. A comparision with similar applications like Celestia or Stellarium quickly results in a long list of deficiencies and missing features. Here are my personal 20 most important ones (roughly ordered by importance):

Comparing Gottorfium with the programs that inspired us most

Feature / ProgramGottorfiumStellariumCelestia
User Interface
Free-Fly modeYesnoyes
Ground-based modeYes, rudimentaryyesyes
Overall user-friendlinessbadok, but could be betterok, but could be better
Graphics - Visual quality and performance
High-res virtual planet texturesYes, rudimentarynoyes
Eye candy in ground modebadgreatok
Eye candy in free-fly modeaveragebad, n/agreat
Accuracy of the celestial mechanics simulation
Orbit calculationsvery goodvery goodvery good
Planet orientation/attitude calculationsvery goodgoodvery good(?)
Provision of light travel speednounknownunknown

Future development / possible roadmap

Currently, Gottorfium's situation in terms of future development is unclear. It is possible that it will never see any further significant improvements, but at least theoretically, I would like to continue working on it, if i can find the time to do so. Here is a possible roadmap:

Phase 1

  1. Develop a new client application, based on SDL and OpenSceneGraph.

    This could greatly improve performance on slower machines and simplify the implementation of more advanced graphical content and effects. For example, it is very easy with OSG to load and display 3D models from a wide variety of file formats. This would allow us to introduce things like spacecraft (ISS, satellites, planetary probes etc.) or irregular shaped asteroid models.

  2. Fix the most annoying bugs and implement the most important basic features that are still missing.

    These are:

    • Get the PSO orientation code to work properly. [done]
    • Lock the camera rotation with the planet's rotation in ground observer mode. [done]

Phase 2

  1. Implement new UI features and information layers which should be not too hard to code.

Phase 3

  1. Try to implement advanced features like ultra-high-resolution texture level-of-detail or maybe even spacecraft physics simulation (making a space flight simulator like Orbiter Sim would be really cool...)

Download and installation

Gottorfium is free software, released under the GNU Public License (GPL). To install the program on your computer, please read the following instructions.

  1. Fullfill the requirements to compile and run Gottorfium.

    So far, Gottorfium has been developed and tested only on Linux (Kubuntu 7.10 and newer). Nevertheless, the code should be faily platform-independent, which means that it should be possible to compile and run it under many other operating systems, including Mac OS X and Windows 2000/XP/Vista, as long as OpenGL hardware 3D graphics acceleration is available and the following libraries are installed:

    • GNU Make and C++ compiler (g++). A free software package that includes all required tools to compile and link a C++ program based on makefiles.
    • GLUT or FreeGlut + development headers. GLUT is a library that provides an interface between OpenGL and the graphical user interface system of your operating system.
    • FreeImage + development headers. FreeImage is the library that we use to load the image files which are used as textures.

    I can't tell you exactly how to install these libraries on your computer, since the procedures are different for each operating system, and even for one OS, there might be more than one way to do it (for example, package-system-based installation vs. compiling it on your own).

  2. Get the source code

    Download the source code archive and uncompress it into a folder of your choice: gottorfium-source_2008-06-30.tar.gz
  3. Compile the program

    Move to the directory Gottorfium-SVN/Debug and run make there. The program should now be compiled. If an error occurs, this probably means that the requirements described above are not fulfilled at some point. In this case, you should try to understand the problem and fix it ;).
  4. Get the data files

    Download the data files archive and copy its content to Gottorfium-SVN/Debug/data: gottorfium-data_2008-06-30.tar.gz
  5. Run the program

    That's all. Gottorfium should now be ready to run. Start it by running the Gottorfium binary in you Debug folder.

Using the program

Currently, Gottorfium has only a preliminary user interface. You can

More UI features like, for example, the possibility to select an object to display information about it, were planned, but didn't make it into the program (yet).

There are three ways to interact with the program, and each covers a subset of the available commands:

The following table contains the most important user commands and how to envoke them:

InputInvoked Command
<w> or mouse drag forwardsRotate the camera up
<s> or mouse drag backwardsRotate the camera down
<a> or mouse drag leftRotate the camera left
<d> or mouse drag rightRotate the camera right
<W>Translate the camera forwards
<S>Translate the camera backwards
<A>Translate the camera to the left
<D>Translate the camera to the right
<r>Set camera translation step size (speed of moving) to high
<f>Set camera translation step size (speed of moving) to medium
<v>Set camera translation steps (speed of moving) to small
<y> or mouse wheel backwardsIncrease FOV angle (zoom out)
<x> or mouse wheel forwardsDecrease FOV angle (zoom in)
<+>Increase simulation speed (time passes faster)
<->Decrease simulation speed (time passes slower)
<n>Reset simulation speed to real time
<t>Reset simulation time to current computer clock
<Esc>Quit the program
<m>Release the camera from a surface location back into free-fly mode
right mouse buttonOpen pop-up menu
In the pop-up menu:A number of entries to set drawing options, select a ground observer location and control simulation time

More documentation material

Besides these web pages, we have created a few other files that document Gottorfium in one or another way: