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.

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.

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.

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.

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.

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!.

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 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
#include
#include

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!

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)

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.