Torsten Rahn on KDE Blogs

Announcement: Marble ships the oldest existent historic Globe

Torsten Rahn — Fri, 23 Oct 2015 00:00:00 +0000

Today I have the pleasure to announce that Marble is the first popular virtual globe that ships and visualizes the Behaim Globe. The Behaim Globe is the oldest surviving terrestrial globe on earth. It was created between 1492 and 1493 - yes at the same time when Christopher Columbus made his first voyage towards the west and "discovered" America. This fact makes the Behaim Globe very special and also subject to scientific research: It documents European cartography during that era and it's probably the only historic globe which completely lacks the American continent.

These days the Behaim globe can be visited in the Germanisches Nationalmuseum in Nuremberg, Germany. The Germanisches Nationalmuseum (GNM) has kindly granted the Marble project permission to release the photo scan material of the Behaim Globe under the CC BY-SA 3.0 license and they have supported us in bringing it for the first time to the users of a widely deployed virtual globe: Marble. Right now our users can immediately download the Behaim Globe from inside Marble by entering File->Download Maps (or download it via our maps download website.).

Starting with the next Marble release scheduled for December 2015 the Behaim Globe map theme will become a regular part of the map themes that are shipped with the Marble installation package by default.

In addition the Marble project released a special Behaim Marble version in the Google Play Store. So users of Android devices – like smartphones and tablets – can enjoy the Behaim Globe, too! This also marks the first public release of a Marble based application on Android devices.

The Behaim map theme for Marble was created as part of the master thesis (Diplomarbeit) 3D Modelling of the Behaim Globe using Marble by Halimatou Poussami. The map theme allows to pan and zoom the whole Behaim Globe - curiously the whole globe is almost fully covered with detailed inscriptions in early modern German. Via checkboxes in the legend tab inside Marble our users can also overlay today's accurate coastlines. This allows to compare the Behaim cartography with today's known actual coastlines. Quite obviously the Behaim map depicts the continents stretched in longitude. So the creators of the Behaim Globe have probably based their globe on an earth radius value that was too small.

The photographic material of the Behaim Globe is based on digital scans made by the Friedrich Alexander University (FAU) in Erlangen-Nuremberg and the IPF TU Wien. These scans were performed using polarized light. This is also part of the reason for the vibrant colors that you can see in the map theme - visually the colors of the Behaim globe are much more subdued. During the past centuries the Behaim Globe has been subject to several "restoration attempts" and "editing", which also resulted e.g. in text changes. Therefore today's scientific research also focuses on the Behaim globe as a palimpsest. Using Marble's legend tab our users can compare the photomaterial of the Behaim Globe with facsimile drawings from 1853 and 1908 which also reveals differences.

The Marble Team would like to thank the Germanisches Nationalmuseum for its decision to release the Behaim imagery under the CC BY-SA 3.0 license. In particular we'd like to thank Dr. Thomas Eser (GNM), Prof. Dr. Günther Görz (FAU) and Halimatou Poussami for their active support in bringing the Behaim Globe to our Marble users and to the public!

GCI 2014 and Grand Prize Trip

Torsten Rahn — Sun, 21 Jun 2015 00:00:00 +0000

Many pre-university students have participated in Google Code-In (2014) again and for many of them it has been the first opportunity to make contributions to Free Software and Open Source projects. In opposite to Google Summer of Code the GCI program is organized as a worldwide contest where students at the age of 13-17 years take the challenge to complete as many software development tasks from their mentor organizations as possible. These software development tasks are provided by Open Source Projects that are approved as mentor organizations. And at the end of 2014 KDE has participated as a mentor organization for the fifth year.

The most recent edition of Google Code-In, GCI 2014 has again been very successful: As Heena Mahour described in her Google Code-in 2014 wrap up with KDE there have been more than 277 tasks created by KDE mentors for the students which covered all aspects of the software development cycle and which ranged from creating source code to documentation, research, quality assurance and user interface tasks. It was amazing to see how the students solved nearly all of them and helped to improve KDE applications significantly.

As in previous years the top 24 performers became Grand Prize Winners and won a trip to Google Headquarters in Mountain View, California! In the KDE community the Marble Virtual Globe developers are usually actively involved with GSOC and GCI mentorship. Two of our students - Mikhail Ivchenko and Ilya Kowalewski - have made extraordinary contributions to Marble: They had worked very hard and contributed several important features to Marble - see e.g. Mikhail's blog post about the Tour (don't miss to watch the video!) and Ilya's blog about the Measure Tool improvements. And since they also earned most points they became Grand Prize Winners.

This year I was the happy one who went to Mountain View as a KDE mentor between June 7-10. And the trip was a great opportunity to learn more about the other mentors and the winning students (they were accompanied by a parent each) and to share more about our Free Software work in the KDE project. The Grand Prize Winner trip was lovingly organized by Stephanie Taylor and other members of the Google Open Source Programs Office: It began with a meet-and-greet event on Sunday evening in San Francisco to get to know everyone. On Monday we visited Googleplex in Mountain View. And on Tuesday we had a fun day in San Francisco where we had the choice to visit the Exploratorium, Alcatraz or went on a Segway tour through San Francisco. Being a science guy I picked the Exploratorium. On Wednesday it was time to say goodbye already after enjoying another round of Googler talks, delicious food and swags at the Google San Francisco Office. The whole experience was just awesome and I'd like to thank Stephanie, Carol, Cat and all the other Googlers for organizing this event and for giving us the opportunity to join it.

Looking for Google Summer of Code students: OpenGL mode for Marble

Torsten Rahn — Thu, 05 Apr 2012 00:00:00 +0000

Google Summer of Code application deadline is just a bit more than 24 hours away and we are still looking for highly motivated students to work on a Marble Virtual Globe project this summer. Tomorrow is a holiday in many countries, so you might still have some time for the application. Make sure you file your application not later than tomorrow at 19:00 UTC.

The last project topic for GSoC that I'll cover is "OpenGL support for Marble":

You might ask: Why OpenGL? Doesn't Marble make use of OpenGL already? No it doesn't. Marble currently uses it's own software rendering to provide the different projections. Both texture and vector data are fully rendered in software by default.

This works reasonably fast on most devices, but compromises must be made with respect to the map quality. OpenGL, however, offers higher-quality results, is more state-of-the-art and perhaps helps to reduce power consumption on mobile devices. It therefore makes sense to introduce an OpenGL mode in addition to the sotware rendering mode in Marble (the user should be able to choose between software rendering or OpenGL).

The main task is to refactor the Marble codebase such that both the software rendering and the future OpenGL code share as much code as possible. In particular, visibility control (which objects should be rendered according to the current view parameters) should be factored out into separate classes, such that they can be reused in the OpenGL mode.

Initially the primary focus will be about replicating the current feature set and behavior of Marble. So the globe would still be browsed in looking top-down. Later on one could extend Marble and introduce bird-view, camera flights and "real" mountains and "real" 3D buildings.

Bernhard Beschow created an initial prototype of the OpenGL mode in an experimental branch already. You can look up more details about this prototype in his blog. Here is the video and a screenshot:

Marble - OpenGL Prototype

Since then Bernhard has partially prepared the current Marble master branch for inclusion of OpenGL. But there are still lots of missing bits and pieces in order to have the actual introduction of OpenGL inside Marble.

Expected Results for this project:

duty: refactored code that separates rendering from visibility management
"icing": an OpenGL mode

If you are interested in this wonderful project then you should act quickly: Deadline for applications is on Friday, April 6th, 2012m 19:00 UTC. Apart from the usual GSoC student application guidelines your application should:

describe the benefit of the feature from a user's perspective (including self-created mock-ups and screenshots)
provide a rough technical explanation in your own words what the project will be about.
state why you are the best person to master this project.

So if you are a student then we are looking forward to your application! Don't hesitate to ask us any questions.

Looking for Google Summer of Code students: Natural Earth Vector Map

Torsten Rahn — Tue, 03 Apr 2012 00:00:00 +0000

Google Summer of Code application deadline is near and we are still looking for highly motivated students to work on a Marble Virtual Globe project this summer.

This is a follow-up of yesterday's blog about OpenStreetMap vector rendering with tiling support.

Today I'd like to describe another important feature that we'd like to see covered as a GSoC project. In terms of technology this project is very similar to the "OpenStreetMap vector rendering with tiling support" topic. In fact if you applied for that project already then you might want to apply for this one as well if you want to increase your chances:

The topographic "Atlas" map is the oldest map theme featured by our Marble Virtual Globe. The original aim behind the Atlas map was to create a quite detailed map from very little data. The data would get shipped together with the Marble application for offline usage.

The result was a combination of a small set of vector data (for coastlines and country borders) and grayscale JPGs (for the color-coded elevation model and for the hillshading).

The small set of vector data is still based on the ancient Pospeschil Micro World Data Bank II ("MWDB II") dataset which was originally created in the 70ies/80ies and received its last update 20 years ago.

The GSoC project "Natural Earth Vector Map" is about creating a next generation "Atlas" map: It would be based on the Natural Earth Data project.

In opposite to the current approach the whole map would be based on vectors. The Natural Earth Data website provides all kinds of feature data for this use case.

The basic data is available in ESRI Shapefile format. Just recently Thibaut Gridel added initial support in Marble for Shapefile rendering (using libshp).

The aim of this project would be to provide a new Atlas map based on the Natural Earth vector data that is

very space efficient (so the shapefile format might not be the ultimate solution).
has a basic version of the data provided together with the application (similar to the current Atlas map)
allows loading of further vector data on demand online with no user interaction (read the OSM vector blog and think vector tiles).
and shows all kinds of topographic features in a map that is nice to look at.

The good news about this project: John Layt has created a master plan that describes all the challenges of this project in detail.

If you are interested in this project then you should act quickly: Deadline for applications is on Friday, April 6th, 2012. Apart from the usual GSoC student application guidelines your application should:

describe the benefit of the project from a user's perspective (including self-created mock-ups and screenshots)
provide a rough technical explanation in your own words what the project will be about.
state why you are the best person to master this project.

So if you are a student then we are looking forward to your application! Don't hesitate to ask us any questions.

Looking for Google Summer of Code students: OpenStreetMap vector rendering with tiling support

Torsten Rahn — Mon, 02 Apr 2012 00:00:00 +0000

Google Summer of Code application deadline is near and we are still looking for highly motivated students to work on a Marble Virtual Globe project this summer.

One of our favorite topics is "OpenStreetMap vector rendering with tiling support". And in this blog I'd like to describe our current ideas about this interesting subject a bit more in detail:

Basically all the maps displayed by Marble are based on bitmap texture data. Some of these maps even consist of multiple texture layers. On top of these texture layers we display further content like placemarks and possibly even simple geometries (like GPX or KML data).

For displaying this bitmap texture data efficiently we are making use of the popular concept of QuadTiles: the data is arranged in different zoom levels.

A single tile for a certain zoom level is split into four tiles in the next zoom level and so on:

This also works quite well across projections and zoom levels like in the case of the globe:

However there is a single prominent case where it doesn't work as well as we would like it to do: For OpenStreetMap the size of the font in the pre-rendered tiles is very small. Scaling these tiles up and reprojecting them results in a somewhat fuzzy appearance of lines and labels. There is a Marble FAQ for this issue including a workaround for the case of the Mercator Projection.

Still we'd love to provide crisp and sharp rendering for all projections and zoom levels. And the only way to do this properly is life vector-rendering. Konstantin Oblaukhov did an awesome job during last year in his Google Summer of Code project 2011 which provided vector-rendering for single OSM files. It got integrated with Marble 1.3 and we suggest you to give it a try. Click the link for the video below or click the thumbnail for a side-by-side comparison between the bitmap and vector map:

Marble - OSM Vector Rendering Video

Currently OSM data must be downloaded and opened manually by the user. During this GSoC 2012 project a QuadTile scheme should be developed such that Marble can open and display the right part of the map without any further user interaction (other than panning/zooming). This will require creation of special pre-filtered OSM files and extension of Marble's parsing and download capabilities.

We suggest the following rough mile-stones in order to come up with a working prototype:

Develop a tiling scheme that maps lon/lat/zoom tuples to filenames and vice versa
Use a tool like osmosis to create tiles for a sample region (say, the city you live in)
Extend Marble's .dgml format to be able to specify .osm files as input (and your tiling scheme)
Improve the current vector rendering to handle different zoom levels better
Add more OSM elements for vector rendering in Marble, improve existing ones (e.g. street names)
(Optional) Work on a .pbf parser for Marble to read .pbf instead of .osm files (much faster)
(Optional) Look into a new file format tailored for OSM vector rendering for Marble. Research existing formats like mapsforge
(Optional) Create a tool that automates the process of creating the tiles needed by Marble

If you are interested in this interesting project then you should act quickly: Deadline for applications is on Friday, April 6th, 2012. Apart from the usual GSoC student application guidelines your application should:

describe the benefit of the feature from a user's perspective (including self-created mock-ups and screenshots)
provide a rough technical explanation in your own words what the project will be about.
state why you are the best person to master this project.

So if you are a student then we are looking forward to your application! Don't hesitate to ask us any questions.

ESA Summer of Code in Space - Marble and KStars are looking for students

Torsten Rahn — Tue, 19 Jul 2011 00:00:00 +0000

The European Space Agency is organizing ESA Summer of Code in Space 2011. And Marble and KStars have just been accepted as mentor organizations! Thanks a lot ESA, this is terrific news!

The students application period starts today! And the schedule is tight: The deadline for applications is on July 27th, 11:00 AM (UTC) - that's about in a week!

So if you're a student and if you'd like to participate then please hurry up and

check the FAQ - especially the paragraph about eligibility
pick a project from the ideas page (or suggest your own project)
fill out and submit the application form for students.

If you have any question, you can refer to the documentation center or write to the public SOCIS mailing list.

If you have a question regarding Marble or KStars ideas just ask on our mailing lists (kstars-devel@kde.org and marble-devel@kde.org).

And remember: In space no one can hear you code.

Raise your voice for Marble!

Torsten Rahn — Thu, 07 Jul 2011 00:00:00 +0000

Have you considered contributing to the Marble (Virtual Globe) yet? The Voice of Marble contest is about to end in 8 days, so you could make use of your weekend by contributing:

Thousands of people use Marble on the Nokia N900 to find their way and explore the world. Become their voice!

Record your voice speaking a handful of turn instructions like "bear left!" and participate in the Voice of Marble contest. With a bit of luck, your voice will be chosen as the default speaker for voice guidance in Marble 1.2 (to be released in July 2011).

We're looking for an English speaker (male or female) whose voice will be shipped with the Marble packages.

And we're also looking for alternative speakers for all other languages - at least one each, and that's a lot!

Please participate in the contest and spread the word among your friends. The five best contributions will get a cool Marble T-shirt as a little present.

Interested? Please head over to the Voice of Marble wiki page which contains all the details you need to participate.

Interested in participating? Please follow these steps:

Choose one or more languages you want to record audio files in. Prepare translations of the commands for languages other than english. See Translations for details.

Record all 64 voice samples and store them as .ogg files. See Recording for details.

Upload your voice in time for the upload deadline (cf. timeline above). See Upload for details.

The deadline for submissions is Friday, July 15th 2011.

2011 - the future of Marble

Torsten Rahn — Wed, 12 Jan 2011 00:00:00 +0000

The new year 2011 has just started and it looks very, very promising for Marble: According to the Release Schedule "KDE Software Compilation (SC) 4.6" will get released with Marble 1.0 in about two weeks. This will be an exciting release which will introduce largely extended worldwide Routing support (Online and Offline), Bookmarks, QML bindings for libMarble, official support for the Nokia N900 / Maemo platform and too many other things to mention!
With our usual release cycle the next big milestone would be Marble 1.2 which will be released together with KDE SC 4.7 (Summer 2011). We have hopes that this might introduce the first steps towards an OpenGL mode for Marble and lots of other bigger framework changes.
For all Marble addicts we have even better news: Google Code-In has just been successfully completed and the students who focussed on Marble tasks did some marbleous, amazing work! Utku Aydın for example created some great new functionality for Marble:

An Earthquake plugin which visualizes earthquakes in realtime via geonames.org
A Social Contacts plugin which uses OpenDesktop.org to display your friends on the Marble globe.
And a Map Creation Wizard that allows you to create your own maps (e.g. using ready made images, a WMS Server or a Server Url) and prepares them for upload and contribution to the Marble map servers. Really cool stuff!

Read all about it in Utku's blog!

Then there's Daniel Marth who worked on the new

Overview map configuration dialog
GPS / Position marker plugin configuration dialog
And lots of other improvements that make Marble an even more polished jewel.

See Daniel Marth's wiki page for all the exciting details!
And then there have been lots of other changes by students like Cezar Mocan and Furkan Üzümcü. Thanks guys, you rock the Marble!
Now all of these changes are in a state which is basically ready for release. And even better: Most of the work is binary compatible. Even more important: Some of the features have a social aspect and allow users to easily participate in creation of maps and making Marble a better world to live in. So we want to bring these features to our users as quickly as possible!
That's why we plan for something special: We would like to release Marble 1.1 by the end of March! Marble 1.1 will be the first feature release that is entirely binary compatible with a prior major release! So combining the library of Marble 1.1 with KDE SC 4.6 will not be a problem. And Marble 1.1 will be the first feature release that doesn't come with a new major version of KDE. This will be a bit of a challenge but I think we can make it happen. The biggest challenge however will be getting translations and documentation prepared. We have created a marble-1.1 branch already and our aim is to keep strings between trunk and the marble-1.1 branch in sync. So our preliminary release schedule that we are aiming for looks like this:

December 26, 2010: Creation of a marble-1.1 branch (has happened already)
January 26, 2011: Release of KDE SC 4.6 with Marble 1.0.
February 15, 2011: Soft message / feature freeze.
February 28, 2011: Hard message / feature freeze
March 1st, 2011: Marble 1.1 Beta 1.
March 15, 2011: Marble 1.1 RC1.
March 31, 2011: Marble 1.1 release for all platforms: Linux, Windows, Mac OS X, Maemo / Nokia N900
Summer 2011: Release of KDE SC 4.7 with Marble 1.2.

Again this development only affects the marble-1.1 branch. In parallel we'll work on Marble 1.2 which is scheduled to be released together with KDE SC 4.7 in Summer 2011. And again the biggest challenge will be to get Marble 1.1 translated!

Lots of helping hands were involved to develop the current version. Would you like to get involved? Please do!.

Today: Marble Weekend Sprint in Nuremberg

Torsten Rahn — Fri, 05 Nov 2010 00:00:00 +0000

The Marble Sprint Weekend is about to start at the basysKom Office in Nuremberg. If you're around and if you're curious about development of the Marble Virtual Globe then don't hesitate to join us. This is your best chance to get involved! We'll have lots of interesting topics about Marble presented on Saturday. See our Marble Sprint Wiki for more information. Thanks go to the KDE e.V. and basysKom for sponsoring this event.

In other news Peregrine got released today! See the basysKom announcement. Peregrine is a crossplatform real-time communication client that integrates all daily needed communication services for VoIP, Video and Chat in one solution. I'll cover this release and project more extensively in a different blog entry.

Marble C++ Tutorial Part 2

Torsten Rahn — Sat, 14 Aug 2010 00:00:00 +0000

Marble 0.10.0 has been released as a major update last week together with KDE SC 4.5. As a user you might be interested in our Visual ChangeLog which is also available in spanish over at muylinux.com.
But Marble is also a library. So it can be used as a widget in other applications. Today I'd like to show you how.
In our previous tutorial I already introduced you to the very first steps of Qt Programming and Marble Programming. Now the last few Summer days in Germany have been rather rainy. So in the second part of our tutorial I'd like to show you how to create a weather map!
Creating a weather map

We'd like to display a small weather map. So we need to modify the map defaults of MarbleWidget. And we need to turn on the satellite view, enable the clouds and enable the country border lines.
Again MarbleWidget provides a convenient way to make these changes to the overall look and feel of the map.
By default Marble shows a few info boxes: Overview Map, Compass and ScaleBar. But the size for the widget is very limited. Therefore we want to shrink the compass. And we want to get rid of all the clutter, so we turn off the Overview Map and the ScaleBar. In the source code the class AbstractFloatItem is used to display all kinds of Info Boxes. All the Info Boxes are derived from the AbstractFloatItem class. Now we get a list of all the float items that are known to MarbleWidget and we go through it. Once we reach the float item which has got the name id compass we make all the changes we want to it (this has been simplified in Marble pre-0.11.0 where you will be able to access AbstractFloatItems directly via their nameId):
#include
#include <marble/global.h> #include <marble/MarbleWidget.h> #include <marble/AbstractFloatItem.h>
using namespace Marble; int main(int argc, char** argv) { QApplication app(argc,argv); // Create a Marble QWidget without a parent MarbleWidget *mapWidget = new MarbleWidget(); // Load the Satellite View map mapWidget->setMapThemeId("earth/bluemarble/bluemarble.dgml"); mapWidget->setProjection( Mercator ); // Enable the cloud cover and enable the country borders mapWidget->setShowClouds( true ); mapWidget->setShowBorders( true ); // Hide the FloatItems: Compass and StatusBar mapWidget->setShowOverviewMap(false); mapWidget->setShowScaleBar(false); foreach ( AbstractFloatItem * floatItem, mapWidget->floatItems() ) if ( floatItem && floatItem->nameId() == "compass" ) { // Put the compass onto the left hand side floatItem->setPosition( QPoint( 10, 10 ) ); // Make the content size of the compass smaller floatItem->setContentSize( QSize( 50, 50 ) ); } mapWidget->resize( 400, 300 ); mapWidget->show(); return app.exec();
}

Save the code above as marble_weather.cpp and compile it:
g++ -I /usr/include/qt4/ -o marble_weather marble_weather.cpp -lmarblewidget -lQtGui

Instead of calling the compiler directly you can also create a qmake project file:
TEMPLATE = app TARGET = marble_weather DEPENDPATH += . INCLUDEPATH += . SOURCES += marble_weather.cpp LIBS += -lmarblewidget

Store it as marble_weather.pro in the same directory and call
qmake marble_weather.pro make

If things go fine, execute ./marble_weather and you end up with a map application that displays clouds on top of a flat map:

That's all for today. In our third chapter we'll show how to load KML and GPX files into Marble. So stay tuned. If you need help join us on our mailing list marble-devel@kde.org or on #marble (IRC on Freenode). If you want to obtain the latest Marble source code have a look at Marble's website.
If you are interested in more news about Marble then join us and feel welcome in our Marble Facebook Group!

Visual Changelog: Marble 0.10.0

Torsten Rahn — Wed, 11 Aug 2010 00:00:00 +0000

Marble 0.10 was released on August 10th, 2010. It is part of the KDE 4.5 Software Compilation. In the good tradition of recent years, we have collected those changes directly visible to the user. Unfortunately we were a bit late with our visual changelog for the release. So please enjoy looking over the new and noteworthy:

Online Routing
Do you want to plan a bicycle tour in the nearby wood? Need driving instructions to get to an address in a foreign city? Besides searching for places, Marble can now display possible routes between two or more of them.

And the best thing is: The routes are draggable!

Online Routing in Marble

Places to travel along can be entered using search terms (e.g. addresses) in the new Routing tab on the left. Of course Marble also allows you to input them directly on the map. Routes are retrieved using OpenRouteService and displayed on the map. Turn-by-turn instructions are displayed on the left.

You can customize the route using preferences like transport type (car, bicycle, foot). An arbitrary number of via points can be added easily: Use either search terms or create stopovers quickly and conveniently by dragging them out of the existing route and dropping them at the desired position. While a real-time navigation mode is scheduled for Marble 0.11, you can already export the route in the GPX format now. This feature is handy for using routes in conjunction with your navigation device or other software.

Bulk Download for Tile data in Marble for Offline Usage
For normal usage, Marble downloads the map data that is needed on the fly in the background. It also saves the data that has been downloaded on the hard disc. Now imagine that you make a trip to Norway, and you don't know for sure whether you'll have internet during the trip. So you want to download the whole Oslo area in advance. Up to now this hasn't been possible. But with Marble 0.10.0 you can click "File->Download Region ..." and you get a dialog where you can specify the region and the zoom levels that you want to download. This feature was brought to you by Jens-Michael Hoffmann.

Download of the Visible Region

Support for Multiple Layers in Marble
So far, Marble has had support only for displaying a single map texture on top of the globe. (The only exception was the cloud feature which allowed having clouds displayed on top of the satellite map. This, however, was hard-coded and not extensible.)
For this release, Jens-Michal Hoffmann has worked on Multiple Layer support. This means that maps can now be created which display multiple texture layers. For instance: a cloud layer on top of a street texture layer on top of a satellite texture layer. This is all done in a generic way. So people who create maps for Marble can create an arbitrary amount of layers blended on top of each other. The best thing is: Due to the way the feature was implemented the performance doesn't change! And the clouds feature has been reworked to make use of the new mechanism.

Support for Gimp-like Filters Between Layers in Marble

The City of Dresden shown in Marble with multiple layers: Satellite images provided via WMS displayed on top of OpenStreetMap data via Multiply Blending.

As described before, Marble has support for multiple layers now. Layers can get blended on top of each other using Gimp-style "filters": You can choose among more than 30 blending algorithms, such as: Overlay, ColorBurn, Darken, Divide,Multiply, HardLight, ColorDodge, Lighten, Screen, SoftLight and VividLight. If you've ever use an application like Photoshop (TM), Krita or Gimp then you probably know what this means.

Quick and Dirty WMS Support and More Url Download Schemes.
Lots of map data is provided on the internet on servers via the Web Map Service ("WMS") protocol. Bernhard Beschow has added initial quick and dirty WMS support to Marble. This means that there are now a huge number of maps that can be easily displayed using Marble.

Marble Goes Mobile: Support for Nokia's N900 and UI profiles
With KDE 4.5, we have completed the first step toward mobile platform support: Marble will show a slightly different and simplified UI on the N900 Maemo platform compared to the desktop. For KDE 4.6 we aim for an even better user experience and improved performance.

Marble on a Nokia N900

Marble Routing on Maemo5

For more information please visit the Marble Garage Project. Next stop will be the MeeGo version for Marble.

Display APRS (Automatic Packet Reporting System) Senders with Marble
This is one of our first more specialized Online Service Plugins: The APRS plugin created by Wes Hardaker shows worldwide Ham-Radio stations.
HAM Radio's APRS program allows radio transmitters to send their position and other information and is frequently used in disaster relief efforts for coordinating team distribution.

APRS senders displayed in Marble

We are still looking for programmers who would like to create more Online-Plugins: e.g. Twitter, News, Earthquakes or a social network plugin. It's easy to do and there's an Online Service Plugin tutorial available on our website that shows how to do it.

Performance Improvements and More Changes Under the Hood ...
In addition to these major improvements, our Marble developers have worked on several other small features, bug fixes and performance improvements:

Two additional search backends: Hostip (try "planetkde.org") and OSM Nominatim (try "ATM, Karlsruhe") (Dennis Nienhüser)

Improved animation support for zoom and panning (Dennis Nienhüser)

A look at Geothek 1.1 Digital World Atlas

Torsten Rahn — Sat, 07 Aug 2010 00:00:00 +0000

Last weekend I received a postal package that contained a classroom atlas from Austria: the Neuer Kozenn Atlas. Inside there was a nice shiny CD with the title GEOTHEK Schulatlas, Version 1.1 Digitaler Weltatlas. The publisher of this atlas and its software is Ed. Hölzel.

The Kozenn Atlas (named after the slovenian born teacher Blasius Kozenn) has been produced in Vienna since 1861. It has been updated continously by the Geographical Institute Ed. Hölzel. And it has been published in a lot of other countries as a world atlas (France, Netherlands, Belgium, etc.). Up to these days it's the most famous austrian school atlas.
Geothek is a software published by Ed. Hölzel that had been developed by Helmut Mülner from the renowned Joanneum Research. I was curious since this was supposed to be the first version based on the Free Software Marble.
So I booted up the Windows 7 partition of my Thinkpad and put the CD into my external DVD drive. The setup application started automatically and I had to approve the License:

Afterwards the Nullsoft Installer quickly installed the files into the directory that I had chosen. A help text showed up and a new entry Geothek Schulatlas appeared in the Start Menu. A click on Atlas started the Geothek. It turned out that this version of Geothek is a nicely enhanced version of the Qt version of Marble: The application is fully translated into German. Also the location database is replaced by data from Ed. Hölzel.

Entering a location in the Search query field centers the globe onto the selected place as usual. However a second tab in addition to the globe view had also been added which contains a 2D-Viewer for the physical maps of the Kozenn atlas (see screenshot above). This 2D viewer would automatically choose the correct physical map and center and zoom it according to the search query. Symbols are added on top of the the physical map which the user can click on and which interactively provide hundreds or thousands of encyclopedic articles, climate diagrams and beautiful photo material for lots of popular places.

The "Map Theme" tab contains additional maps featuring topics like "Population Density", "Climate Zones" and "World Trade". And for each of these a specific legend had been created. Of course all those maps can be panned and zoomed as always in Marble. Very nice quality work!

At the bottom left there is a "Statistics" page. Clicking onto it makes a big table appear: The table lists all countries of the world. The columns cover all kinds of topics, like area, population, life expectancy and lots of other interesting facts. After selecting one of the columns the second tab displays a map that nicely color-codes this information. There are more configuration options for this map and it's pretty evident that the application developer had a lot of fun in developing this particular feature.

Another interesting addition is the 3D Satellite View. Marble itself which serves as a base doesn't provide a true OpenGL view with flights over mountain landscape sceneries. Adding something like this is on our roadmap. But it will still take some time to add it properly.
So the Geothek developer added a special separate OpenGL based canvas which would allow to fly over a given area. The view features satellite imagery on a "flat" map and it's possible to tilt and rotate the view in all directions. Also the elevation of the landscape can be exaggerated:
As a bonus access to a set of "silent maps" is provided for teachers via the application menu.
All in all this application is a great showcase how Marble can be turned into a customized and polished quality product that is fun to use! The current version of Geothek is based on Marble 0.7/0.8, which is more than a year old. Since then Marble has developed a lot furter, adding stuff like Routing, WMS support, multiple layers, better OpenStreetMap integration and a lot of details that make life of application developers easier. So I think that Marble nowadays should be an even more attractive solution for publishers of schoolatlases and encyclopedias: They could just rip out the original Marble content (if necessary) and replace it with their own high quality data. That would cost a lot less than building up a full custom solution on their own. In the Marble project we'd really like to support such kinds of projects. And since the Marble development pace seems to increase I wonder what the next two years will bring.
I'd like to congratulate and thank Helmut Mülner and Lukas Birsak for this amazing product they have created. I was also very impressed by the way they credited the Marble team's work. Even better: The Geothek was published as an LGPL project on sourceforge. Of course the Hölzel maps are not included in the source code but that was naturally to be expected. But we also liked how the Geothek developer contributed his bug fixes back to the Marble Project in the best possible way.

Marble C++ Tutorial Part 1

Torsten Rahn — Tue, 03 Aug 2010 00:00:00 +0000

In a few hours KDE 4.5 will be released. And together with it the new version of our Virtual Globe and Map Widget Marble. The new release Marble 0.10.0 will bring lots of additional features (Routing, Tile-Bulk-Download, Multiple Layers, initial WMS support and a lot more) - many of them related to OpenStreetMap.
Of course development on the next release has started already: Dennis Nienhüser and Niko Sams have added Worldwide and Offline Routing support to Marble using Gosmore and Routino.
In other news the spanish Linux Magazine has published a really nice article by Tim Schürmann about Marble the application: "¡MARBILLOSO! Marble se ha convertido en una alternativa interesante a Google Earth, y funciona sin conexión a Internet. Marble Facebook Group!

But Marble is more than an application: You can use the MarbleWidget and its framework in your own application to display map data! There are many applications which are doing this already. See our success story page for more information. And today we start to show how to do it. All you need for our Tutorial is a little bit of C++ and basic Qt knowledge:

Hello Marble!

The API of the Marble library allows for a very easy integration of a map widget into your application.
Let's prove that with a tiny Hello world-like example: Qt beginners might want to have a look at the Qt Widgets Tutorial to learn more about the details of the code. But this is probably not necessary. For a start we just create a QApplication object and a MarbleWidget object which serves as a window.

By default the MarbleWidget uses the ''Atlas'' map theme. However for our first example we choose to display streets. So we set the maptheme id to OpenStreetMap. Then we call QWidget::show() to show the map widget and we call QApplication::exec() to start the application's event loop. That's all!

