to the presentation and documentation web pages of the Gottorfium project. Here you can learn
- what the Gottorfium program does,
- what it does not do (or not do well),
- how it works,
- how you can download and install it and,
- how it compares to similar programs.
Sebastian Bechtold and Nils Weiher,
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.
- 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.
- 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.
- 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.
- 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.
- Image: Earth, rendered by Gottorfium with high-resolution surface textures
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):
Implement correct planet attitude calculation[Done since version 2008-08-29] Improve star rendering. Especially find a good function that maps a magnitude value to a tupel of (color, radius) for realistic looking "dot of light" representations of stars and other objects.[done since version 2008-07-23]
- A better GUI, maybe using Qt or another GUI toolkit library. Especially allow the user to enter ground observer mode at any self-defined geographic coordinates on any celestial body, not only at pre-defined locations, as it is currently the case.
- Better virtual texture support, especially an intelligent texture memory management solution. Without such a thing, virtual texture support is almost useless, since its application is extremely limited by the amount of available graphics card memory.
- Support saving and loading of the simulation status, perhaps URL-based like in Celestia
- Implement the possibility to select objects by clicking on them and display information about them
- Display constellation names
- Display constellation artwork (see Stellarium)
Improve performance and display quality of orbit line drawing[Done since version 2008-08-30]
- Switch from GLUT and plain OpenGL to SDL/OpenSceneGraph and/or other more sophisticated (graphics) libraries [work in progress]
- Add loading support for other (larger) star catalogues
- Display different celestial coordinate system grid lines
- Support displaying of deep sky objects like galaxies, nebulae etc. (see Stellarium)
- A model for atmospheric light scattering in ground observer mode, including realistic parameters for the atmospheres of Earth, Mars and other objects (see Stellarium)
- Display a panorama background image in ground observer mode that represents the surrounding landscape (see Stellarium)
- Make Gottorfium run on other operating systems, especially Mac OS 10.x and Windows 2000/XP/Vista
- Realize a "Plug-In" system that allows users to add modules to the program "on the fly", without having to recompile it
- Implement the possibility to map a (unlimited?) number of stacked semi-transparent texture layers on a planet (for things like clouds or political information)
- Add eye candy like lensflares and planetary atmospheres as seen from space (haze on the horizon)
- Add scripting language support (Python? Lua? other?) for implemetation of orbit classes / planet position functions, so that we don't have to hard-code these for each object that has a 'special' orbit.
Comparing Gottorfium with the programs that inspired us most
|Feature / Program||Gottorfium||Stellarium||Celestia|
|Ground-based mode||Yes, rudimentary||yes||yes|
|Overall user-friendliness||bad||ok, but could be better||ok, but could be better|
|Graphics - Visual quality and performance|
|High-res virtual planet textures||Yes, rudimentary||no||yes|
|Eye candy in ground mode||bad||great||ok|
|Eye candy in free-fly mode||average||bad, n/a||great|
|Accuracy of the celestial mechanics simulation|
|Orbit calculations||very good||very good||very good|
|Planet orientation/attitude calculations||very good||good||very good(?)|
|Provision of light travel speed||no||unknown||unknown|
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:
- 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.
- Fix the most annoying bugs and implement the most important basic features that are
- Get the PSO orientation code to work properly. [done]
- Lock the camera rotation with the planet's rotation in ground observer mode. [done]
- Implement new UI features and information layers which should be not too hard to code.
- 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.
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).
Get the source codeDownload the source code archive and uncompress it into a folder of your choice: gottorfium-source_2008-06-30.tar.gz
Compile the programMove 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 ;).
Get the data filesDownload the data files archive and copy its content to Gottorfium-SVN/Debug/data: gottorfium-data_2008-06-30.tar.gz
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 programCurrently, Gottorfium has only a preliminary user interface. You can
- rotate the camera
- move the camera around (in free-fly mode),
- place yourself at some predefined location,
- toggle a number of drawing options and
- set the simulation speed (how fast or slow time passes).
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:
- Keyboard keys
- The right-click popup menu
- Mouse dragging
The following table contains the most important user commands and how to envoke them:
|<w> or mouse drag forwards||Rotate the camera up|
|<s> or mouse drag backwards||Rotate the camera down|
|<a> or mouse drag left||Rotate the camera left|
|<d> or mouse drag right||Rotate 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 backwards||Increase FOV angle (zoom out)|
|<x> or mouse wheel forwards||Decrease 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 button||Open 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: