Skip navigation.
KDE Developer's Journals

torsten rahn's blog

torsten rahn's picture

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

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.

torsten rahn's picture

Marble - Get involved!

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 Eye-wink

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.

torsten rahn's picture

Marble's Secrets IV: Run Marble, Run!

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:

  1. Make sure you have internet -- Oh, ok, yes, I just wanted to make sure ...
  2. Start Marble (e.g. from KDE 4.2 Beta1 or trunk)
  3. Find the "Search" field and type in: Playmobil
  4. 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!

torsten rahn's picture

Marble integration with KOffice

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?

torsten rahn's picture

KDE 4.1 Beta1: OpenStreetMap Support in KDE via Marble

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":

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.

torsten rahn's picture

Google Summer of Code 2008 - Marble Projects

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.

torsten rahn's picture

Marble on WinCE

I hope that everybody who celebrated Easter has enjoyed some pleasant days (well and of course everybody else, too ... Eye-wink. Recently I've received a few e-mails from Thomas Hartmann who works in Trolltech's Qt/WinCE team. Thomas has started to port Marble to Windows CE after I had told him about Marble during the KDE 4 satellite launch event in Berlin.

After having seen a few screenshots of Marble running on Qtopia this is the fifth plattform apart from Marble on Windows, Mac OS X and Linux/Solaris/Unix. The high portability of Marble is due to the fact that Marble doesn't have any dependencies apart from Qt 4 itself (and it doesn't use OpenGL). So you don't even need to have KDE 4 installed to run Marble. However for users the KDE frontend is very much recommended as it has a few extra features that the Qt4-only frontend doesn't offer: like e.g. GetHotNewStuff support.

The fact that Qt offers the same API across plattforms (unlike other toolkits) has certainly helped a lot to make the Windows CE port possible. Of course Thomas had to strip down Marble due to the 32 MB memory limit, so the initial vector data isn't as detailed as for the desktop version (we hope that we'll find a GSoC 2008 student who will volunteer to implement vector tiles for Marble):



Thomas also created two youtube videos which show Marble on a Dell Axim X51v. The result is pretty impressive given that this PDA is using an XScale/ARM processor (which doesn't provide hardware support for floating point instructions):







torsten rahn's picture

Marbl10n

This Wednesday Marble got fully translated to Czech (thanks to Vít
Pelčák) - including some fixes to the localized city names in the Czech Republic (thanks to Karel Volný). Recently I've looked closer at the KDE Localization Statistics which seem to have improved a lot during the last few months. What has become more and more apparent to me is the fact that Marble might soon be the virtual globe that has the best and most translated GUI on this marbleous planet. Ok, this shouldn't exactly be the primary concern of a tool like this (Yes, I hear you asking for more and better maps instead and we are working on that as well).




Caption: Marble's UI translated to Chinese (Credits for the Screenshot: John Smith).

But it's still interesting: Taking a peek into Google Earth's ~/google-earth/lang directory I can spot 14 files in the familiar .qm format. So I guess that Google Earth's user interface is available in 14 languages. With NASA's WorldWind it's a bit harder to say. But from what I was told there is no real translation framework available for the current stable version (However this is about to change with WWJ), so translations either need to get patched in or need a special plugin. As a result there are up to my knowledge no other languages officially supported apart from english (although the NASA WorldWind Wiki lists some translations).

Looking at our Localisation statistics I can see that Marble is close to 100% fully translated in Arabic, Catalan, Chinese (Simple & Traditional), Czech, Danish, Dutch, Estonian, French, German, Greek, Hebrew, Hindi, Italian, Japanese, Latvian, Low Saxon, Norwegian (Bokmål and Nynorsk), Polish, Portuguese, Punjabi, Romanian, Slovenian, Spanish, Swedish and Ukrainian. So according to The Count the stable version of Marble has GUI translation support for up to 26 27 languages ("Haha haha ha ...!"). With KDE 4.0.2 being near most notably absent are Krakhozian, Danish (thanks to Martin Schlander!), Farsi, Korean, Russian (thanks Nick! Eye-wink ), Turkish, and lots of other beautiful languages.




Caption: Marble's UI translated to Slovenian (Credits: Jure Repinc).

I understand that translation is a much more difficult task than most people might think -- especially for an application like Marble: There are lots of technical terms which don't get recognized as such easily -- even by translators:
For example the label of the "Relief" checkbox in Marble's legend reads "Relief" in English. This (or "shading") is the correct technical term in English and it's easy to understand for the mainstream audience. In German however the "official" cartographic technical term for this feature would be Schummerung. In my opinion this correct technical term is a pretty unknown word in German which has a strange sound to it and I'm pretty convinced that most people wouldn't immediately understand what it's about.

As the brilliant physicist and teacher Richard P. Feynman had pointed out on several occasions there is a big difference between knowing something and knowing the name of something. Of course it's a lot more important that people get a deep understanding of the nature of things than knowing the correct name. Still it's necessary to be easily understood and hence it is important to stick to wording standards. However these standards might vary depending on the audience you are talking to.

"Relief" is easily understood in German and gets the point across immediately (and it's not even an anglicism). Therefore I consider it a much better choice given Marble's target audience.

Now counting the supported languages of the GUI might be a nice thing to do for arithmomanians. But the real deal is translating the map:

torsten rahn's picture

Marble's Secrets Part III: The Earth in a Download

Today we'll finish our first trilogy about Marble Desktop Globe:

  • 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).

In Part III we'll look beyond Marble's offline mode: We'll get to know how Marble fetches its data from the internet.




Caption: Left: Creating "KWorldClock 2" in 5 minutes using Marble's Qt Designer Widget Plugin. Note that this is just a proof that this would work today! - Actually Henry de Valence is working on a KWorldClock plasmoid already. Right: Marble showing off a real-time cloud map and Sun Shading with the "Earth At Night" map blended in.

By data we mostly refer to texture data. As of version 0.5.x (KDE 4.0) we only support a single texture layer. However this is about to change with the next version of Marble: David Roberts has added support for Sun Shading in Marble. If this wasn't exciting enough he also added a way to have the "Earth at Night" map blended onto the dark side of the earth. This includes a pretty nice Terminator line. On top of that he already added internal support for having real-time clouds as another layer! See the screenshot based on a current build of the Qt-version of Marble pre-0.6-SVN.

A really big mosaic of tiles ...

Actually I've met a lot of people recently who weren't aware of the fact that Marble downloads further texture data from the internet while browsing the map. On one hand the reason for this misconception is maybe the fact that we only provide very little additional online data right now (about 400 MB). On the other hand the map download is done automatically and very seamlessly in the background, so people will hardly notice. Andrew Manson created a nice YouTube video while he finished his GSoC Project "GPS support for Marble". During the first 1.5 minutes Andrew demonstrates what could be a summary of the "Marble Secrets Part II" hands-on paragraph: the video shows how you can hide and show layers using the legend tab. Watch closely at 1:35 where Andrew zooms into the "Earth at Night" Map: you can see how the map will suddenly show a lot more detail as new data has arrived on the computer in the background. Keep watching and you'll see the same happening with the "Satellite View" map.



From Part I we know that internally the current map gets provided at different sizes - each size at different resolutions. These different map "levels" are split into 675x675 pixel tiles each. Depending on the zoom level only those tiles that are actually visible will get loaded into the physical memory ("RAM") of our computer. This mechanism keeps physical memory consumption low. For each tile Marble will check first whether it's available in the physical memory's Tile Cache (yes, you were about to suggest this feature, but we got it implemented already!). If it's not available in the "Tile Cache" Marble will try to load it from the local hard disc. In case it's not there Marble will schedule the tile for download in Marble's very own HttpDownloadManager. But wait - what should we display in the meantime while there is no matching tile available? After all due to the way Marble works we can't simply "omit" the missing tile!


As a cheap but smart workaround Marble just scales up the tile at the biggest zoom level that is locally available for this particular place. It will then just cut out the area that is needed and will use this handcrafted DIY-tile as a temporary replacement until the "real" data arrives.

In the meantime the HttpDownloadManager will contact the server and will look for the tile in question (e.g. it might look for this one ) .
It's only convenient that on the server all the tiles get stored in the very same directory hierarchy as on the local hard disc:

{marble-data-base-url}/maps/earth/{theme}/{level}/{row}/{row}_{column}.jpg


So Marble will fetch the tile from the server and will store it locally on the hard disc - again sticking to the given tile directory hierarchy. Once it got stored locally Marble will update the temporary data of the texture tile to match the "real" data.

This mechanism works pretty well already. The HttpDownloadManager is also used to download the Wikipedia webpages that get displayed if you left-click on city labels or symbols.


If you're a real GIS person you might wonder whether it's possible to just replace this HttpDownloadManager with something "more sane" - like an enterprise database that has this data stored already. Yes, a suitable solution might be available in marble/src/lib/MarbleWidget.{cpp,h} where you'll find a method called: void MarbleWidget::setDownloadManager( HttpDownloadManager *downloadManager );
(soon to be changed to "AbstractTileProvider"). Just replace the HttpDownloadManager pointer with a pointer to your very own custom TileProvider class.

Get Hot New Maps ...


But what if you don't just want to zoom into maps that exist on your hard disc already. What if you want new maps on your computer?
DXS to rescue! DXS is the successor of "Get Hot New Stuff (GHNS)". It's a web service that allows applications to download and install data from the Internet in one single click.
So if you have the

torsten rahn's picture

Marble's Secrets Part II - Walking In The Shoes Of Slartibartfast ...

In Part I we have seen how easy it is to create your own maps for Marble. We've also seen how this works down to the zoom level of aerial photos or OpenStreetMap. Part II will show how Marble manages to provide the biggest bang for the byte when it comes to providing map data. It outlines how we managed to get the default map squeezed into the 10MB package that the Marble-Qt version gets shipped with. We basically show ...

Why Marble is the perfect choice for Asus EeePC, OLPC & Co and some Embedded Devices ... Eye-wink




Caption: Marble running on my Asus EeePC and on the OLPC (OLPC photo kindly provided by Bernhard Rosenkränzer of ArkLinux fame)

If you followed our last part closely and did a bit hands-on work then you maybe have stumbled across the contents of ~/.marble/data/maps/earth/srtm . This one contains part of the data for the default topographic view which is pretty colorful to mimic the appearance of a typical school atlas. Although the Marble application focuses on the educational aspect that's only one reason why we default to the topographic map:

If you look at the actual tiles of the "Atlas" map then you will realize that they are all provided as grayscale bitmaps! If you actually replace "false" by "true" in line 10 of the srtm.dgml-textfile (which is likely placed in /usr/share/apps/marble/data/maps/earth/srtm/srtm.dgml if you're on a Linux/UNIX system) then your line should look like this:

<layer type="bitmap" name="srtm" dem="false"/>


Restart Marble and choose the "Atlas" map, zoom out a bit and you can see the grayscale data in "raw mode" in its full dull beauty. Actually you'll find out that it has a blue tint as Marble just applies the grayscale data to the blue color channel.



So apparently Marble takes the grayscale data, and somehow applies colors to it! This is pretty smart: All tiles get stored as JPG's. But grayscale images use up a lot less space on the hard disc drive than color images. Color images just need four bytes (RGBA) per pixel while grayscale only needs a single byte per pixel! And you can even compress grayscale tiles a lot more than color tiles: Usually people feel offended by highly compressed JPGs due to the violet-pinky artefact-shades that result from an overly compressed JPG-file.

With grayscale images this artefact is gone and it's much harder to tell a highly compressed image from an uncompressed one! That's the reason why Marble can store a lot more map data (about 4 times as much) in Atlas View than it would be possible in Satellite View!

The grayscale shades actually represent heights. In fact those grayscale shades are based on data that was acquired during the Shuttle Radar Topography Mission" ("SRTM") back in February of 2000: A radar system that flew onboard the Space Shuttle Endeavour during STS-99 mission obtained digital elevation models on a near-global scale from 56 °S to 60 °N. While Marble only ships part of the data the whole SRTM provides the most complete high-resolution digital topographic database of Earth to date! That's why the GIS community loves the SRTM data so much.

Now if we would just map those grayscale values to color values and if we would colorize our map that way then we would get a beautiful and clean map. We'd just choose a green-yellow-brown palette for all grayscale-values which represent heights above sea level. And we'd choose a blueish palette for everything below sea level - but wait: There are some large areas, e.g. in northern africa, which are actually below sealevel and which are not filled with water!
However several moons ago when Marble hatched from its spherical egg it worked exactly as suggested before. Back then it actually looked like this. Look at the upper coastline of africa and you'll spot some blue patches of water which are actually not supposed to be there ...




Caption: Left: Marble on MacOS X using beautiful high-res full-color SRTM tiles created with Mapnik (Credits: Artem Pavlenko). Right: Marble using the Altas map: notice the vector coastline blending with the texture data).

So we need some data for a coast line which enables us to choose the correct palette for the land and for the sea. Marble right now ships with such data which was very popular back in the 90ies: The "Micro World Database II" - which is based on some work by the Central Intelligence Agency, "CIA" back in

Syndicate content