#include <QtGui/QApplication> #include <marble/MarbleWidget.h>
using namespace Marble; int main(int argc, char** argv) { QApplication app(argc,argv); // Create a Marble QWidget without a parent MarbleWidget *mapWidget = new MarbleWidget(); // Load the OpenStreetMap map mapWidget->setMapThemeId("earth/openstreetmap/openstreetmap.dgml"); mapWidget->show(); return app.exec(); }
Copy and paste the code above into a text editor. Then save it as my_marble.cpp and compile it by entering the folling command on the command line:
g++ -I /usr/include/qt4/ -o my_marble my_marble.cpp -lmarblewidget -lQtGui
If things go fine, execute ./my_marble and you end up with a fully usable OpenStreetMap application:

That's all for today. In our next chapter we'll show how to create a basic weather map with Marble. We'll also show how to change basic properties of the map widget. So stay tuned. If you need help join us on our mailing list marble-devel@kde.org or on #marble (IRC on Freenode).
Tip

Here's a little checklist to tackle some problems that might arise when compiling the code above:

You need Qt and Marble development packages (or comparable SVN installations)
If ''Qt headers'' are not installed in /usr/include/qt4 on your system, change the path in the g++ call above accordingly.
Likewise, add -I /path/to/marble/headers if they're not to be found in /usr/include

Note

If you provide maps in your application please check the Terms of Use of the map material. The map material that is shipped with Marble is licensed in the spirit of Free Software. This usually means at least that the authors should be credited and that the license is mentioned.
E.g. for OpenStreetMap the license is CC-BY-SA. Other map data shipped with Marble is either public domain or licensed in the spirit of the BSD license.

Marble Virtual Globe and Google Summer Of Code 2010

Torsten Rahn — Sun, 04 Apr 2010 00:00:00 +0000

The student application deadline for Google Summer of Code 2010 is near: So if you plan to submit an application for a Marble project then it needs to arrive no later than April 9, 19:00 UTC.
I have just added a few more ideas to the idea page: OpenDesktop.org support and Panorama support. So now in total there are five Marble ideas listed on our idea page:

Time Support for Marble
More online plugins for Marble
Enhanced KML support for Marble
Marble To Go (Navigation Mode)
Panoramic Picture Support in Marble ("StreetView")
Of course this isn't the limit, so if you come up with another great idea don't hesitate to apply for it.
In other news we've just created a Marble Facebook Group for all users of Marble and Facebook.
Join us! Join the Marble Community!

Gran Canaria Desktop Summit - Slides and Video about the Virtual Globe "Marble"

Torsten Rahn — Wed, 12 Aug 2009 00:00:00 +0000

Just recently my blog got syndicated by Planet OSGeo. So I'd like to take the opportunity and say "Hello" to all readers and I'd like to thank for the warm welcome!

As a Marble and KDE developer I had been at the Gran Canaria Desktop Summit last month (and that made me miss the State Of The Map unfortunately). I enjoyed this conference a lot and I would like to thank especially the GCDS Team which did a terrific job and made this event a full success.

For all people who have missed my 30-min presentation about Marble: The slides of this presentation are now available. Additionally there is a Video on YouTube which has the first ten minutes. The full OGV-video can be downloaded here. The video is licensed under the Creative Commons Attribution-Share Alike License 3.0. Credits go to the GCDS team. Enjoy!

As an introduction to Marble I can also recommend this nice review over at Dedoimedo.

Marble - Get involved!

Torsten Rahn — Tue, 31 Mar 2009 00:00:00 +0000

We've recently extended our Marble Wiki to include more documentation about how you can participate in Marble development. Here are a few possible jobs for a start:

If you are an artist or interested in historical world maps you can help us to improve our "Historic Maps" library: Magnus Valle ("wiscados" on #kde-edu) has done some great work in this area (resulting in the Historic Map that comes with Marble 0.7). Find out here how you are able to take part in this.
For source code aficionados we have lots and lots of JuniorJobs for Marble. You can have a look at our How to become a Marble Developer page to find out how to tackle those.
If you're a student and you are still looking for a Google Summer of Code 2009 topic, then you can either look at the KDE ideas page or you look at Wikipedia's fine article about Virtual Globes. They got a nice comparison matrix there which even includes Marble. There are still a few red "No" marks there which might help you to get an idea for your Marble topic for the Google Summer of Code application (like e.g. Movie Maker, Guides, Planetarium, etc.). Just make sure that you don't work on "Imagery of other planets" as Marble already has got this feature since Marble 0.7 (the author of the article just hasn't updated the page yet and I myself don't want to edit such wikipedia pages due to my obvious bias ;-)
If you'd like to help us or have questions regarding Marble, just join us on IRC ( channel #kde-edu on irc.kde.org ) or write an e-mail to marble-devel@kde.org.

Marble's Secrets IV: Run Marble, Run!

Torsten Rahn — Thu, 20 Nov 2008 00:00:00 +0000

KDE 4.2 is in bug fixing mode and so is Marble. Time to have a look at things that got implemented right in time for Marble 0.7: Henry de Valence has been one of the most active Marble core developers during the last few months: He has implemented several exciting Marble features already.

For Marble 0.7 (KDE 4.2) he implemented MarbleRunners. This is a pretty nice feature, which is still a bit hidden, but that is probably going to change soon:

Make sure you have internet -- Oh, ok, yes, I just wanted to make sure ...
Start Marble (e.g. from KDE 4.2 Beta1 or trunk)
Find the "Search" field and type in: Playmobil
Wait for the results to arrive!

What happens is that on pressing the Enter key Marble will send the search query to several "service" threads in the background called "MarbleRunners". These threads will return the result as soon as it is available. In this case the OpenStreetMap-Runner has returned four matching results from the OpenStreetMap-Server!

Ok, let's try another one: Imagine, you are somewhere in Finland on holidays ("Tervetuloa!"), it snows and you feel really hungry. In this situation Marble can be a true life-saver ("Hyvää ruokahalua!"):

The source code for the OpenStreetMap-Runner is based on source code by Jens-Michael Hoffmann who also created the OpenStreetMap integration for Marble. Henry de Valence has taken it and created a Marble runner out of it. Additionally Henry has created a Coordinate-Runner:

Enter e.g. 46°14'00" N 06°03'00" E

or just:
46 14 00 N 06 03 00 E

and press the Enter key. The latter will almost immediately return a result from the GeoCoordinate-Runner and several results from the OpenStreetMap-Runner trailing in a few seconds afterwards:

The best thing is however that Henry has made a HOWTO for creating MarbleRunners. So now you can create your own MarbleRunner yourself! The example shows how easy it is! And the description ensures that you can do this even if you are a beginner.
Just go here to get the HOWTO and just look here to get instructions on how to compile Marble.
The best Runners that you'll come up with will get shipped with the next version of Marble (your chance to enter history)!
I could imagine lots of runners: What e.g. about a Wikipedia-Runner (we don't have that one yet, ...)? What ideas do you have? Please let us know or even better: send us your patch! We are reachable via marble-devel@kde.org. Or join us on IRC ( #kde-edu, Freenode: irc.kde.org )! Of course we also appreciate all kinds of patches that improve the current MarbleRunners as well!

Marble integration with KOffice

Torsten Rahn — Sat, 24 May 2008 00:00:00 +0000

Shortly after the Marble OpenStreetMap integration I'm happy to report that Simon Schmeisser has managed to integrate Marble as a Flake Shape into KPresenter. As a flake shape you can change the map according to your liking even after it has been embedded into the KOffice application. So it's not just a simple image but rather a component that allows the user to adjust the content:

Which other Free Software office application has a virtual globe that it can embedd into the documents across plattforms?
So that adds another successful application of KDE technology to Marble's capabilities: It's only a few weeks ago that our weather man Henry de Valence has started to work on a Marble WorldClock plasmoid:

Of course apart from a Marble Qt Designer Plugin and the Marble KPart (which gets used by the Marble Desktop application itself) you can use the MarbleWidget in your very own application -- like Gilles Caullier has done for Digikam:

The Marble Widget has no KDE ties, so even if your application uses only Qt you can still take advantage of Marble. So what's the next showcase that people will come up with? A Marble Netscape Plugin? I'm curious.
In other news Shashank Singh has just joined us for GSoC 2008 and will provide Panoramio support for Marble. Welcome Shashank!
Right now the Marble Team is heavily working towards KDE 4.1 Beta2: Jens-Michael is working on further improving Marble OpenStreetMap support, Inge is working on the Mercator Projection, Patrick is working on further improving KML for his GSoC 2008 project (which actually deals with vector rendering in Marble), Claudiu is working on his Satellite Plugin and Henry is working on texture colorization and Temperature / Precipitation maps. I'll continue to work on GeoPainter and Marble's new plugin architecture which will enable other developers to write Qt-Plugins for Marble to render their own layers and their own data.
These are exciting times for Marble. Can you feel the Earth spinning?

KDE 4.1 Beta1: OpenStreetMap Support in KDE via Marble

Torsten Rahn — Wed, 21 May 2008 00:00:00 +0000

The hero of the current Marble KDE 4.1 Beta1 release is Jens-Michael Hoffmann: He has successfully worked on getting OpenStreetMap integrated into Marble and KDE 4.1!
This means that once you start our free software virtual globe and select "OpenStreetMap" as a theme then Marble will directly start to download OpenStreetMap tiles from the OpenStreetMap server:

If you want to try it you can either wait for KDE 4.1 Beta1 packages to appear on the KDE Website next week. Or you start to compile current Marble SVN yourself. It's pretty easy: You only need just Qt 4.3 (or 4.4), or alternatively KDE >= 4.0 and Qt >= 4.3 including headers.
Then you can start to build Marble according to our HOWTO.
Once you have compiled Marble from current SVN you can start it either from the menu or from the commandline. You'll be greeted by our globe. If everything went well, you'll see that Marble now features a starry sky plugin (notice the constellation "Orion" right next to the earth in the following screenshot):

If you have compiled the KDE version then you can adjust the quality settings for "Still image" and "During animations". We'd suggest that you use "High" for "Still image" and "Low" for "During animations" however you can adjust the values according to the performance of your hardware.

Now select the "Map View" tab on the left and choose "OpenStreetMap". The screen should look about like this:

Once you start to zoom in Marble will start fetching tiles from the OpenStreetMap server and will texturemap them onto the globe:

Zoom in more and Marble will show streets and buildings. Please notice that we've also added a fitting OSM legend to Marble (on the left in the screenshot) so you are able to identify the items on the map correctly:

In the upcoming weeks Jens-Michael plans to refine OSM support by fixing bugs and letting tiles expire (so you'll always stay up-to-date with the current OSM mapping progress).
On 12-13 July Jens-Michael and me plan to attend the OSM conference State of the Map where I'll be present as a speaker.
If you are interested in learning more about Marble please have a look at our series "Marble's Secrets":

Part I
Part II
Part III
If you want to help us with creating free roadmaps please consider to join the OpenStreetMap project!
Oh and if you wonder about the blockiness due to the texture mapping: We are going to fix that for KDE 4.2. Patrick Spendrin is going to work on a Google Summer of Code 2008 project for Marble that will likely deliver life vector rendering of the OSM data in Marble.

Google Summer of Code 2008 - Marble Projects

Torsten Rahn — Wed, 26 Mar 2008 00:00:00 +0000

If you're a student and if you're still searching for a suitable GSoC 2008 idea then Marble might offer a chance to participate in a young, vivid and interesting project. We suggest that you have a look at the Google Summer of Code Ideas page. There are especially three ideas which seem to be exciting and very important:

Vector Tiles: We'd like to see a similar concept implemented for all geographical features as the one we are using for Textures: Usage of tiles. Especially for vectors this would be interesting as we could live render e.g. Open Street Map or VMap 0 data.
Panoramio/Wikipedia photo support: This would enable Marble to show thumbnails from georeferenced photos such as those from Panoramio, Wikipedia (or whatever image source is suggested by the applicant). Technically this work would extend Marble's KML support (which is currently being ported to a new QXmlStreamReader based framework).
OSM Annotations: This project was suggested by Adriaan de Groot and Armijn Hemel and is meant to provide on-screen OSM Annotation support. Of course providing OpenStreetMap support is an important goal for Marble and the suggestions for this idea seem pretty reasonable and realistic for the given timeframe (and dealing with UMPC devices seems to promise lots of fun).
Of course we appreciate any other ideas for Marble development as well. Creative ideas get extra bonus points. If you want to find out what Marble Development is about then I recommend that you check out my "Marble's Secrets" blog entries:

Part I was a Do-It-Yourself course about creating maps for Marble. We've seen how Marble manages to even display features such as aerial photos or OpenStreetMap.
Part II showed how Marble paints the different map layers. We've also seen why Marble only needs very little disk space and memory for its default map - making it an ideal choice for solutions that involve little hardware resources (like the Asus EeePC and the OLPC).
Part III looks beyond Marble's offline mode: It describes how Marble fetches its data from the internet.

But hurry up: Deadline for GSoC 2008 student applications is on Monday!
For help or questions you can join us on IRC ( irc.kde.org, #kde-edu ) or send a mail to our mailing list.