diff --git a/src/lib/marble/StyleBuilder.cpp b/src/lib/marble/StyleBuilder.cpp
index c13983b5d..7d114832a 100644
--- a/src/lib/marble/StyleBuilder.cpp
+++ b/src/lib/marble/StyleBuilder.cpp
@@ -1,1454 +1,1465 @@
 //
 // This file is part of the Marble Virtual Globe.
 //
 // This program is free software licensed under the GNU LGPL. You can
 // find a copy of this license in LICENSE.txt in the top directory of
 // the source code.
 //
 // Copyright 2007      Murad Tagirov <tmurad@gmail.com>
 // Copyright 2009      Patrick Spendrin <ps_ml@gmx.de>
 // Copyright 2016      Dennis Nienhüser <nienhueser@kde.org>
 //
 
 #include "StyleBuilder.h"
 
 #include "MarbleDirs.h"
 #include "OsmPlacemarkData.h"
 #include "GeoDataTypes.h"
 #include "GeoDataPlacemark.h"
 #include "OsmPresetLibrary.h"
 
 #include <QApplication>
 #include <QFont>
 #include <QImage>
 #include <QDate>
 #include <QSet>
 #include <QScreen>
 
 namespace Marble {
 
 class StyleBuilder::Private
 {
 public:
     Private();
 
     static GeoDataStyle::Ptr createStyle( qreal width, qreal realWidth, const QColor& color,
                                       const QColor& outlineColor, bool fill, bool outline,
                                       Qt::BrushStyle brushStyle, Qt::PenStyle penStyle,
                                       Qt::PenCapStyle capStyle, bool lineBackground,
                                       const QVector< qreal >& dashPattern = QVector< qreal >(),
                                       const QFont& font = QFont(QLatin1String("Arial")), const QColor& fontColor = Qt::black,
                                       const QString& texturePath = QString());
     static GeoDataStyle::Ptr createOsmPOIStyle( const QFont &font, const QString &bitmap,
                                          const QColor &textColor = Qt::black,
                                          const QColor &color = QColor( 0xBE, 0xAD, 0xAD ),
                                          const QColor &outline = QColor( 0xBE, 0xAD, 0xAD ).darker()
                                          );
     static GeoDataStyle::Ptr createHighwayStyle( const QString &bitmap, const QColor& color, const QColor& outlineColor,
                                              const QFont& font = QFont(QLatin1String("Arial")), const QColor& fontColor = Qt::black,
                                              qreal width = 1, qreal realWidth = 0.0,
                                              Qt::PenStyle penStyle = Qt::SolidLine,
                                              Qt::PenCapStyle capStyle = Qt::RoundCap,
                                              bool lineBackground = false);
     static GeoDataStyle::Ptr createWayStyle( const QColor& color, const QColor& outlineColor,
                                          bool fill = true, bool outline = true,
                                          Qt::BrushStyle brushStyle = Qt::SolidPattern,
                                          const QString& texturePath = QString());
 
     void initializeDefaultStyles();
 
     static QString createPaintLayerItem(const QString &itemType, GeoDataFeature::GeoDataVisualCategory visualCategory, const QString &subType = QString());
 
     int m_defaultMinZoomLevels[GeoDataFeature::LastIndex];
     int m_maximumZoomLevel;
     QColor m_defaultLabelColor;
     QFont m_defaultFont;
     GeoDataStyle::Ptr m_defaultStyle[GeoDataFeature::LastIndex];
     bool m_defaultStyleInitialized;
 };
 
 StyleBuilder::Private::Private() :
     m_maximumZoomLevel(15),
     m_defaultLabelColor(Qt::black),
     m_defaultFont(QStringLiteral("Sans Serif")),
     m_defaultStyle(),
     m_defaultStyleInitialized(false)
 {
     for ( int i = 0; i < GeoDataFeature::LastIndex; i++ )
         m_defaultMinZoomLevels[i] = m_maximumZoomLevel;
 
     m_defaultMinZoomLevels[GeoDataFeature::Default]             = 1;
     m_defaultMinZoomLevels[GeoDataFeature::NaturalReef]         = 3;
     m_defaultMinZoomLevels[GeoDataFeature::NaturalWater]        = 3;
     m_defaultMinZoomLevels[GeoDataFeature::NaturalWood]         = 8;
     m_defaultMinZoomLevels[GeoDataFeature::NaturalBeach]        = 10;
     m_defaultMinZoomLevels[GeoDataFeature::NaturalWetland]      = 10;
     m_defaultMinZoomLevels[GeoDataFeature::NaturalGlacier]      = 3;
     m_defaultMinZoomLevels[GeoDataFeature::NaturalIceShelf]     = 3;
     m_defaultMinZoomLevels[GeoDataFeature::NaturalScrub]        = 10;
     m_defaultMinZoomLevels[GeoDataFeature::NaturalCliff]        = 15;
     m_defaultMinZoomLevels[GeoDataFeature::NaturalPeak]         = 11;
     m_defaultMinZoomLevels[GeoDataFeature::BarrierCityWall]     = 15;
     m_defaultMinZoomLevels[GeoDataFeature::Building]            = 15;
 
     m_defaultMinZoomLevels[GeoDataFeature::ManmadeBridge]       = 15;
 
         // OpenStreetMap highways
     m_defaultMinZoomLevels[GeoDataFeature::HighwaySteps]        = 15;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayUnknown]      = 13;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayPath]         = 13;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayTrack]        = 13;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayPedestrian]   = 13;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayFootway]      = 13;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayCycleway]     = 13;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayService]      = 13;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayRoad]         = 13;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayTertiaryLink] = 10;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayTertiary]     = 10;
     m_defaultMinZoomLevels[GeoDataFeature::HighwaySecondaryLink]= 10;
     m_defaultMinZoomLevels[GeoDataFeature::HighwaySecondary]    = 9;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayPrimaryLink]  = 10;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayPrimary]      = 8;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayTrunkLink]    = 10;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayTrunk]        = 7;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayMotorwayLink] = 10;
     m_defaultMinZoomLevels[GeoDataFeature::HighwayMotorway]     = 6;
 
 #if 0 // not needed as long as default min zoom level is 15
     for(int i = GeoDataFeature::AccomodationCamping; i <= GeoDataFeature::ReligionSikh; i++)
         s_defaultMinZoomLevels[i] = 15;
 #endif
 
     m_defaultMinZoomLevels[GeoDataFeature::AmenityGraveyard]    = 14;
     m_defaultMinZoomLevels[GeoDataFeature::AmenityFountain]     = 17;
 
     m_defaultMinZoomLevels[GeoDataFeature::MilitaryDangerArea]  = 11;
 
     m_defaultMinZoomLevels[GeoDataFeature::LeisureMarina]       = 13;
     m_defaultMinZoomLevels[GeoDataFeature::LeisurePark]         = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LeisurePlayground]   = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseAllotments]   = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseBasin]        = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseCemetery]     = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseCommercial]   = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseConstruction] = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseFarmland]     = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseFarmyard]     = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseGarages]      = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseGrass]        = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseIndustrial]   = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseLandfill]     = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseMeadow]       = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseMilitary]     = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseQuarry]       = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseRailway]      = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseReservoir]    = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseResidential]  = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseRetail]       = 11;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseOrchard]      = 14;
     m_defaultMinZoomLevels[GeoDataFeature::LanduseVineyard]     = 14;
 
     m_defaultMinZoomLevels[GeoDataFeature::RailwayRail]         = 6;
     m_defaultMinZoomLevels[GeoDataFeature::RailwayNarrowGauge]  = 6;
     m_defaultMinZoomLevels[GeoDataFeature::RailwayTram]         = 14;
     m_defaultMinZoomLevels[GeoDataFeature::RailwayLightRail]    = 12;
     m_defaultMinZoomLevels[GeoDataFeature::RailwayAbandoned]    = 10;
     m_defaultMinZoomLevels[GeoDataFeature::RailwaySubway]       = 13;
     m_defaultMinZoomLevels[GeoDataFeature::RailwayPreserved]    = 13;
     m_defaultMinZoomLevels[GeoDataFeature::RailwayMiniature]    = 13;
     m_defaultMinZoomLevels[GeoDataFeature::RailwayConstruction] = 10;
     m_defaultMinZoomLevels[GeoDataFeature::RailwayMonorail]     = 12;
     m_defaultMinZoomLevels[GeoDataFeature::RailwayFunicular]    = 13;
     m_defaultMinZoomLevels[GeoDataFeature::TransportPlatform]   = 16;
 
     m_defaultMinZoomLevels[GeoDataFeature::Satellite]           = 0;
 
     m_defaultMinZoomLevels[GeoDataFeature::Landmass]            = 0;
     m_defaultMinZoomLevels[GeoDataFeature::UrbanArea]           = 3;
     m_defaultMinZoomLevels[GeoDataFeature::InternationalDateLine]      = 1;
+    m_defaultMinZoomLevels[GeoDataFeature::Bathymetry]          = 1;
+
 
     m_defaultMinZoomLevels[GeoDataFeature::AdminLevel1]         = 0;
     m_defaultMinZoomLevels[GeoDataFeature::AdminLevel2]         = 1;
     m_defaultMinZoomLevels[GeoDataFeature::AdminLevel3]         = 1;
     m_defaultMinZoomLevels[GeoDataFeature::AdminLevel4]         = 2;
     m_defaultMinZoomLevels[GeoDataFeature::AdminLevel5]         = 4;
     m_defaultMinZoomLevels[GeoDataFeature::AdminLevel6]         = 5;
     m_defaultMinZoomLevels[GeoDataFeature::AdminLevel7]         = 5;
     m_defaultMinZoomLevels[GeoDataFeature::AdminLevel8]         = 7;
     m_defaultMinZoomLevels[GeoDataFeature::AdminLevel9]         = 7;
     m_defaultMinZoomLevels[GeoDataFeature::AdminLevel10]        = 8;
     m_defaultMinZoomLevels[GeoDataFeature::AdminLevel11]        = 8;
 
     m_defaultMinZoomLevels[GeoDataFeature::BoundaryMaritime]    = 1;
 
     for (int i = 0; i < GeoDataFeature::LastIndex; ++i) {
         m_maximumZoomLevel = qMax(m_maximumZoomLevel, m_defaultMinZoomLevels[i]);
     }
 }
 
 GeoDataStyle::Ptr StyleBuilder::Private::createOsmPOIStyle( const QFont &font, const QString &imagePath,
                                      const QColor &textColor, const QColor &color, const QColor &outline)
 {
     GeoDataStyle::Ptr style =  createStyle(1, 0, color, outline, true, true, Qt::SolidPattern, Qt::SolidLine, Qt::RoundCap, false);
     QString const path = MarbleDirs::path( "svg/osmcarto/svg/" + imagePath + ".svg" );
     style->setIconStyle( GeoDataIconStyle( path) );
     auto const screen = QApplication::screens().first();
     double const physicalSize = 6.0; // mm
     int const pixelSize = qRound(physicalSize * screen->physicalDotsPerInch() / (IN2M * M2MM));
     style->iconStyle().setSize(QSize(pixelSize, pixelSize));
     style->setLabelStyle( GeoDataLabelStyle( font, textColor ) );
     style->labelStyle().setAlignment(GeoDataLabelStyle::Center);
     return style;
 }
 
 GeoDataStyle::Ptr StyleBuilder::Private::createHighwayStyle( const QString &imagePath, const QColor& color, const QColor& outlineColor,
                                          const QFont& font, const QColor& fontColor, qreal width, qreal realWidth, Qt::PenStyle penStyle,
                                                              Qt::PenCapStyle capStyle, bool lineBackground)
 {
     GeoDataStyle::Ptr style = createStyle( width, realWidth, color, outlineColor, true, true,
                                        Qt::SolidPattern, penStyle, capStyle, lineBackground, QVector< qreal >(),
                                        font, fontColor );
     if( !imagePath.isEmpty() ) {
         style->setIconStyle( GeoDataIconStyle( MarbleDirs::path( "svg/osmcarto/svg/" + imagePath + ".svg" ) ) );
     }
     return style;
 }
 
 GeoDataStyle::Ptr StyleBuilder::Private::createWayStyle( const QColor& color, const QColor& outlineColor,
                                      bool fill, bool outline, Qt::BrushStyle brushStyle, const QString& texturePath)
 {
     return createStyle( 1, 0, color, outlineColor, fill, outline, brushStyle, Qt::SolidLine, Qt::RoundCap, false, QVector< qreal >(), QFont("Arial"), Qt::black, texturePath );
 }
 
 GeoDataStyle::Ptr StyleBuilder::Private::createStyle( qreal width, qreal realWidth, const QColor& color,
                                   const QColor& outlineColor, bool fill, bool outline, Qt::BrushStyle brushStyle, Qt::PenStyle penStyle,
                                   Qt::PenCapStyle capStyle, bool lineBackground, const QVector< qreal >& dashPattern,
                                   const QFont& font, const QColor& fontColor, const QString& texturePath)
 {
     GeoDataStyle *style = new GeoDataStyle;
     GeoDataLineStyle lineStyle( outlineColor );
     lineStyle.setCapStyle( capStyle );
     lineStyle.setPenStyle( penStyle );
     lineStyle.setWidth( width );
     lineStyle.setPhysicalWidth( realWidth );
     lineStyle.setBackground( lineBackground );
     lineStyle.setDashPattern( dashPattern );
     GeoDataPolyStyle polyStyle( color );
     polyStyle.setOutline( outline );
     polyStyle.setFill( fill );
     polyStyle.setBrushStyle( brushStyle );
     polyStyle.setTexturePath( texturePath );
     GeoDataLabelStyle labelStyle(font, fontColor);
     style->setLineStyle( lineStyle );
     style->setPolyStyle( polyStyle );
     style->setLabelStyle( labelStyle );
     return GeoDataStyle::Ptr(style);
 }
 
 void StyleBuilder::Private::initializeDefaultStyles()
 {
     // We need to do this similar to the way KCmdLineOptions works in
     // the future: Having a PlacemarkStyleProperty properties[] would
     // help here greatly.
 
     if (m_defaultStyleInitialized) {
         return;
     }
 
     m_defaultStyleInitialized = true;
 
     QString defaultFamily = m_defaultFont.family();
 
 #ifdef Q_OS_MACX
     int defaultSize = 10;
 #else
     int defaultSize = 8;
 #endif
 
     QColor const defaultLabelColor = m_defaultLabelColor;
 
     m_defaultStyle[GeoDataFeature::None]
         = GeoDataStyle::Ptr(new GeoDataStyle( QString(),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Default]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/default_location.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Unknown]
         = GeoDataStyle::Ptr(new GeoDataStyle( QString(),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::SmallCity]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_4_white.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::SmallCountyCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_4_yellow.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::SmallStateCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_4_orange.png" ),
               QFont( defaultFamily, defaultSize, 50, true  ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::SmallNationCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_4_red.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::MediumCity]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_3_white.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::MediumCountyCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_3_yellow.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::MediumStateCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_3_orange.png" ),
               QFont( defaultFamily, defaultSize, 50, true  ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::MediumNationCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_3_red.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::BigCity]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_2_white.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::BigCountyCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_2_yellow.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::BigStateCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_2_orange.png" ),
               QFont( defaultFamily, defaultSize, 50, true  ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::BigNationCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_2_red.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::LargeCity]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_1_white.png" ),
               QFont( defaultFamily, defaultSize, 75, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::LargeCountyCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_1_yellow.png" ),
               QFont( defaultFamily, defaultSize, 75, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::LargeStateCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_1_orange.png" ),
               QFont( defaultFamily, defaultSize, 75, true  ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::LargeNationCapital]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/city_1_red.png" ),
               QFont( defaultFamily, defaultSize, 75, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Nation]
         = GeoDataStyle::Ptr(new GeoDataStyle( QString(),
               QFont( defaultFamily, (int)(defaultSize * 1.2 ), 75, false ), QColor( "#404040" ) ));
     // Align area labels centered
     m_defaultStyle[GeoDataFeature::Nation]->labelStyle().setAlignment( GeoDataLabelStyle::Center );
 
     m_defaultStyle[GeoDataFeature::PlaceCity] = GeoDataStyle::Ptr(new GeoDataStyle( QString(), QFont( defaultFamily, (int)(defaultSize * 2.0 ), 75, false ), QColor( "#202020" ) ));
     m_defaultStyle[GeoDataFeature::PlaceCity]->labelStyle().setAlignment( GeoDataLabelStyle::Center );
     m_defaultStyle[GeoDataFeature::PlaceSuburb] = GeoDataStyle::Ptr(new GeoDataStyle( QString(), QFont( defaultFamily, (int)(defaultSize * 2.0 ), 75, false ), QColor( "#707070" ) ));
     m_defaultStyle[GeoDataFeature::PlaceSuburb]->labelStyle().setAlignment( GeoDataLabelStyle::Center );
     m_defaultStyle[GeoDataFeature::PlaceHamlet] = GeoDataStyle::Ptr(new GeoDataStyle( QString(), QFont( defaultFamily, (int)(defaultSize * 2.0 ), 75, false ), QColor( "#707070" ) ));
     m_defaultStyle[GeoDataFeature::PlaceHamlet]->labelStyle().setAlignment( GeoDataLabelStyle::Center );
     m_defaultStyle[GeoDataFeature::PlaceLocality] = GeoDataStyle::Ptr(new GeoDataStyle( QString(), QFont( defaultFamily, (int)(defaultSize * 2.0 ), 75, false ), QColor( "#707070" ) ));
     m_defaultStyle[GeoDataFeature::PlaceLocality]->labelStyle().setAlignment( GeoDataLabelStyle::Center );
     m_defaultStyle[GeoDataFeature::PlaceTown] = GeoDataStyle::Ptr(new GeoDataStyle( QString(), QFont( defaultFamily, (int)(defaultSize * 2.0 ), 75, false ), QColor( "#404040" ) ));
     m_defaultStyle[GeoDataFeature::PlaceTown]->labelStyle().setAlignment( GeoDataLabelStyle::Center );
     m_defaultStyle[GeoDataFeature::PlaceVillage] = GeoDataStyle::Ptr(new GeoDataStyle( QString(), QFont( defaultFamily, (int)(defaultSize * 2.0 ), 75, false ), QColor( "#505050" ) ));
     m_defaultStyle[GeoDataFeature::PlaceVillage]->labelStyle().setAlignment( GeoDataLabelStyle::Center );
 
     m_defaultStyle[GeoDataFeature::Mountain]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/mountain_1.png" ),
               QFont( defaultFamily, (int)(defaultSize * 0.9 ), 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Volcano]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/volcano_1.png" ),
               QFont( defaultFamily, (int)(defaultSize * 0.9 ), 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Mons]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/mountain_1.png" ),
               QFont( defaultFamily, (int)(defaultSize * 0.9 ), 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Valley]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/valley.png" ),
               QFont( defaultFamily, (int)(defaultSize * 0.9 ), 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Continent]
         = GeoDataStyle::Ptr(new GeoDataStyle( QString(),
               QFont( defaultFamily, (int)(defaultSize * 1.7 ), 50, false ), QColor( "#bf0303" ) ));
     // Align area labels centered
     m_defaultStyle[GeoDataFeature::Continent]->labelStyle().setAlignment( GeoDataLabelStyle::Center );
 
     m_defaultStyle[GeoDataFeature::Ocean]
         = GeoDataStyle::Ptr(new GeoDataStyle( QString(),
               QFont( defaultFamily, (int)(defaultSize * 1.7 ), 50, true ), QColor( "#2c72c7" ) ));
     // Align area labels centered
     m_defaultStyle[GeoDataFeature::Ocean]->labelStyle().setAlignment( GeoDataLabelStyle::Center );
 
     m_defaultStyle[GeoDataFeature::OtherTerrain]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/other.png" ),
               QFont( defaultFamily, (int)(defaultSize * 0.9 ), 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Crater]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/crater.png" ),
               QFont( defaultFamily, (int)(defaultSize * 0.9 ), 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Mare]
         = GeoDataStyle::Ptr(new GeoDataStyle( QString(),
               QFont( defaultFamily, (int)(defaultSize * 1.7 ), 50, false ), QColor( "#bf0303" ) ));
     // Align area labels centered
     m_defaultStyle[GeoDataFeature::Mare]->labelStyle().setAlignment( GeoDataLabelStyle::Center );
 
     m_defaultStyle[GeoDataFeature::GeographicPole]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/pole_1.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::MagneticPole]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/pole_2.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::ShipWreck]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/shipwreck.png" ),
               QFont( defaultFamily, (int)(defaultSize * 0.8 ), 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::AirPort]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/airport.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Observatory]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/observatory.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::OsmSite]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/osm.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Coordinate]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/coordinate.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
 
     m_defaultStyle[GeoDataFeature::MannedLandingSite]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/manned_landing.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::RoboticRover]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/robotic_rover.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::UnmannedSoftLandingSite]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/unmanned_soft_landing.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::UnmannedHardLandingSite]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/unmanned_hard_landing.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Folder]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/folder.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     m_defaultStyle[GeoDataFeature::Bookmark]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/bookmark.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     QColor const shopColor("#ac39ac");
     QColor const transportationColor("#0066ff");
     QColor const amenityColor("#734a08");
     QColor const healthColor("#da0092");
     QColor const airTransportColor("#8461C4");
     QColor const educationalAreasAndHospital("#f0f0d8");
     QColor const buildingColor("#beadad");
     QColor const waterColor("#b5d0d0");
     // Allows to visualize multiple repaints of buildings
 //    QColor const buildingColor(0, 255, 0, 64);
 
     QFont const osmFont( defaultFamily, 10, 50, false );
     m_defaultStyle[GeoDataFeature::AccomodationCamping]      = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/camping.16", transportationColor );
     m_defaultStyle[GeoDataFeature::AccomodationHostel]       = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/hostel.16", transportationColor );
     m_defaultStyle[GeoDataFeature::AccomodationHotel]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/hotel.16", transportationColor );
     m_defaultStyle[GeoDataFeature::AccomodationMotel]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/motel.16", transportationColor );
     m_defaultStyle[GeoDataFeature::AccomodationYouthHostel]  = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/hostel.16", transportationColor );
     m_defaultStyle[GeoDataFeature::AccomodationGuestHouse]   = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/guest_house.16", transportationColor );
     m_defaultStyle[GeoDataFeature::AmenityLibrary]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/library.20", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityKindergarten]      = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString(), amenityColor, educationalAreasAndHospital, amenityColor );
     m_defaultStyle[GeoDataFeature::EducationCollege]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString(), amenityColor, educationalAreasAndHospital, amenityColor );
     m_defaultStyle[GeoDataFeature::EducationSchool]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString(), amenityColor, educationalAreasAndHospital, amenityColor );
     m_defaultStyle[GeoDataFeature::EducationUniversity]      = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString(), amenityColor, educationalAreasAndHospital, amenityColor );
     m_defaultStyle[GeoDataFeature::FoodBar]                  = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/bar.16", amenityColor );
     m_defaultStyle[GeoDataFeature::FoodBiergarten]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/biergarten.16", amenityColor );
     m_defaultStyle[GeoDataFeature::FoodCafe]                 = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/cafe.16", amenityColor );
     m_defaultStyle[GeoDataFeature::FoodFastFood]             = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/fast_food.16", amenityColor );
     m_defaultStyle[GeoDataFeature::FoodPub]                  = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/pub.16", amenityColor );
     m_defaultStyle[GeoDataFeature::FoodRestaurant]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/restaurant.16", amenityColor );
 
     m_defaultStyle[GeoDataFeature::HealthDentist]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "health/dentist.16", healthColor );
     m_defaultStyle[GeoDataFeature::HealthDoctors]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "health/doctors.16", healthColor );
     m_defaultStyle[GeoDataFeature::HealthHospital]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "health/hospital.16", healthColor, educationalAreasAndHospital, amenityColor );
     m_defaultStyle[GeoDataFeature::HealthPharmacy]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "health/pharmacy.16", healthColor );
     m_defaultStyle[GeoDataFeature::HealthVeterinary]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "health/veterinary-14", healthColor );
 
     m_defaultStyle[GeoDataFeature::MoneyAtm]                 = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/atm.16", amenityColor );
     m_defaultStyle[GeoDataFeature::MoneyBank]                = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/bank.16", amenityColor );
 
     m_defaultStyle[GeoDataFeature::AmenityArchaeologicalSite] = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/archaeological_site.16", amenityColor, Qt::transparent );
     m_defaultStyle[GeoDataFeature::AmenityEmbassy]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/embassy.16", transportationColor );
     m_defaultStyle[GeoDataFeature::AmenityEmergencyPhone]    = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/emergency_phone.16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityWaterPark]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/water_park.16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityCommunityCentre]   = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/community_centre-14", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityFountain]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/fountain-14", QColor("#7989de"), waterColor, waterColor.darker(150) );
     m_defaultStyle[GeoDataFeature::AmenityNightClub]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/nightclub.18", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityBench]             = StyleBuilder::Private::createOsmPOIStyle( osmFont, "individual/bench.16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityCourtHouse]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/courthouse-16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityFireStation]       = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/firestation.16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityHuntingStand]      = StyleBuilder::Private::createOsmPOIStyle( osmFont, "manmade/hunting-stand.16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityPolice]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/police.16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityPostBox]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/post_box-12", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityPostOffice]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/post_office-14", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityPrison]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/prison.16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityRecycling]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/recycling.16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityTelephone]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/telephone.16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityToilets]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/toilets.16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityTownHall]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/town_hall.16", amenityColor );
     m_defaultStyle[GeoDataFeature::AmenityWasteBasket]       = StyleBuilder::Private::createOsmPOIStyle( osmFont, "individual/waste_basket.10", amenityColor );
 
     m_defaultStyle[GeoDataFeature::AmenityDrinkingWater]     = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/drinking_water.16", amenityColor );
 
     m_defaultStyle[GeoDataFeature::NaturalPeak]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "individual/peak", amenityColor );
     m_defaultStyle[GeoDataFeature::NaturalPeak]->iconStyle().setScale(0.33);
     m_defaultStyle[GeoDataFeature::NaturalTree]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "individual/tree-29", amenityColor ); // tree-16 provides the official icon
 
     m_defaultStyle[GeoDataFeature::ShopBeverages]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/beverages-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopHifi]                 = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/hifi-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopSupermarket]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_supermarket", shopColor );
     m_defaultStyle[GeoDataFeature::ShopAlcohol]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_alcohol.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopBakery]               = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_bakery.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopButcher]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/butcher-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopConfectionery]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/confectionery.14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopConvenience]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_convenience", shopColor );
     m_defaultStyle[GeoDataFeature::ShopGreengrocer]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/greengrocer-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopSeafood]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/seafood-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopDepartmentStore]      = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/department_store-16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopKiosk]                = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/kiosk-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopBag]                  = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/bag-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopClothes]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_clothes.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopFashion]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_clothes.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopJewelry]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_jewelry.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopShoes]                = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_shoes.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopVarietyStore]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/variety_store-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopBeauty]               = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/beauty-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopChemist]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/chemist-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopCosmetics]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/perfumery-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopHairdresser]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_hairdresser.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopOptician]             = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_optician.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopPerfumery]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/perfumery-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopDoitYourself]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_diy.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopFlorist]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/florist.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopHardware]             = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_diy.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopFurniture]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_furniture.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopElectronics]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_electronics.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopMobilePhone]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_mobile_phone.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopBicycle]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_bicycle.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopCar]                  = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_car", shopColor );
     m_defaultStyle[GeoDataFeature::ShopCarRepair]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shopping_car_repair.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopCarParts]             = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/car_parts-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopMotorcycle]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/motorcycle-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopOutdoor]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/outdoor-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopMusicalInstrument]    = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/musical_instrument-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopPhoto]                = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/photo-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopBook]                 = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_books.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopGift]                 = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_gift.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopStationery]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/stationery-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopLaundry]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/laundry-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopPet]                  = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop_pet.16", shopColor );
     m_defaultStyle[GeoDataFeature::ShopToys]                 = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/toys-14", shopColor );
     m_defaultStyle[GeoDataFeature::ShopTravelAgency]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/travel_agency-14", shopColor );
     m_defaultStyle[GeoDataFeature::Shop]                     = StyleBuilder::Private::createOsmPOIStyle( osmFont, "shop/shop-14", shopColor );
 
     m_defaultStyle[GeoDataFeature::ManmadeBridge]            = StyleBuilder::Private::createWayStyle( QColor("#b8b8b8"), QColor("transparent"), true, true );
     m_defaultStyle[GeoDataFeature::ManmadeLighthouse]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/lighthouse.16", transportationColor, "#f2efe9", QColor( "#f2efe9" ).darker() );
     m_defaultStyle[GeoDataFeature::ManmadePier]              = StyleBuilder::Private::createStyle(0.0, 3.0, "#f2efe9", "#f2efe9", true, true, Qt::SolidPattern, Qt::SolidLine, Qt::FlatCap, false );
     m_defaultStyle[GeoDataFeature::ManmadeWaterTower]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/water_tower.16", amenityColor );
     m_defaultStyle[GeoDataFeature::ManmadeWindMill]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/windmill.16", amenityColor );
 
     m_defaultStyle[GeoDataFeature::TouristAttraction]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/tourist_memorial.16", amenityColor );
     m_defaultStyle[GeoDataFeature::TouristCastle]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/cinema.16", amenityColor );
     m_defaultStyle[GeoDataFeature::TouristCinema]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/cinema.16", amenityColor );
     m_defaultStyle[GeoDataFeature::TouristInformation]       = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/information.16", amenityColor );
     m_defaultStyle[GeoDataFeature::TouristMonument]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/monument.16", amenityColor );
     m_defaultStyle[GeoDataFeature::TouristMuseum]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/museum.16", amenityColor );
     m_defaultStyle[GeoDataFeature::TouristRuin]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString(), amenityColor );
     m_defaultStyle[GeoDataFeature::TouristTheatre]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/theatre.16", amenityColor );
     m_defaultStyle[GeoDataFeature::TouristThemePark]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString(), amenityColor );
     m_defaultStyle[GeoDataFeature::TouristViewPoint]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/viewpoint.16", amenityColor );
     m_defaultStyle[GeoDataFeature::TouristZoo]               = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString(), amenityColor, Qt::transparent );
     m_defaultStyle[GeoDataFeature::TouristAlpineHut]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/alpinehut.16", transportationColor );
     m_defaultStyle[GeoDataFeature::TransportAerodrome]       = StyleBuilder::Private::createOsmPOIStyle( osmFont, "airtransport/aerodrome", airTransportColor );
     m_defaultStyle[GeoDataFeature::TransportHelipad]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "airtransport/helipad", airTransportColor );
     m_defaultStyle[GeoDataFeature::TransportAirportTerminal] = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString(), airTransportColor );
     m_defaultStyle[GeoDataFeature::TransportBusStation]      = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/bus_station.16", transportationColor );
     m_defaultStyle[GeoDataFeature::TransportBusStop]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/bus_stop.12", transportationColor );
     m_defaultStyle[GeoDataFeature::TransportCarShare]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/car_share.16", transportationColor );
     m_defaultStyle[GeoDataFeature::TransportFuel]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/fuel.16", transportationColor );
     m_defaultStyle[GeoDataFeature::TransportParking]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/parking", transportationColor, "#F6EEB6", QColor( "#F6EEB6" ).darker() );
     m_defaultStyle[GeoDataFeature::TransportParkingSpace]    = StyleBuilder::Private::createWayStyle( "#F6EEB6", QColor( "#F6EEB6" ).darker(), true, true );
     m_defaultStyle[GeoDataFeature::TransportPlatform]        = StyleBuilder::Private::createWayStyle( "#bbbbbb", Qt::transparent, true, false );
     m_defaultStyle[GeoDataFeature::TransportTrainStation]    = StyleBuilder::Private::createOsmPOIStyle( osmFont, "individual/railway_station", transportationColor );
     m_defaultStyle[GeoDataFeature::TransportTramStop]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString(), transportationColor );
     m_defaultStyle[GeoDataFeature::TransportRentalBicycle]   = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/rental_bicycle.16", transportationColor );
     m_defaultStyle[GeoDataFeature::TransportRentalCar]       = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/rental_car.16", transportationColor );
     m_defaultStyle[GeoDataFeature::TransportTaxiRank]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/taxi.16", transportationColor );
     m_defaultStyle[GeoDataFeature::TransportBicycleParking]  = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/bicycle_parking.16", transportationColor );
     m_defaultStyle[GeoDataFeature::TransportMotorcycleParking] = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/motorcycle_parking.16", transportationColor );
     m_defaultStyle[GeoDataFeature::TransportSubwayEntrance]  = StyleBuilder::Private::createOsmPOIStyle( osmFont, "transportation/subway_entrance", transportationColor );
     m_defaultStyle[GeoDataFeature::ReligionPlaceOfWorship]   = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString() /* "black/place_of_worship.16" */ );
     m_defaultStyle[GeoDataFeature::ReligionBahai]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString() );
     m_defaultStyle[GeoDataFeature::ReligionBuddhist]         = StyleBuilder::Private::createOsmPOIStyle( osmFont, "black/buddhist.16" );
     m_defaultStyle[GeoDataFeature::ReligionChristian]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "black/christian.16" );
     m_defaultStyle[GeoDataFeature::ReligionMuslim]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "black/muslim.16" );
     m_defaultStyle[GeoDataFeature::ReligionHindu]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, "black/hinduist.16" );
     m_defaultStyle[GeoDataFeature::ReligionJain]             = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString() );
     m_defaultStyle[GeoDataFeature::ReligionJewish]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "black/jewish.16" );
     m_defaultStyle[GeoDataFeature::ReligionShinto]           = StyleBuilder::Private::createOsmPOIStyle( osmFont, "black/shintoist.16" );
     m_defaultStyle[GeoDataFeature::ReligionSikh]             = StyleBuilder::Private::createOsmPOIStyle( osmFont, "black/sikhist.16" );
 
     m_defaultStyle[GeoDataFeature::HighwayTrafficSignals]    = StyleBuilder::Private::createOsmPOIStyle( osmFont, "individual/traffic_light" );
 
     m_defaultStyle[GeoDataFeature::PowerTower]               = StyleBuilder::Private::createOsmPOIStyle( osmFont, "individual/power_tower", QColor( "#888888" ) );
 
     m_defaultStyle[GeoDataFeature::BarrierCityWall]          = StyleBuilder::Private::createStyle( 6.0, 3.0, "#787878", "transparent", true, false, Qt::SolidPattern, Qt::SolidLine, Qt::FlatCap, false, QVector< qreal >(), QFont(), "transparent" );
     m_defaultStyle[GeoDataFeature::BarrierGate]              = StyleBuilder::Private::createOsmPOIStyle( osmFont, "individual/gate" );
     m_defaultStyle[GeoDataFeature::BarrierLiftGate]          = StyleBuilder::Private::createOsmPOIStyle( osmFont, "individual/liftgate" );
     m_defaultStyle[GeoDataFeature::BarrierWall]              = StyleBuilder::Private::createWayStyle( "#444444", Qt::transparent, true, false );
 
     m_defaultStyle[GeoDataFeature::HighwaySteps]             = StyleBuilder::Private::createStyle(0.0, 2.0, "#fa8072", QColor(Qt::white), true, true, Qt::SolidPattern, Qt::CustomDashLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
     m_defaultStyle[GeoDataFeature::HighwayUnknown]           = StyleBuilder::Private::createHighwayStyle( "highway_unknown", "#ddd", "#bbb", QFont(QStringLiteral("Arial")), "000000", 0.0, 1.0);
     m_defaultStyle[GeoDataFeature::HighwayPath]              = StyleBuilder::Private::createHighwayStyle( "highway_path", "#dddde8", "#999", QFont(QStringLiteral("Arial")), "000000", 0.0, 1.0, Qt::DotLine, Qt::SquareCap, true);
     m_defaultStyle[GeoDataFeature::HighwayTrack]             = StyleBuilder::Private::createHighwayStyle( "highway_track", "#996600", QColor(Qt::white), QFont(QStringLiteral("Arial")), "000000", 1.0, 1.0, Qt::DashLine, Qt::SquareCap, true );
     m_defaultStyle[GeoDataFeature::HighwayPedestrian]        = StyleBuilder::Private::createHighwayStyle( "highway_pedestrian", "#dddde8", "#999", QFont(QStringLiteral("Arial")), "000000", 0.0, 2.0);
     m_defaultStyle[GeoDataFeature::HighwayFootway]           = StyleBuilder::Private::createHighwayStyle( "highway_footway", "#fa8072", QColor(Qt::white), QFont(QStringLiteral("Arial")), "000000", 0.0, 2.0, Qt::DotLine, Qt::SquareCap, true);
     m_defaultStyle[GeoDataFeature::HighwayCycleway]          = StyleBuilder::Private::createHighwayStyle( "highway_cycleway", QColor(Qt::blue), QColor(Qt::white), QFont(QStringLiteral("Arial")), "000000", 0.0, 2.0, Qt::DotLine, Qt::SquareCap, true);
     m_defaultStyle[GeoDataFeature::HighwayService]           = StyleBuilder::Private::createHighwayStyle( "highway_service", "#ffffff", "#bbb", QFont(QStringLiteral("Arial")), "000000", 1.0, 6 );
     m_defaultStyle[GeoDataFeature::HighwayResidential]       = StyleBuilder::Private::createHighwayStyle( "highway_residential", "#ffffff", "#bbb", QFont(QStringLiteral("Arial")), "000000", 3, 6 );
     m_defaultStyle[GeoDataFeature::HighwayLivingStreet]      = StyleBuilder::Private::createHighwayStyle( "highway_living_street", "#ffffff", "#bbb", QFont(QStringLiteral("Arial")), "000000", 3, 6 );
     m_defaultStyle[GeoDataFeature::HighwayRoad]              = StyleBuilder::Private::createHighwayStyle( "highway_road", "#ddd", "#bbb", QFont(QStringLiteral("Arial")), "000000", 3, 6 );
     m_defaultStyle[GeoDataFeature::HighwayUnclassified]      = StyleBuilder::Private::createHighwayStyle( "highway_unclassified", "#ffffff", "#bbb", QFont(QStringLiteral("Arial")), "000000", 3, 6 );
     m_defaultStyle[GeoDataFeature::HighwayTertiary]          = StyleBuilder::Private::createHighwayStyle( "highway_tertiary", "#ffffff", "#8f8f8f", QFont(QStringLiteral("Arial")), "000000", 6.0, 6 );
     m_defaultStyle[GeoDataFeature::HighwayTertiaryLink]      = StyleBuilder::Private::createHighwayStyle( "highway_tertiary", "#ffffff", "#8f8f8f", QFont(QStringLiteral("Arial")), "000000", 6.0, 6 );
     m_defaultStyle[GeoDataFeature::HighwaySecondary]         = StyleBuilder::Private::createHighwayStyle( "highway_secondary", "#f7fabf", "#707d05", QFont(QStringLiteral("Arial")), "000000", 6.0, 6 );
     m_defaultStyle[GeoDataFeature::HighwaySecondaryLink]     = StyleBuilder::Private::createHighwayStyle( "highway_secondary", "#f7fabf", "#707d05", QFont(QStringLiteral("Arial")), "000000", 6.0, 6 );
     m_defaultStyle[GeoDataFeature::HighwayPrimary]           = StyleBuilder::Private::createHighwayStyle( "highway_primary", "#fcd6a4", "#a06b00", QFont(QStringLiteral("Arial")), "000000", 9.0, 6 );
     m_defaultStyle[GeoDataFeature::HighwayPrimaryLink]       = StyleBuilder::Private::createHighwayStyle( "highway_primary", "#fcd6a4", "#a06b00", QFont(QStringLiteral("Arial")), "000000", 6.0, 6 );
     m_defaultStyle[GeoDataFeature::HighwayTrunk]             = StyleBuilder::Private::createHighwayStyle( "highway_trunk", "#f9b29c", "#c84e2f", QFont(QStringLiteral("Arial")), "000000", 9.0, 6 );
     m_defaultStyle[GeoDataFeature::HighwayTrunkLink]         = StyleBuilder::Private::createHighwayStyle( "highway_trunk", "#f9b29c", "#c84e2f", QFont(QStringLiteral("Arial")), "000000", 9.0, 6 );
     m_defaultStyle[GeoDataFeature::HighwayMotorway]          = StyleBuilder::Private::createHighwayStyle( "highway_motorway", "#e892a2", "#dc2a67", QFont(QStringLiteral("Arial")), "000000", 9.0, 10 );
     m_defaultStyle[GeoDataFeature::HighwayMotorwayLink]      = StyleBuilder::Private::createHighwayStyle( "highway_motorway", "#e892a2", "#dc2a67", QFont(QStringLiteral("Arial")), "000000", 9.0, 10 );
 
     m_defaultStyle[GeoDataFeature::NaturalWater]             = StyleBuilder::Private::createStyle( 4, 0, waterColor, waterColor, true, true,
                                                                                                    Qt::SolidPattern, Qt::SolidLine, Qt::RoundCap, false, QVector< qreal >(),
                                                                                                    QFont(QStringLiteral("Arial")), waterColor.darker(150));
 
     m_defaultStyle[GeoDataFeature::NaturalReef]              = StyleBuilder::Private::createStyle( 5.5, 0, "#36677c", "#36677c", true, true,
                                                                                                    Qt::Dense7Pattern, Qt::DotLine, Qt::RoundCap, false, QVector< qreal >(),
                                                                                                    QFont(QStringLiteral("Arial")), waterColor.darker(150));
 
     m_defaultStyle[GeoDataFeature::AmenityGraveyard]         = StyleBuilder::Private::createWayStyle( "#AACBAF", "#AACBAF", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/grave_yard_generic.png") );
 
     m_defaultStyle[GeoDataFeature::NaturalWood]              = StyleBuilder::Private::createWayStyle( "#8DC46C", "#8DC46C", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/forest.png") );
     m_defaultStyle[GeoDataFeature::NaturalBeach]             = StyleBuilder::Private::createWayStyle( "#FFF1BA", "#FFF1BA", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/beach.png") );
     m_defaultStyle[GeoDataFeature::NaturalWetland]           = StyleBuilder::Private::createWayStyle( "#DDECEC", "#DDECEC", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/wetland.png") );
     m_defaultStyle[GeoDataFeature::NaturalGlacier]           = StyleBuilder::Private::createWayStyle( "#DDECEC", "#DDECEC", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/glacier.png") );
     m_defaultStyle[GeoDataFeature::NaturalIceShelf]           = StyleBuilder::Private::createWayStyle( "#8ebebe", "#8ebebe", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/glacier.png") );
     m_defaultStyle[GeoDataFeature::NaturalScrub]             = StyleBuilder::Private::createWayStyle( "#B5E3B5", "#B5E3B5", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/scrub.png") );
     m_defaultStyle[GeoDataFeature::NaturalCliff]             = StyleBuilder::Private::createWayStyle( Qt::transparent, Qt::transparent, true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/cliff2.png") );
     m_defaultStyle[GeoDataFeature::NaturalHeath]             = StyleBuilder::Private::createWayStyle( "#d6d99f", QColor("#d6d99f").darker(150), true, false );
 
     m_defaultStyle[GeoDataFeature::LeisureGolfCourse]        = StyleBuilder::Private::createWayStyle( QColor("#b5e3b5"), QColor("#b5e3b5").darker(150), true, true );
     m_defaultStyle[GeoDataFeature::LeisureMarina]            = StyleBuilder::Private::createOsmPOIStyle( osmFont, QString(), QColor("#95abd5"), QColor("#aec8d1"), QColor("#95abd5").darker(150) );
     m_defaultStyle[GeoDataFeature::LeisurePark]              = StyleBuilder::Private::createWayStyle( QColor("#c8facc"), QColor("#c8facc").darker(150), true, true );
     m_defaultStyle[GeoDataFeature::LeisurePlayground]        = StyleBuilder::Private::createOsmPOIStyle( osmFont, "amenity/playground.16", amenityColor, "#CCFFF1", "#BDFFED" );
     m_defaultStyle[GeoDataFeature::LeisurePitch]             = StyleBuilder::Private::createWayStyle( "#8ad3af", QColor("#8ad3af").darker(150), true, true );
     m_defaultStyle[GeoDataFeature::LeisureSportsCentre]      = StyleBuilder::Private::createWayStyle( "#33cc99", QColor("#33cc99").darker(150), true, true );
     m_defaultStyle[GeoDataFeature::LeisureStadium]           = StyleBuilder::Private::createWayStyle( "#33cc99", QColor("#33cc99").darker(150), true, true );
     m_defaultStyle[GeoDataFeature::LeisureTrack]             = StyleBuilder::Private::createWayStyle( "#74dcba", QColor("#74dcba").darker(150), true, true );
     m_defaultStyle[GeoDataFeature::LeisureSwimmingPool]      = StyleBuilder::Private::createWayStyle( waterColor, waterColor.darker(150), true, true );
 
     m_defaultStyle[GeoDataFeature::LanduseAllotments]        = StyleBuilder::Private::createWayStyle( "#E4C6AA", "#E4C6AA", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/allotments.png") );
     m_defaultStyle[GeoDataFeature::LanduseBasin]             = StyleBuilder::Private::createWayStyle( QColor(0xB5, 0xD0, 0xD0, 0x80 ), QColor( 0xB5, 0xD0, 0xD0 ) );
     m_defaultStyle[GeoDataFeature::LanduseCemetery]          = StyleBuilder::Private::createWayStyle( "#AACBAF", "#AACBAF", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/grave_yard_generic.png") );
     m_defaultStyle[GeoDataFeature::LanduseCommercial]        = StyleBuilder::Private::createWayStyle( "#F2DAD9", "#D1B2B0", true, true );
     m_defaultStyle[GeoDataFeature::LanduseConstruction]      = StyleBuilder::Private::createWayStyle( "#b6b592", "#b6b592", true, true );
     m_defaultStyle[GeoDataFeature::LanduseFarmland]          = StyleBuilder::Private::createWayStyle( "#EDDDC9", "#C8B69E", true, true );
     m_defaultStyle[GeoDataFeature::LanduseFarmyard]          = StyleBuilder::Private::createWayStyle( "#EFD6B5", "#D1B48C", true, true );
     m_defaultStyle[GeoDataFeature::LanduseGarages]           = StyleBuilder::Private::createWayStyle( "#E0DDCD", "#E0DDCD", true, true );
     m_defaultStyle[GeoDataFeature::LanduseGrass]             = StyleBuilder::Private::createWayStyle( "#A8C8A5", "#A8C8A5", true, true );
     m_defaultStyle[GeoDataFeature::LanduseIndustrial]        = StyleBuilder::Private::createWayStyle( "#DED0D5", "#DED0D5", true, true );
     m_defaultStyle[GeoDataFeature::LanduseLandfill]          = StyleBuilder::Private::createWayStyle( "#b6b592", "#b6b592", true, true );
     m_defaultStyle[GeoDataFeature::LanduseMeadow]            = StyleBuilder::Private::createWayStyle( "#cdebb0", "#cdebb0", true, true );
     m_defaultStyle[GeoDataFeature::LanduseMilitary]          = StyleBuilder::Private::createWayStyle( "#F3D8D2", "#F3D8D2", true, true, Qt::BDiagPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/military_red_hatch.png") );
     m_defaultStyle[GeoDataFeature::LanduseQuarry]            = StyleBuilder::Private::createWayStyle( "#C4C2C2", "#C4C2C2", true, true, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/quarry.png") );
     m_defaultStyle[GeoDataFeature::LanduseRailway]           = StyleBuilder::Private::createWayStyle( "#DED0D5", "#DED0D5", true, true );
     m_defaultStyle[GeoDataFeature::LanduseReservoir]         = StyleBuilder::Private::createWayStyle( waterColor, waterColor, true, true );
     m_defaultStyle[GeoDataFeature::LanduseResidential]       = StyleBuilder::Private::createWayStyle( "#DCDCDC", "#DCDCDC", true, true );
     m_defaultStyle[GeoDataFeature::LanduseRetail]            = StyleBuilder::Private::createWayStyle( "#FFD6D1", "#D99C95", true, true );
     m_defaultStyle[GeoDataFeature::LanduseOrchard]           = StyleBuilder::Private::createWayStyle( "#AEDFA3", "#AEDFA3", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/orchard.png") );
     m_defaultStyle[GeoDataFeature::LanduseVineyard]          = StyleBuilder::Private::createWayStyle( "#AEDFA3", "#AEDFA3", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/vineyard.png") );
 
     m_defaultStyle[GeoDataFeature::MilitaryDangerArea]       = StyleBuilder::Private::createWayStyle( "#FFC0CB", "#FFC0CB", true, false, Qt::SolidPattern, MarbleDirs::path("bitmaps/osmcarto/patterns/danger.png") );
 
     m_defaultStyle[GeoDataFeature::RailwayRail]              = StyleBuilder::Private::createStyle( 2.0, 1.435, "#706E70", "#EEEEEE", true, true, Qt::SolidPattern, Qt::CustomDashLine, Qt::FlatCap, true, QVector< qreal >() << 2 << 3 );
     m_defaultStyle[GeoDataFeature::RailwayNarrowGauge]       = StyleBuilder::Private::createStyle( 2.0, 1.0, "#706E70", "#EEEEEE", true, true, Qt::SolidPattern, Qt::CustomDashLine, Qt::FlatCap, true, QVector< qreal >() << 2 << 3 );
     // FIXME: the tram is currently being rendered as a polygon.
     m_defaultStyle[GeoDataFeature::RailwayTram]              = StyleBuilder::Private::createStyle( 2.0, 1.435, "#706E70", "#EEEEEE", false, true, Qt::SolidPattern, Qt::SolidLine, Qt::FlatCap, false );
     m_defaultStyle[GeoDataFeature::RailwayLightRail]         = StyleBuilder::Private::createStyle( 2.0, 1.435, "#706E70", "#EEEEEE", false, true, Qt::SolidPattern, Qt::SolidLine, Qt::FlatCap, false );
     m_defaultStyle[GeoDataFeature::RailwayAbandoned]         = StyleBuilder::Private::createStyle( 2.0, 1.435, Qt::transparent, "#706E70", false, false, Qt::SolidPattern, Qt::DotLine, Qt::FlatCap, false );
     m_defaultStyle[GeoDataFeature::RailwaySubway]            = StyleBuilder::Private::createStyle( 2.0, 1.435, "#706E70", "#EEEEEE", false, true, Qt::SolidPattern, Qt::SolidLine, Qt::FlatCap, false );
     m_defaultStyle[GeoDataFeature::RailwayPreserved]         = StyleBuilder::Private::createStyle( 2.0, 1.435, "#EEEEEE", "#706E70", true, true, Qt::SolidPattern, Qt::DotLine, Qt::FlatCap, true );
     m_defaultStyle[GeoDataFeature::RailwayMiniature]         = StyleBuilder::Private::createStyle( 2.0, 1.435, "#706E70", "#EEEEEE", false, true, Qt::SolidPattern, Qt::SolidLine, Qt::FlatCap, false );
     m_defaultStyle[GeoDataFeature::RailwayConstruction]      = StyleBuilder::Private::createStyle( 2.0, 1.435, "#EEEEEE", "#706E70", true, true, Qt::SolidPattern, Qt::DotLine, Qt::FlatCap, true );
     m_defaultStyle[GeoDataFeature::RailwayMonorail]          = StyleBuilder::Private::createStyle( 2.0, 1.435, "#706E70", "#EEEEEE", false, true, Qt::SolidPattern, Qt::SolidLine, Qt::FlatCap, false );
     m_defaultStyle[GeoDataFeature::RailwayFunicular]         = StyleBuilder::Private::createStyle( 2.0, 1.435, "#706E70", "#EEEEEE", false, true, Qt::SolidPattern, Qt::SolidLine, Qt::FlatCap, false );
 
     m_defaultStyle[GeoDataFeature::Building]                 = StyleBuilder::Private::createStyle( 1, 0, buildingColor, buildingColor.darker(),
                                                                                    true, true, Qt::SolidPattern, Qt::SolidLine, Qt::RoundCap, false );
 
     m_defaultStyle[GeoDataFeature::Landmass]                 = StyleBuilder::Private::createWayStyle( "#F1EEE8", "#F1EEE8", true, true );
     m_defaultStyle[GeoDataFeature::UrbanArea]                = StyleBuilder::Private::createWayStyle( "#E6E3DD", "#E6E3DD", true, true );
     m_defaultStyle[GeoDataFeature::InternationalDateLine]    = StyleBuilder::Private::createStyle( 1.0, 0.0, "#000000", "#000000", false, true, Qt::SolidPattern, Qt::SolidLine, Qt::FlatCap, false );
+    m_defaultStyle[GeoDataFeature::Bathymetry]               = StyleBuilder::Private::createWayStyle( "#a5c9c9", "#a5c9c9", true, true );
 
     m_defaultStyle[GeoDataFeature::AdminLevel1]              = StyleBuilder::Private::createStyle(0.0, 0.0, "#DF9CCF", "#DF9CCF", false, true, Qt::SolidPattern, Qt::CustomDashLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
     m_defaultStyle[GeoDataFeature::AdminLevel2]              = StyleBuilder::Private::createStyle(2.0, 0.0, "#DF9CCF", "#DF9CCF", false, true, Qt::SolidPattern, Qt::SolidLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
     m_defaultStyle[GeoDataFeature::AdminLevel3]              = StyleBuilder::Private::createStyle(1.8, 0.0, "#DF9CCF", "#DF9CCF", false, true, Qt::SolidPattern, Qt::DashLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
     m_defaultStyle[GeoDataFeature::AdminLevel4]              = StyleBuilder::Private::createStyle(1.5, 0.0, "#DF9CCF", "#DF9CCF", false, true, Qt::SolidPattern, Qt::DotLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
     m_defaultStyle[GeoDataFeature::AdminLevel5]              = StyleBuilder::Private::createStyle(1.25, 0.0, "#DF9CCF", "#DF9CCF", false, true, Qt::SolidPattern, Qt::DashDotDotLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
     m_defaultStyle[GeoDataFeature::AdminLevel6]              = StyleBuilder::Private::createStyle(1, 0.0, "#DF9CCF", "#DF9CCF", false, true, Qt::SolidPattern, Qt::DashDotLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
     m_defaultStyle[GeoDataFeature::AdminLevel7]              = StyleBuilder::Private::createStyle(1, 0.0, "#DF9CCF", "#DF9CCF", false, true, Qt::SolidPattern, Qt::DashLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
     m_defaultStyle[GeoDataFeature::AdminLevel8]              = StyleBuilder::Private::createStyle(1, 0.0, "#DF9CCF", "#DF9CCF", false, true, Qt::SolidPattern, Qt::DashLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
     m_defaultStyle[GeoDataFeature::AdminLevel9]              = StyleBuilder::Private::createStyle(1.5, 0.0, "#DF9CCF", "#DF9CCF", false, true, Qt::SolidPattern, Qt::DotLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
     m_defaultStyle[GeoDataFeature::AdminLevel10]             = StyleBuilder::Private::createStyle(1.5, 0.0, "#DF9CCF", "#DF9CCF", false, true, Qt::SolidPattern, Qt::DotLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
     m_defaultStyle[GeoDataFeature::AdminLevel11]             = StyleBuilder::Private::createStyle(1.5, 0.0, "#DF9CCF", "#DF9CCF", false, true, Qt::SolidPattern, Qt::DotLine, Qt::FlatCap, false, QVector< qreal >() << 0.3 << 0.3 );
 
     m_defaultStyle[GeoDataFeature::BoundaryMaritime]         = StyleBuilder::Private::createStyle(2.0, 0.0, "#88b3bf", "#88b3bf", false, true, Qt::SolidPattern, Qt::SolidLine, Qt::FlatCap, false );
 
     m_defaultStyle[GeoDataFeature::Satellite]
         = GeoDataStyle::Ptr(new GeoDataStyle( MarbleDirs::path( "bitmaps/satellite.png" ),
               QFont( defaultFamily, defaultSize, 50, false ), defaultLabelColor ));
 
     QFont tmp;
 
     // Fonts for areas ...
     tmp = m_defaultStyle[GeoDataFeature::Continent]->labelStyle().font();
     tmp.setLetterSpacing( QFont::AbsoluteSpacing, 2 );
     tmp.setCapitalization( QFont::AllUppercase );
     tmp.setBold( true );
     m_defaultStyle[GeoDataFeature::Continent]->labelStyle().setFont( tmp );
 
     // Fonts for areas ...
     tmp = m_defaultStyle[GeoDataFeature::Mare]->labelStyle().font();
     tmp.setLetterSpacing( QFont::AbsoluteSpacing, 2 );
     tmp.setCapitalization( QFont::AllUppercase );
     tmp.setBold( true );
     m_defaultStyle[GeoDataFeature::Mare]->labelStyle().setFont( tmp );
 
     // Now we need to underline the capitals ...
 
     tmp = m_defaultStyle[GeoDataFeature::SmallNationCapital]->labelStyle().font();
     tmp.setUnderline( true );
     m_defaultStyle[GeoDataFeature::SmallNationCapital]->labelStyle().setFont( tmp );
 
     tmp = m_defaultStyle[GeoDataFeature::MediumNationCapital]->labelStyle().font();
     tmp.setUnderline( true );
     m_defaultStyle[GeoDataFeature::MediumNationCapital]->labelStyle().setFont( tmp );
 
     tmp = m_defaultStyle[GeoDataFeature::BigNationCapital]->labelStyle().font();
     tmp.setUnderline( true );
     m_defaultStyle[GeoDataFeature::BigNationCapital]->labelStyle().setFont( tmp );
 
     tmp = m_defaultStyle[GeoDataFeature::LargeNationCapital]->labelStyle().font();
     tmp.setUnderline( true );
     m_defaultStyle[GeoDataFeature::LargeNationCapital]->labelStyle().setFont( tmp );
 }
 
 QString StyleBuilder::Private::createPaintLayerItem(const QString &itemType, GeoDataFeature::GeoDataVisualCategory visualCategory, const QString &subType)
 {
     QString const category = visualCategoryName(visualCategory);
     if (subType.isEmpty()) {
         return QString("%1/%2").arg(itemType).arg(category);
     } else {
         return QString("%1/%2/%3").arg(itemType).arg(category).arg(subType);
     }
 }
 
 
 StyleBuilder::StyleBuilder() :
     d(new Private)
 {
     // nothing to do
 }
 
 StyleBuilder::~StyleBuilder()
 {
     delete d;
 }
 
 QFont StyleBuilder::defaultFont() const
 {
     return d->m_defaultFont;
 }
 
 void StyleBuilder::setDefaultFont( const QFont& font )
 {
     d->m_defaultFont = font;
     reset();
 }
 
 QColor StyleBuilder::defaultLabelColor() const
 {
     return d->m_defaultLabelColor;
 }
 
 void StyleBuilder::setDefaultLabelColor( const QColor& color )
 {
     d->m_defaultLabelColor = color;
     reset();
 }
 
 GeoDataStyle::ConstPtr StyleBuilder::createStyle(const StyleParameters &parameters) const
 {
     if (!parameters.feature) {
         Q_ASSERT(false && "Must not pass a null feature to StyleBuilder::createStyle");
         return GeoDataStyle::Ptr();
     }
 
     if (parameters.feature->customStyle()) {
         return parameters.feature->customStyle();
     }
 
     auto const visualCategory = parameters.feature->visualCategory();
     GeoDataStyle::ConstPtr style = presetStyle(visualCategory);
     if (parameters.feature->nodeType() != GeoDataTypes::GeoDataPlacemarkType) {
         return style;
     }
 
     GeoDataPlacemark const * placemark = static_cast<GeoDataPlacemark const *>(parameters.feature);
     OsmPlacemarkData const & osmData = placemark->osmData();
     if (placemark->geometry()->nodeType() == GeoDataTypes::GeoDataPointType) {
         if (visualCategory == GeoDataFeature::NaturalTree) {
             GeoDataCoordinates const coordinates = placemark->coordinate();
             qreal const lat = coordinates.latitude(GeoDataCoordinates::Degree);
             if (qAbs(lat) > 15) {
                 /** @todo Should maybe auto-adjust to MarbleClock at some point */
                 int const month = QDate::currentDate().month();
                 QString season;
                 bool const southernHemisphere = lat < 0;
                 if (southernHemisphere) {
                     if (month >= 3 && month <= 5) {
                         season = "autumn";
                     } else if (month >= 6 && month <= 8) {
                         season = "winter";
                     }
                 } else {
                     if (month >= 9 && month <= 11) {
                         season = "autumn";
                     } else if (month == 12 || month == 1 || month == 2) {
                         season = "winter";
                     }
                 }
 
                 if (!season.isEmpty()) {
                     GeoDataIconStyle iconStyle = style->iconStyle();
                     QString const image = QString("svg/osmcarto/svg/individual/tree-29-%1.svg").arg(season);
                     iconStyle.setIconPath(MarbleDirs::path(image));
 
                     GeoDataStyle::Ptr newStyle(new GeoDataStyle(*style));
                     newStyle->setIconStyle(iconStyle);
                     style = newStyle;
                 }
             }
         }
     } else if (placemark->geometry()->nodeType() == GeoDataTypes::GeoDataLinearRingType) {
         bool adjustStyle = false;
 
         GeoDataPolyStyle polyStyle = style->polyStyle();
         GeoDataLineStyle lineStyle = style->lineStyle();
         if (visualCategory == GeoDataFeature::NaturalWater) {
             if( osmData.containsTag("salt","yes") ){
                 polyStyle.setColor("#ffff80");
                 lineStyle.setPenStyle(Qt::DashLine);
                 lineStyle.setWidth(2);
                 adjustStyle = true;
             }
         }
-        if(visualCategory == GeoDataFeature::AmenityGraveyard || visualCategory == GeoDataFeature::LanduseCemetery) {
+        else if (visualCategory == GeoDataFeature::Bathymetry) {
+            if( osmData.containsTagKey("depth") ){
+                // Style according to depth
+
+            }
+        }
+        else if(visualCategory == GeoDataFeature::AmenityGraveyard || visualCategory == GeoDataFeature::LanduseCemetery) {
             if( osmData.containsTag("religion","jewish") ){
                 polyStyle.setTexturePath(MarbleDirs::path("bitmaps/osmcarto/patterns/grave_yard_jewish.png"));
                 adjustStyle = true;
             } else if( osmData.containsTag("religion","christian") ){
                 polyStyle.setTexturePath(MarbleDirs::path("bitmaps/osmcarto/patterns/grave_yard_christian.png"));
                 adjustStyle = true;
             } else if( osmData.containsTag("religion","INT-generic") ){
                 polyStyle.setTexturePath(MarbleDirs::path("bitmaps/osmcarto/patterns/grave_yard_generic.png"));
                 adjustStyle = true;
             }
         }
         if (adjustStyle) {
             GeoDataStyle::Ptr newStyle(new GeoDataStyle(*style));
             newStyle->setPolyStyle(polyStyle);
             newStyle->setLineStyle(lineStyle);
             style = newStyle;
         }
 
         if (style->iconStyle().iconPath().isEmpty()) {
             for (auto iter = osmData.tagsBegin(), end = osmData.tagsEnd(); iter != end; ++iter) {
                 const QString keyValue = QString("%1=%2").arg(iter.key()).arg(iter.value());
                 const GeoDataFeature::GeoDataVisualCategory category = OsmPresetLibrary::osmVisualCategory(keyValue);
                 const GeoDataStyle::ConstPtr categoryStyle = presetStyle(category);
                 if (category != GeoDataFeature::None && !categoryStyle->iconStyle().icon().isNull()) {
                     GeoDataStyle::Ptr newStyle(new GeoDataStyle(*style));
                     newStyle->setIconStyle(categoryStyle->iconStyle());
                     style = newStyle;
                     break;
                 }
             }
         }
     } else if (placemark->geometry()->nodeType() == GeoDataTypes::GeoDataLineStringType) {
         GeoDataPolyStyle polyStyle = style->polyStyle();
         GeoDataLineStyle lineStyle = style->lineStyle();
         lineStyle.setCosmeticOutline(true);
 
         if(visualCategory == GeoDataFeature::AdminLevel2){
             if (osmData.containsTag("maritime", "yes") ) {
                 lineStyle.setColor("#88b3bf");
                 polyStyle.setColor("#88b3bf");
                 if( osmData.containsTag("marble:disputed", "yes") ){
                     lineStyle.setPenStyle( Qt::DashLine );
                 }
             }
         }
         else if (visualCategory >= GeoDataFeature::HighwayService &&
                 visualCategory <= GeoDataFeature::HighwayMotorway) {
 
             if (parameters.tileLevel >= 0 && parameters.tileLevel <= 7) {
                 /** @todo: Dummy implementation for dynamic style changes based on tile level, replace with sane values */
                 lineStyle.setPhysicalWidth(0.0);
                 lineStyle.setWidth(3.0);
             } else if (parameters.tileLevel >= 0 && parameters.tileLevel <= 9) {
                 /** @todo: Dummy implementation for dynamic style changes based on tile level, replace with sane values */
                 lineStyle.setPhysicalWidth(0.0);
                 lineStyle.setWidth(4.0);
             } else {
                 bool const isOneWay = osmData.containsTag("oneway", "yes") || osmData.containsTag("oneway", "-1");
                 int const lanes = isOneWay ? 1 : 2; // also for motorway which implicitly is one way, but has two lanes and each direction has its own highway
                 double const laneWidth = 3.0;
                 double const margins = visualCategory == GeoDataFeature::HighwayMotorway ? 2.0 : (isOneWay ? 1.0 : 0.0);
                 double const physicalWidth = margins + lanes * laneWidth;
                 lineStyle.setPhysicalWidth(physicalWidth);
             }
 
             QString const accessValue = osmData.tagValue("access");
             if (accessValue == "private" || accessValue == "no" || accessValue == "agricultural" || accessValue == "delivery" || accessValue == "forestry") {
                 QColor polyColor = polyStyle.color();
                 qreal hue, sat, val;
                 polyColor.getHsvF(&hue, &sat, &val);
                 polyColor.setHsvF(0.98, qMin(1.0, 0.2 + sat), val);
                 polyStyle.setColor(polyColor);
                 lineStyle.setColor(lineStyle.color().darker(150));
             }
 
             if (osmData.containsTag("tunnel", "yes") ) {
                 QColor polyColor = polyStyle.color();
                 qreal hue, sat, val;
                 polyColor.getHsvF(&hue, &sat, &val);
                 polyColor.setHsvF(hue, 0.25 * sat, 0.95 * val);
                 polyStyle.setColor(polyColor);
                 lineStyle.setColor(lineStyle.color().lighter(115));
             }
 
         } else if (visualCategory == GeoDataFeature::NaturalWater) {
             if (parameters.tileLevel >= 0 && parameters.tileLevel <= 7) {
                 lineStyle.setWidth(parameters.tileLevel <= 3 ? 1 : 2);
                 lineStyle.setPhysicalWidth(0.0);
             } else {
                 QString const widthValue = osmData.tagValue("width").remove(QStringLiteral(" meters")).remove(QStringLiteral(" m"));
                 bool ok;
                 float const width = widthValue.toFloat(&ok);
                 lineStyle.setPhysicalWidth(ok ? qBound(0.1f, width, 200.0f) : 0.0f);
             }
         }
         GeoDataStyle::Ptr newStyle(new GeoDataStyle(*style));
         newStyle->setPolyStyle(polyStyle);
         newStyle->setLineStyle(lineStyle);
 
         bool const hideLabel = visualCategory == GeoDataFeature::HighwayTrack
                 || (visualCategory >= GeoDataFeature::RailwayRail && visualCategory <= GeoDataFeature::RailwayFunicular);
         if (hideLabel) {
             newStyle->labelStyle().setColor(QColor(Qt::transparent));
         }
 
         style = newStyle;
     }
 
     return style;
 }
 
 GeoDataStyle::ConstPtr StyleBuilder::presetStyle(GeoDataFeature::GeoDataVisualCategory visualCategory) const
 {
     if (!d->m_defaultStyleInitialized) {
         d->initializeDefaultStyles();
     }
 
     if (visualCategory != GeoDataFeature::None && d->m_defaultStyle[visualCategory] ) {
         return d->m_defaultStyle[visualCategory];
     } else {
         return d->m_defaultStyle[GeoDataFeature::Default];
     }
 }
 
 
 QStringList StyleBuilder::renderOrder() const
 {
     static QStringList paintLayerOrder;
 
     if (paintLayerOrder.isEmpty()) {
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::Landmass);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::UrbanArea);
         for ( int i = GeoDataFeature::LanduseAllotments; i <= GeoDataFeature::LanduseVineyard; i++ ) {
             if ((GeoDataFeature::GeoDataVisualCategory)i != GeoDataFeature::LanduseGrass) {
                 paintLayerOrder << Private::createPaintLayerItem("Polygon", (GeoDataFeature::GeoDataVisualCategory)i);
             }
         }
+        paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::Bathymetry);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::NaturalBeach);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::NaturalWetland);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::NaturalGlacier);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::NaturalIceShelf);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::NaturalCliff);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::NaturalPeak);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::MilitaryDangerArea);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::LeisurePark);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::LeisurePitch);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::LeisureSportsCentre);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::LeisureStadium);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::NaturalWood);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::LanduseGrass);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::LeisurePlayground);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::NaturalScrub);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::LeisureTrack);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::TransportParking);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::TransportParkingSpace);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::ManmadeBridge);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::BarrierCityWall);
 
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::AmenityGraveyard);
 
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::AmenityKindergarten);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::EducationCollege);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::EducationSchool);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::EducationUniversity);
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::HealthHospital);
 
         paintLayerOrder << Private::createPaintLayerItem("LineString", GeoDataFeature::Landmass);
 
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::NaturalWater);
         paintLayerOrder << Private::createPaintLayerItem("LineString", GeoDataFeature::NaturalWater, "outline");
         paintLayerOrder << Private::createPaintLayerItem("LineString", GeoDataFeature::NaturalWater, "inline");
         paintLayerOrder << Private::createPaintLayerItem("LineString", GeoDataFeature::NaturalWater, "label");
 
 
         paintLayerOrder << Private::createPaintLayerItem("LineString", GeoDataFeature::NaturalReef, "outline");
         paintLayerOrder << Private::createPaintLayerItem("LineString", GeoDataFeature::NaturalReef, "inline");
         paintLayerOrder << Private::createPaintLayerItem("LineString", GeoDataFeature::NaturalReef, "label");
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::LeisureMarina);
 
 
         for ( int i = GeoDataFeature::HighwaySteps; i <= GeoDataFeature::HighwayMotorway; i++ ) {
             paintLayerOrder << Private::createPaintLayerItem("LineString", (GeoDataFeature::GeoDataVisualCategory)i, "outline");
         }
         for ( int i = GeoDataFeature::HighwaySteps; i <= GeoDataFeature::HighwayMotorway; i++ ) {
             paintLayerOrder << Private::createPaintLayerItem("LineString", (GeoDataFeature::GeoDataVisualCategory)i, "inline");
         }
         for ( int i = GeoDataFeature::HighwaySteps; i <= GeoDataFeature::HighwayMotorway; i++ ) {
             paintLayerOrder << Private::createPaintLayerItem("LineString", (GeoDataFeature::GeoDataVisualCategory)i, "label");
         }
         for ( int i = GeoDataFeature::RailwayRail; i <= GeoDataFeature::RailwayFunicular; i++ ) {
             paintLayerOrder << Private::createPaintLayerItem("LineString", (GeoDataFeature::GeoDataVisualCategory)i, "outline");
         }
         for ( int i = GeoDataFeature::RailwayRail; i <= GeoDataFeature::RailwayFunicular; i++ ) {
             paintLayerOrder << Private::createPaintLayerItem("LineString", (GeoDataFeature::GeoDataVisualCategory)i, "inline");
         }
         for ( int i = GeoDataFeature::RailwayRail; i <= GeoDataFeature::RailwayFunicular; i++ ) {
             paintLayerOrder << Private::createPaintLayerItem("LineString", (GeoDataFeature::GeoDataVisualCategory)i, "label");
         }
 
         paintLayerOrder << Private::createPaintLayerItem("Polygon", GeoDataFeature::TransportPlatform);
 
         for ( int i = GeoDataFeature::AdminLevel1; i <= GeoDataFeature::AdminLevel11; i++ ) {
             paintLayerOrder << Private::createPaintLayerItem("LineString", (GeoDataFeature::GeoDataVisualCategory)i, "outline");
         }
         for ( int i = GeoDataFeature::AdminLevel1; i <= GeoDataFeature::AdminLevel11; i++ ) {
             paintLayerOrder << Private::createPaintLayerItem("LineString", (GeoDataFeature::GeoDataVisualCategory)i, "inline");
         }
         for ( int i = GeoDataFeature::AdminLevel1; i <= GeoDataFeature::AdminLevel11; i++ ) {
             paintLayerOrder << Private::createPaintLayerItem("LineString", (GeoDataFeature::GeoDataVisualCategory)i, "label");
         }
-
+        paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::Bathymetry);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::AmenityGraveyard);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::NaturalWood);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::NaturalBeach);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::NaturalWetland);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::NaturalGlacier);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::NaturalIceShelf);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::NaturalScrub);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::LeisureMarina);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::LeisurePark);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::LeisurePlayground);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::LeisurePitch);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::LeisureSportsCentre);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::LeisureStadium);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::LeisureTrack);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::TransportParking);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::ManmadeBridge);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::BarrierCityWall);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::NaturalWater);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::NaturalReef);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::Landmass);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::NaturalCliff);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::NaturalPeak);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::AmenityKindergarten);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::EducationCollege);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::EducationSchool);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::EducationUniversity);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::HealthHospital);
         paintLayerOrder << Private::createPaintLayerItem("Point", GeoDataFeature::MilitaryDangerArea);
 
         paintLayerOrder << "Polygon/Building/frame";
         paintLayerOrder << "Polygon/Building/roof";
 
         Q_ASSERT(QSet<QString>::fromList(paintLayerOrder).size() == paintLayerOrder.size());
     }
 
     return paintLayerOrder;
 }
 
 void StyleBuilder::reset()
 {
     d->m_defaultStyleInitialized = false;
 }
 
 int StyleBuilder::minimumZoomLevel(GeoDataFeature::GeoDataVisualCategory category) const
 {
     return d->m_defaultMinZoomLevels[category];
 }
 
 int StyleBuilder::maximumZoomLevel() const
 {
     return d->m_maximumZoomLevel;
 }
 
 QString StyleBuilder::visualCategoryName(GeoDataFeature::GeoDataVisualCategory category)
 {
     static QHash<GeoDataFeature::GeoDataVisualCategory, QString> visualCategoryNames;
 
     if (visualCategoryNames.isEmpty()) {
         visualCategoryNames[GeoDataFeature::GeoDataFeature::None] = "None";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Default] = "Default";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Unknown] = "Unknown";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::SmallCity] = "SmallCity";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::SmallCountyCapital] = "SmallCountyCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::SmallStateCapital] = "SmallStateCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::SmallNationCapital] = "SmallNationCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::MediumCity] = "MediumCity";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::MediumCountyCapital] = "MediumCountyCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::MediumStateCapital] = "MediumStateCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::MediumNationCapital] = "MediumNationCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::BigCity] = "BigCity";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::BigCountyCapital] = "BigCountyCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::BigStateCapital] = "BigStateCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::BigNationCapital] = "BigNationCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::LargeCity] = "LargeCity";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::LargeCountyCapital] = "LargeCountyCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::LargeStateCapital] = "LargeStateCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::LargeNationCapital] = "LargeNationCapital";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Nation] = "Nation";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::PlaceCity] = "PlaceCity";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::PlaceSuburb] = "PlaceSuburb";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::PlaceHamlet] = "PlaceHamlet";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::PlaceLocality] = "PlaceLocality";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::PlaceTown] = "PlaceTown";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::PlaceVillage] = "PlaceVillage";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Mountain] = "Mountain";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Volcano] = "Volcano";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Mons] = "Mons";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Valley] = "Valley";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Continent] = "Continent";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Ocean] = "Ocean";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::OtherTerrain] = "OtherTerrain";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Crater] = "Crater";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Mare] = "Mare";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::GeographicPole] = "GeographicPole";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::MagneticPole] = "MagneticPole";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::ShipWreck] = "ShipWreck";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::AirPort] = "AirPort";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::Observatory] = "Observatory";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::MilitaryDangerArea] = "MilitaryDangerArea";
         visualCategoryNames[GeoDataFeature::GeoDataFeature::OsmSite] = "OsmSite";
         visualCategoryNames[GeoDataFeature::Coordinate] = "Coordinate";
         visualCategoryNames[GeoDataFeature::MannedLandingSite] = "MannedLandingSite";
         visualCategoryNames[GeoDataFeature::RoboticRover] = "RoboticRover";
         visualCategoryNames[GeoDataFeature::UnmannedSoftLandingSite] = "UnmannedSoftLandingSite";
         visualCategoryNames[GeoDataFeature::UnmannedHardLandingSite] = "UnmannedHardLandingSite";
         visualCategoryNames[GeoDataFeature::Folder] = "Folder";
         visualCategoryNames[GeoDataFeature::Bookmark] = "Bookmark";
         visualCategoryNames[GeoDataFeature::NaturalWater] = "NaturalWater";
         visualCategoryNames[GeoDataFeature::NaturalReef] = "NaturalReef";
         visualCategoryNames[GeoDataFeature::NaturalWood] = "NaturalWood";
         visualCategoryNames[GeoDataFeature::NaturalBeach] = "NaturalBeach";
         visualCategoryNames[GeoDataFeature::NaturalWetland] = "NaturalWetland";
         visualCategoryNames[GeoDataFeature::NaturalGlacier] = "NaturalGlacier";
         visualCategoryNames[GeoDataFeature::NaturalIceShelf] = "NaturalIceShelf";
         visualCategoryNames[GeoDataFeature::NaturalScrub] = "NaturalScrub";
         visualCategoryNames[GeoDataFeature::NaturalCliff] = "NaturalCliff";
         visualCategoryNames[GeoDataFeature::NaturalHeath] = "NaturalHeath";
         visualCategoryNames[GeoDataFeature::HighwayTrafficSignals] = "HighwayTrafficSignals";
         visualCategoryNames[GeoDataFeature::HighwaySteps] = "HighwaySteps";
         visualCategoryNames[GeoDataFeature::HighwayUnknown] = "HighwayUnknown";
         visualCategoryNames[GeoDataFeature::HighwayPath] = "HighwayPath";
         visualCategoryNames[GeoDataFeature::HighwayFootway] = "HighwayFootway";
         visualCategoryNames[GeoDataFeature::HighwayTrack] = "HighwayTrack";
         visualCategoryNames[GeoDataFeature::HighwayPedestrian] = "HighwayPedestrian";
         visualCategoryNames[GeoDataFeature::HighwayCycleway] = "HighwayCycleway";
         visualCategoryNames[GeoDataFeature::HighwayService] = "HighwayService";
         visualCategoryNames[GeoDataFeature::HighwayRoad] = "HighwayRoad";
         visualCategoryNames[GeoDataFeature::HighwayResidential] = "HighwayResidential";
         visualCategoryNames[GeoDataFeature::HighwayLivingStreet] = "HighwayLivingStreet";
         visualCategoryNames[GeoDataFeature::HighwayUnclassified] = "HighwayUnclassified";
         visualCategoryNames[GeoDataFeature::HighwayTertiaryLink] = "HighwayTertiaryLink";
         visualCategoryNames[GeoDataFeature::HighwayTertiary] = "HighwayTertiary";
         visualCategoryNames[GeoDataFeature::HighwaySecondaryLink] = "HighwaySecondaryLink";
         visualCategoryNames[GeoDataFeature::HighwaySecondary] = "HighwaySecondary";
         visualCategoryNames[GeoDataFeature::HighwayPrimaryLink] = "HighwayPrimaryLink";
         visualCategoryNames[GeoDataFeature::HighwayPrimary] = "HighwayPrimary";
         visualCategoryNames[GeoDataFeature::HighwayTrunkLink] = "HighwayTrunkLink";
         visualCategoryNames[GeoDataFeature::HighwayTrunk] = "HighwayTrunk";
         visualCategoryNames[GeoDataFeature::HighwayMotorwayLink] = "HighwayMotorwayLink";
         visualCategoryNames[GeoDataFeature::HighwayMotorway] = "HighwayMotorway";
         visualCategoryNames[GeoDataFeature::Building] = "Building";
         visualCategoryNames[GeoDataFeature::AccomodationCamping] = "AccomodationCamping";
         visualCategoryNames[GeoDataFeature::AccomodationHostel] = "AccomodationHostel";
         visualCategoryNames[GeoDataFeature::AccomodationHotel] = "AccomodationHotel";
         visualCategoryNames[GeoDataFeature::AccomodationMotel] = "AccomodationMotel";
         visualCategoryNames[GeoDataFeature::AccomodationYouthHostel] = "AccomodationYouthHostel";
         visualCategoryNames[GeoDataFeature::AccomodationGuestHouse] = "AccomodationGuestHouse";
         visualCategoryNames[GeoDataFeature::AmenityLibrary] = "AmenityLibrary";
         visualCategoryNames[GeoDataFeature::AmenityKindergarten] = "AmenityKindergarten";
         visualCategoryNames[GeoDataFeature::EducationCollege] = "EducationCollege";
         visualCategoryNames[GeoDataFeature::EducationSchool] = "EducationSchool";
         visualCategoryNames[GeoDataFeature::EducationUniversity] = "EducationUniversity";
         visualCategoryNames[GeoDataFeature::FoodBar] = "FoodBar";
         visualCategoryNames[GeoDataFeature::FoodBiergarten] = "FoodBiergarten";
         visualCategoryNames[GeoDataFeature::FoodCafe] = "FoodCafe";
         visualCategoryNames[GeoDataFeature::FoodFastFood] = "FoodFastFood";
         visualCategoryNames[GeoDataFeature::FoodPub] = "FoodPub";
         visualCategoryNames[GeoDataFeature::FoodRestaurant] = "FoodRestaurant";
         visualCategoryNames[GeoDataFeature::HealthDentist] = "HealthDentist";
         visualCategoryNames[GeoDataFeature::HealthDoctors] = "HealthDoctors";
         visualCategoryNames[GeoDataFeature::HealthHospital] = "HealthHospital";
         visualCategoryNames[GeoDataFeature::HealthPharmacy] = "HealthPharmacy";
         visualCategoryNames[GeoDataFeature::HealthVeterinary] = "HealthVeterinary";
         visualCategoryNames[GeoDataFeature::MoneyAtm] = "MoneyAtm";
         visualCategoryNames[GeoDataFeature::MoneyBank] = "MoneyBank";
         visualCategoryNames[GeoDataFeature::AmenityArchaeologicalSite] = "AmenityArchaeologicalSite";
         visualCategoryNames[GeoDataFeature::AmenityEmbassy] = "AmenityEmbassy";
         visualCategoryNames[GeoDataFeature::AmenityEmergencyPhone] = "AmenityEmergencyPhone";
         visualCategoryNames[GeoDataFeature::AmenityWaterPark] = "AmenityWaterPark";
         visualCategoryNames[GeoDataFeature::AmenityCommunityCentre] = "AmenityCommunityCentre";
         visualCategoryNames[GeoDataFeature::AmenityFountain] = "AmenityFountain";
         visualCategoryNames[GeoDataFeature::AmenityNightClub] = "AmenityNightClub";
         visualCategoryNames[GeoDataFeature::AmenityBench] = "AmenityBench";
         visualCategoryNames[GeoDataFeature::AmenityCourtHouse] = "AmenityCourtHouse";
         visualCategoryNames[GeoDataFeature::AmenityFireStation] = "AmenityFireStation";
         visualCategoryNames[GeoDataFeature::AmenityHuntingStand] = "AmenityHuntingStand";
         visualCategoryNames[GeoDataFeature::AmenityPolice] = "AmenityPolice";
         visualCategoryNames[GeoDataFeature::AmenityPostBox] = "AmenityPostBox";
         visualCategoryNames[GeoDataFeature::AmenityPostOffice] = "AmenityPostOffice";
         visualCategoryNames[GeoDataFeature::AmenityPrison] = "AmenityPrison";
         visualCategoryNames[GeoDataFeature::AmenityRecycling] = "AmenityRecycling";
         visualCategoryNames[GeoDataFeature::AmenityTelephone] = "AmenityTelephone";
         visualCategoryNames[GeoDataFeature::AmenityToilets] = "AmenityToilets";
         visualCategoryNames[GeoDataFeature::AmenityTownHall] = "AmenityTownHall";
         visualCategoryNames[GeoDataFeature::AmenityWasteBasket] = "AmenityWasteBasket";
         visualCategoryNames[GeoDataFeature::AmenityDrinkingWater] = "AmenityDrinkingWater";
         visualCategoryNames[GeoDataFeature::AmenityGraveyard] = "AmenityGraveyard";
         visualCategoryNames[GeoDataFeature::BarrierCityWall] = "BarrierCityWall";
         visualCategoryNames[GeoDataFeature::BarrierGate] = "BarrierGate";
         visualCategoryNames[GeoDataFeature::BarrierLiftGate] = "BarrierLiftGate";
         visualCategoryNames[GeoDataFeature::BarrierWall] = "BarrierWall";
         visualCategoryNames[GeoDataFeature::NaturalPeak] = "NaturalPeak";
         visualCategoryNames[GeoDataFeature::NaturalTree] = "NaturalTree";
         visualCategoryNames[GeoDataFeature::ShopBeverages] = "ShopBeverages";
         visualCategoryNames[GeoDataFeature::ShopHifi] = "ShopHifi";
         visualCategoryNames[GeoDataFeature::ShopSupermarket] = "ShopSupermarket";
         visualCategoryNames[GeoDataFeature::ShopAlcohol] = "ShopAlcohol";
         visualCategoryNames[GeoDataFeature::ShopBakery] = "ShopBakery";
         visualCategoryNames[GeoDataFeature::ShopButcher] = "ShopButcher";
         visualCategoryNames[GeoDataFeature::ShopConfectionery] = "ShopConfectionery";
         visualCategoryNames[GeoDataFeature::ShopConvenience] = "ShopConvenience";
         visualCategoryNames[GeoDataFeature::ShopGreengrocer] = "ShopGreengrocer";
         visualCategoryNames[GeoDataFeature::ShopSeafood] = "ShopSeafood";
         visualCategoryNames[GeoDataFeature::ShopDepartmentStore] = "ShopDepartmentStore";
         visualCategoryNames[GeoDataFeature::ShopKiosk] = "ShopKiosk";
         visualCategoryNames[GeoDataFeature::ShopBag] = "ShopBag";
         visualCategoryNames[GeoDataFeature::ShopClothes] = "ShopClothes";
         visualCategoryNames[GeoDataFeature::ShopFashion] = "ShopFashion";
         visualCategoryNames[GeoDataFeature::ShopJewelry] = "ShopJewelry";
         visualCategoryNames[GeoDataFeature::ShopShoes] = "ShopShoes";
         visualCategoryNames[GeoDataFeature::ShopVarietyStore] = "ShopVarietyStore";
         visualCategoryNames[GeoDataFeature::ShopBeauty] = "ShopBeauty";
         visualCategoryNames[GeoDataFeature::ShopChemist] = "ShopChemist";
         visualCategoryNames[GeoDataFeature::ShopCosmetics] = "ShopCosmetics";
         visualCategoryNames[GeoDataFeature::ShopHairdresser] = "ShopHairdresser";
         visualCategoryNames[GeoDataFeature::ShopOptician] = "ShopOptician";
         visualCategoryNames[GeoDataFeature::ShopPerfumery] = "ShopPerfumery";
         visualCategoryNames[GeoDataFeature::ShopDoitYourself] = "ShopDoitYourself";
         visualCategoryNames[GeoDataFeature::ShopFlorist] = "ShopFlorist";
         visualCategoryNames[GeoDataFeature::ShopHardware] = "ShopHardware";
         visualCategoryNames[GeoDataFeature::ShopFurniture] = "ShopFurniture";
         visualCategoryNames[GeoDataFeature::ShopElectronics] = "ShopElectronics";
         visualCategoryNames[GeoDataFeature::ShopMobilePhone] = "ShopMobilePhone";
         visualCategoryNames[GeoDataFeature::ShopBicycle] = "ShopBicycle";
         visualCategoryNames[GeoDataFeature::ShopCar] = "ShopCar";
         visualCategoryNames[GeoDataFeature::ShopCarRepair] = "ShopCarRepair";
         visualCategoryNames[GeoDataFeature::ShopCarParts] = "ShopCarParts";
         visualCategoryNames[GeoDataFeature::ShopMotorcycle] = "ShopMotorcycle";
         visualCategoryNames[GeoDataFeature::ShopOutdoor] = "ShopOutdoor";
         visualCategoryNames[GeoDataFeature::ShopMusicalInstrument] = "ShopMusicalInstrument";
         visualCategoryNames[GeoDataFeature::ShopPhoto] = "ShopPhoto";
         visualCategoryNames[GeoDataFeature::ShopBook] = "ShopBook";
         visualCategoryNames[GeoDataFeature::ShopGift] = "ShopGift";
         visualCategoryNames[GeoDataFeature::ShopStationery] = "ShopStationery";
         visualCategoryNames[GeoDataFeature::ShopLaundry] = "ShopLaundry";
         visualCategoryNames[GeoDataFeature::ShopPet] = "ShopPet";
         visualCategoryNames[GeoDataFeature::ShopToys] = "ShopToys";
         visualCategoryNames[GeoDataFeature::ShopTravelAgency] = "ShopTravelAgency";
         visualCategoryNames[GeoDataFeature::Shop] = "Shop";
         visualCategoryNames[GeoDataFeature::ManmadeBridge] = "ManmadeBridge";
         visualCategoryNames[GeoDataFeature::ManmadeLighthouse] = "ManmadeLighthouse";
         visualCategoryNames[GeoDataFeature::ManmadePier] = "ManmadePier";
         visualCategoryNames[GeoDataFeature::ManmadeWaterTower] = "ManmadeWaterTower";
         visualCategoryNames[GeoDataFeature::ManmadeWindMill] = "ManmadeWindMill";
         visualCategoryNames[GeoDataFeature::TouristAttraction] = "TouristAttraction";
         visualCategoryNames[GeoDataFeature::TouristCastle] = "TouristCastle";
         visualCategoryNames[GeoDataFeature::TouristCinema] = "TouristCinema";
         visualCategoryNames[GeoDataFeature::TouristInformation] = "TouristInformation";
         visualCategoryNames[GeoDataFeature::TouristMonument] = "TouristMonument";
         visualCategoryNames[GeoDataFeature::TouristMuseum] = "TouristMuseum";
         visualCategoryNames[GeoDataFeature::TouristRuin] = "TouristRuin";
         visualCategoryNames[GeoDataFeature::TouristTheatre] = "TouristTheatre";
         visualCategoryNames[GeoDataFeature::TouristThemePark] = "TouristThemePark";
         visualCategoryNames[GeoDataFeature::TouristViewPoint] = "TouristViewPoint";
         visualCategoryNames[GeoDataFeature::TouristZoo] = "TouristZoo";
         visualCategoryNames[GeoDataFeature::TouristAlpineHut] = "TouristAlpineHut";
         visualCategoryNames[GeoDataFeature::TransportAerodrome] = "TransportAerodrome";
         visualCategoryNames[GeoDataFeature::TransportHelipad] = "TransportHelipad";
         visualCategoryNames[GeoDataFeature::TransportAirportTerminal] = "TransportAirportTerminal";
         visualCategoryNames[GeoDataFeature::TransportBusStation] = "TransportBusStation";
         visualCategoryNames[GeoDataFeature::TransportBusStop] = "TransportBusStop";
         visualCategoryNames[GeoDataFeature::TransportCarShare] = "TransportCarShare";
         visualCategoryNames[GeoDataFeature::TransportFuel] = "TransportFuel";
         visualCategoryNames[GeoDataFeature::TransportParking] = "TransportParking";
         visualCategoryNames[GeoDataFeature::TransportParkingSpace] = "TransportParkingSpace";
         visualCategoryNames[GeoDataFeature::TransportPlatform] = "TransportPlatform";
         visualCategoryNames[GeoDataFeature::TransportRentalBicycle] = "TransportRentalBicycle";
         visualCategoryNames[GeoDataFeature::TransportRentalCar] = "TransportRentalCar";
         visualCategoryNames[GeoDataFeature::TransportTaxiRank] = "TransportTaxiRank";
         visualCategoryNames[GeoDataFeature::TransportTrainStation] = "TransportTrainStation";
         visualCategoryNames[GeoDataFeature::TransportTramStop] = "TransportTramStop";
         visualCategoryNames[GeoDataFeature::TransportBicycleParking] = "TransportBicycleParking";
         visualCategoryNames[GeoDataFeature::TransportMotorcycleParking] = "TransportMotorcycleParking";
         visualCategoryNames[GeoDataFeature::TransportSubwayEntrance] = "TransportSubwayEntrance";
         visualCategoryNames[GeoDataFeature::ReligionPlaceOfWorship] = "ReligionPlaceOfWorship";
         visualCategoryNames[GeoDataFeature::ReligionBahai] = "ReligionBahai";
         visualCategoryNames[GeoDataFeature::ReligionBuddhist] = "ReligionBuddhist";
         visualCategoryNames[GeoDataFeature::ReligionChristian] = "ReligionChristian";
         visualCategoryNames[GeoDataFeature::ReligionMuslim] = "ReligionMuslim";
         visualCategoryNames[GeoDataFeature::ReligionHindu] = "ReligionHindu";
         visualCategoryNames[GeoDataFeature::ReligionJain] = "ReligionJain";
         visualCategoryNames[GeoDataFeature::ReligionJewish] = "ReligionJewish";
         visualCategoryNames[GeoDataFeature::ReligionShinto] = "ReligionShinto";
         visualCategoryNames[GeoDataFeature::ReligionSikh] = "ReligionSikh";
         visualCategoryNames[GeoDataFeature::LeisureGolfCourse] = "LeisureGolfCourse";
         visualCategoryNames[GeoDataFeature::LeisureMarina] = "LeisureMarina";
         visualCategoryNames[GeoDataFeature::LeisurePark] = "LeisurePark";
         visualCategoryNames[GeoDataFeature::LeisurePlayground] = "LeisurePlayground";
         visualCategoryNames[GeoDataFeature::LeisurePitch] = "LeisurePitch";
         visualCategoryNames[GeoDataFeature::LeisureSportsCentre] = "LeisureSportsCentre";
         visualCategoryNames[GeoDataFeature::LeisureStadium] = "LeisureStadium";
         visualCategoryNames[GeoDataFeature::LeisureTrack] = "LeisureTrack";
         visualCategoryNames[GeoDataFeature::LeisureSwimmingPool] = "LeisureSwimmingPool";
         visualCategoryNames[GeoDataFeature::LanduseAllotments] = "LanduseAllotments";
         visualCategoryNames[GeoDataFeature::LanduseBasin] = "LanduseBasin";
         visualCategoryNames[GeoDataFeature::LanduseCemetery] = "LanduseCemetery";
         visualCategoryNames[GeoDataFeature::LanduseCommercial] = "LanduseCommercial";
         visualCategoryNames[GeoDataFeature::LanduseConstruction] = "LanduseConstruction";
         visualCategoryNames[GeoDataFeature::LanduseFarmland] = "LanduseFarmland";
         visualCategoryNames[GeoDataFeature::LanduseFarmyard] = "LanduseFarmyard";
         visualCategoryNames[GeoDataFeature::LanduseGarages] = "LanduseGarages";
         visualCategoryNames[GeoDataFeature::LanduseGrass] = "LanduseGrass";
         visualCategoryNames[GeoDataFeature::LanduseIndustrial] = "LanduseIndustrial";
         visualCategoryNames[GeoDataFeature::LanduseLandfill] = "LanduseLandfill";
         visualCategoryNames[GeoDataFeature::LanduseMeadow] = "LanduseMeadow";
         visualCategoryNames[GeoDataFeature::LanduseMilitary] = "LanduseMilitary";
         visualCategoryNames[GeoDataFeature::LanduseQuarry] = "LanduseQuarry";
         visualCategoryNames[GeoDataFeature::LanduseRailway] = "LanduseRailway";
         visualCategoryNames[GeoDataFeature::LanduseReservoir] = "LanduseReservoir";
         visualCategoryNames[GeoDataFeature::LanduseResidential] = "LanduseResidential";
         visualCategoryNames[GeoDataFeature::LanduseRetail] = "LanduseRetail";
         visualCategoryNames[GeoDataFeature::LanduseOrchard] = "LanduseOrchard";
         visualCategoryNames[GeoDataFeature::LanduseVineyard] = "LanduseVineyard";
         visualCategoryNames[GeoDataFeature::RailwayRail] = "RailwayRail";
         visualCategoryNames[GeoDataFeature::RailwayNarrowGauge] = "RailwayNarrowGauge";
         visualCategoryNames[GeoDataFeature::RailwayTram] = "RailwayTram";
         visualCategoryNames[GeoDataFeature::RailwayLightRail] = "RailwayLightRail";
         visualCategoryNames[GeoDataFeature::RailwayAbandoned] = "RailwayAbandoned";
         visualCategoryNames[GeoDataFeature::RailwaySubway] = "RailwaySubway";
         visualCategoryNames[GeoDataFeature::RailwayPreserved] = "RailwayPreserved";
         visualCategoryNames[GeoDataFeature::RailwayMiniature] = "RailwayMiniature";
         visualCategoryNames[GeoDataFeature::RailwayConstruction] = "RailwayConstruction";
         visualCategoryNames[GeoDataFeature::RailwayMonorail] = "RailwayMonorail";
         visualCategoryNames[GeoDataFeature::RailwayFunicular] = "RailwayFunicular";
         visualCategoryNames[GeoDataFeature::PowerTower] = "PowerTower";
         visualCategoryNames[GeoDataFeature::Satellite] = "Satellite";
         visualCategoryNames[GeoDataFeature::Landmass] = "Landmass";
         visualCategoryNames[GeoDataFeature::UrbanArea] = "UrbanArea";
         visualCategoryNames[GeoDataFeature::InternationalDateLine] = "InternationalDateLine";
+        visualCategoryNames[GeoDataFeature::Bathymetry] = "Bathymetry";
         visualCategoryNames[GeoDataFeature::AdminLevel1] = "AdminLevel1";
         visualCategoryNames[GeoDataFeature::AdminLevel2] = "AdminLevel2";
         visualCategoryNames[GeoDataFeature::AdminLevel3] = "AdminLevel3";
         visualCategoryNames[GeoDataFeature::AdminLevel4] = "AdminLevel4";
         visualCategoryNames[GeoDataFeature::AdminLevel5] = "AdminLevel5";
         visualCategoryNames[GeoDataFeature::AdminLevel6] = "AdminLevel6";
         visualCategoryNames[GeoDataFeature::AdminLevel7] = "AdminLevel7";
         visualCategoryNames[GeoDataFeature::AdminLevel8] = "AdminLevel8";
         visualCategoryNames[GeoDataFeature::AdminLevel9] = "AdminLevel9";
         visualCategoryNames[GeoDataFeature::AdminLevel10] = "AdminLevel10";
         visualCategoryNames[GeoDataFeature::AdminLevel11] = "AdminLevel11";
         visualCategoryNames[GeoDataFeature::BoundaryMaritime] = "BoundaryMaritime";
         visualCategoryNames[GeoDataFeature::LastIndex] = "LastIndex";
     }
 
     Q_ASSERT(visualCategoryNames.contains(category));
     return visualCategoryNames[category];
 }
 
 StyleParameters::StyleParameters(const GeoDataFeature *feature_, int tileLevel_) :
     feature(feature_),
     tileLevel(tileLevel_)
 {
     // nothing to do
 }
 
 }
diff --git a/src/lib/marble/declarative/Placemark.cpp b/src/lib/marble/declarative/Placemark.cpp
index ae495a198..d05bfdab0 100644
--- a/src/lib/marble/declarative/Placemark.cpp
+++ b/src/lib/marble/declarative/Placemark.cpp
@@ -1,513 +1,514 @@
 //
 // This file is part of the Marble Virtual Globe.
 //
 // This program is free software licensed under the GNU LGPL. You can
 // find a copy of this license in LICENSE.txt in the top directory of
 // the source code.
 //
 // Copyright 2011      Dennis Nienhüser <nienhueser@kde.org>
 //
 
 #include "Placemark.h"
 
 #ifdef HAVE_QT5_POSITIONING
 #include <GeoDataExtendedData.h>
 #include <QGeoAddress>
 #endif // HAVE_QT5_POSITIONING
 
 #include <osm/OsmPlacemarkData.h>
 
 namespace Marble {
 
 Placemark::Placemark(QObject *parent ) :
     QObject( parent )
 {
     // nothing to do
 }
 
 void Placemark::setGeoDataPlacemark( const Marble::GeoDataPlacemark &placemark )
 {
     m_placemark = placemark;
     m_address = QString();
     m_description = QString();
     m_website = QString();
     m_wikipedia = QString();
     m_fuelDetails = QString();
     m_openingHours = QString();
     emit coordinatesChanged();
     emit nameChanged();
     emit descriptionChanged();
     emit addressChanged();
     emit websiteChanged();
     emit wikipediaChanged();
     emit openingHoursChanged();
     if (m_placemark.visualCategory() == GeoDataFeature::TransportFuel) {
         emit fuelDetailsChanged();
     }
 }
 
 Marble::GeoDataPlacemark & Placemark::placemark()
 {
     return m_placemark;
 }
 
 QString Placemark::name() const
 {
     return m_placemark.name();
 }
 
 QString Placemark::description() const
 {
     if (m_description.isEmpty()) {
         auto const category = m_placemark.visualCategory();
         m_description = categoryName(category);
         if (category >= GeoDataFeature::FoodBar && category <= GeoDataFeature::FoodRestaurant) {
             addTagValue(m_description, "brand");
             addTagValue(m_description, "cuisine");
             addTagDescription(m_description, "self_service", "yes", "Self Service");
             addTagDescription(m_description, "takeaway", "yes", "Take Away");
             addTagDescription(m_description, "outdoor_seating", "yes", "Outdoor Seating");
             addTagDescription(m_description, "ice_cream", "yes", "Ice Cream");
             addTagDescription(m_description, "smoking", "dedicated", "Smoking (dedicated)");
             addTagDescription(m_description, "smoking", "yes", "Smoking allowed");
             addTagDescription(m_description, "smoking", "separated", "Smoking (separated)");
             addTagDescription(m_description, "smoking", "isolated", "Smoking (isolated)");
             addTagDescription(m_description, "smoking", "no", "No smoking");
             addTagDescription(m_description, "smoking", "outside", "Smoking (outside)");
             addTagDescription(m_description, "smoking:outside", "yes", "Smoking (outside)");
             addTagDescription(m_description, "smoking:outside", "separated", "Smoking (outside separated)");
             addTagDescription(m_description, "smoking:outside", "no", "No smoking outside");
         } else if (category >= GeoDataFeature::ShopBeverages && category <= GeoDataFeature::Shop) {
             addTagValue(m_description, "operator");
         } else if (category == GeoDataFeature::TransportBusStop) {
             addTagValue(m_description, "network");
             addTagValue(m_description, "operator");
             addTagValue(m_description, "ref");
         } else if (category == GeoDataFeature::TransportCarShare) {
             addTagValue(m_description, "network");
             addTagValue(m_description, "operator");
         } else if (category == GeoDataFeature::TransportFuel) {
             addTagValue(m_description, "brand");
             addTagValue(m_description, "operator");
         } else if (category == GeoDataFeature::NaturalTree) {
             addTagValue(m_description, "species:en");
             addTagValue(m_description, "genus:en");
             addTagValue(m_description, "leaf_type");
         }
     }
 
     return m_description;
 }
 
 QString Placemark::address() const
 {
     if (m_address.isEmpty()) {
         m_address = addressFromOsmData();
     }
     return m_address;
 }
 
 QString Placemark::fuelDetails() const
 {
     if (m_fuelDetails.isEmpty() && m_placemark.visualCategory() == GeoDataFeature::TransportFuel) {
         addTagDescription(m_fuelDetails, "fuel:diesel", "yes", tr("Diesel"));
         addTagDescription(m_fuelDetails, "fuel:octane_91", "yes", tr("Octane 91"));
         addTagDescription(m_fuelDetails, "fuel:octane_95", "yes", tr("Octane 95"));
         addTagDescription(m_fuelDetails, "fuel:octane_98", "yes", tr("Octane 98"));
         addTagDescription(m_fuelDetails, "fuel:e10", "yes", tr("E10"));
         addTagDescription(m_fuelDetails, "fuel:lpg", "yes", tr("LPG"));
 
     }
     return m_fuelDetails;
 }
 
 QString Placemark::website() const
 {
     if (!m_website.isEmpty()) {
         return m_website;
     }
     foreach(const QString &tag, QStringList() << "website" << "contact:website" << "facebook" << "contact:facebook" << "url") {
         m_website = m_placemark.osmData().tagValue(tag);
         if (!m_website.isEmpty()) {
             return m_website;
         }
     }
 
     return m_website;
 }
 
 QString Placemark::wikipedia() const
 {
     if (!m_wikipedia.isEmpty()) {
         return m_wikipedia;
     }
 
     m_wikipedia = m_placemark.osmData().tagValue("wikipedia");
     return m_wikipedia;
 }
 
 QString Placemark::openingHours() const
 {
     if (!m_openingHours.isEmpty()) {
         return m_openingHours;
     }
 
     addTagValue(m_openingHours, "opening_hours");
     return m_openingHours;
 }
 
 QString Placemark::coordinates() const
 {
     return m_placemark.coordinate().toString(GeoDataCoordinates::Decimal);
 }
 
 void Placemark::setName(const QString & name)
 {
     if (m_placemark.name() == name) {
         return;
     }
 
     m_placemark.setName(name);
     emit nameChanged();
 }
 
 QString Placemark::categoryName(GeoDataFeature::GeoDataVisualCategory category) const
 {
     switch (category) {
     case GeoDataFeature::SmallCity: return tr("City");
     case GeoDataFeature::SmallCountyCapital: return tr("County Capital");
     case GeoDataFeature::SmallStateCapital: return tr("State Capital");
     case GeoDataFeature::SmallNationCapital: return tr("Nation Capital");
     case GeoDataFeature::MediumCity: return tr("City");
     case GeoDataFeature::MediumCountyCapital: return tr("County Capital");
     case GeoDataFeature::MediumStateCapital: return tr("State Capital");
     case GeoDataFeature::MediumNationCapital: return tr("Nation Capital");
     case GeoDataFeature::BigCity: return tr("City");
     case GeoDataFeature::BigCountyCapital: return tr("County Capital");
     case GeoDataFeature::BigStateCapital: return tr("State Capital");
     case GeoDataFeature::BigNationCapital: return tr("Nation Capital");
     case GeoDataFeature::LargeCity: return tr("City");
     case GeoDataFeature::LargeCountyCapital: return tr("County Capital");
     case GeoDataFeature::LargeStateCapital: return tr("State Capital");
     case GeoDataFeature::LargeNationCapital: return tr("Nation Capital");
     case GeoDataFeature::Nation: return tr("Nation");
     case GeoDataFeature::PlaceCity: return tr("City");
     case GeoDataFeature::PlaceSuburb: return tr("Suburb");
     case GeoDataFeature::PlaceHamlet: return tr("Hamlet");
     case GeoDataFeature::PlaceLocality: return tr("Locality");
     case GeoDataFeature::PlaceTown: return tr("Town");
     case GeoDataFeature::PlaceVillage: return tr("Village");
     case GeoDataFeature::Mountain: return tr("Mountain");
     case GeoDataFeature::Volcano: return tr("Volcano");
     case GeoDataFeature::Continent: return tr("Continent");
     case GeoDataFeature::Ocean: return tr("Ocean");
     case GeoDataFeature::GeographicPole: return tr("Geographic Pole");
     case GeoDataFeature::MagneticPole: return tr("Magnetic Pole");
     case GeoDataFeature::ShipWreck: return tr("Ship Wreck");
     case GeoDataFeature::AirPort: return tr("Air Port");
     case GeoDataFeature::Observatory: return tr("Observatory");
     case GeoDataFeature::MilitaryDangerArea: return tr("Military Danger Area");
     case GeoDataFeature::OsmSite: return tr("OSM Site");
     case GeoDataFeature::Coordinate: return tr("Coordinate");
     case GeoDataFeature::Folder: return tr("Folder");
     case GeoDataFeature::Bookmark: return tr("Bookmark");
     case GeoDataFeature::NaturalWater: return tr("Water");
     case GeoDataFeature::NaturalReef: return tr("Reef");
     case GeoDataFeature::NaturalWood: return tr("Wood");
     case GeoDataFeature::NaturalBeach: return tr("Beach");
     case GeoDataFeature::NaturalWetland: return tr("Wetland");
     case GeoDataFeature::NaturalGlacier: return tr("Glacier");
     case GeoDataFeature::NaturalIceShelf: return tr("Ice Shelf");
     case GeoDataFeature::NaturalScrub: return tr("Scrub");
     case GeoDataFeature::NaturalCliff: return tr("Cliff");
     case GeoDataFeature::NaturalHeath: return tr("Heath");
     case GeoDataFeature::HighwayTrafficSignals: return tr("Traffic Signals");
     case GeoDataFeature::HighwaySteps: return tr("Steps");
     case GeoDataFeature::HighwayUnknown: return tr("Unknown Road");
     case GeoDataFeature::HighwayPath: return tr("Path");
     case GeoDataFeature::HighwayFootway: return tr("Footway");
     case GeoDataFeature::HighwayTrack: return tr("Track");
     case GeoDataFeature::HighwayPedestrian: return tr("Footway");
     case GeoDataFeature::HighwayCycleway: return tr("Cycleway");
     case GeoDataFeature::HighwayService: return tr("Service Road");
     case GeoDataFeature::HighwayRoad: return tr("Road");
     case GeoDataFeature::HighwayResidential: return tr("Residential Road");
     case GeoDataFeature::HighwayLivingStreet: return tr("Living Street");
     case GeoDataFeature::HighwayUnclassified: return tr("Unclassified Road");
     case GeoDataFeature::HighwayTertiaryLink: return tr("Tertiary Link Road");
     case GeoDataFeature::HighwayTertiary: return tr("Tertiary Road");
     case GeoDataFeature::HighwaySecondaryLink: return tr("Secondary Link Road");
     case GeoDataFeature::HighwaySecondary: return tr("Secondary Road");
     case GeoDataFeature::HighwayPrimaryLink: return tr("Primary Link Road");
     case GeoDataFeature::HighwayPrimary: return tr("Primary Road");
     case GeoDataFeature::HighwayTrunkLink: return tr("Trunk Link Road");
     case GeoDataFeature::HighwayTrunk: return tr("Trunk Road");
     case GeoDataFeature::HighwayMotorwayLink: return tr("Motorway Link Road");
     case GeoDataFeature::HighwayMotorway: return tr("Motorway");
     case GeoDataFeature::Building: return tr("Building");
     case GeoDataFeature::AccomodationCamping: return tr("Camping");
     case GeoDataFeature::AccomodationHostel: return tr("Hostel");
     case GeoDataFeature::AccomodationHotel: return tr("Hotel");
     case GeoDataFeature::AccomodationMotel: return tr("Motel");
     case GeoDataFeature::AccomodationYouthHostel: return tr("Youth Hostel");
     case GeoDataFeature::AccomodationGuestHouse: return tr("Guest House");
     case GeoDataFeature::AmenityLibrary: return tr("Library");
     case GeoDataFeature::AmenityKindergarten: return tr("Kindergarten");
     case GeoDataFeature::EducationCollege: return tr("College");
     case GeoDataFeature::EducationSchool: return tr("School");
     case GeoDataFeature::EducationUniversity: return tr("University");
     case GeoDataFeature::FoodBar: return tr("Bar");
     case GeoDataFeature::FoodBiergarten: return tr("Biergarten");
     case GeoDataFeature::FoodCafe: return tr("Cafe");
     case GeoDataFeature::FoodFastFood: return tr("Fast Food");
     case GeoDataFeature::FoodPub: return tr("Pub");
     case GeoDataFeature::FoodRestaurant: return tr("Restaurant");
     case GeoDataFeature::HealthDentist: return tr("Dentist");
     case GeoDataFeature::HealthDoctors: return tr("Doctors");
     case GeoDataFeature::HealthHospital: return tr("Hospital");
     case GeoDataFeature::HealthPharmacy: return tr("Pharmacy");
     case GeoDataFeature::HealthVeterinary: return tr("Veterinary");
     case GeoDataFeature::MoneyAtm: return tr("ATM");
     case GeoDataFeature::MoneyBank: return tr("Bank");
     case GeoDataFeature::AmenityArchaeologicalSite: return tr("Archaeological Site");
     case GeoDataFeature::AmenityEmbassy: return tr("Embassy");
     case GeoDataFeature::AmenityEmergencyPhone: return tr("Emergency Phone");
     case GeoDataFeature::AmenityWaterPark: return tr("Water Park");
     case GeoDataFeature::AmenityCommunityCentre: return tr("Community Centre");
     case GeoDataFeature::AmenityFountain: return tr("Fountain");
     case GeoDataFeature::AmenityNightClub: return tr("Night Club");
     case GeoDataFeature::AmenityBench: return tr("Bench");
     case GeoDataFeature::AmenityCourtHouse: return tr("Court House");
     case GeoDataFeature::AmenityFireStation: return tr("Fire Station");
     case GeoDataFeature::AmenityHuntingStand: return tr("Hunting Stand");
     case GeoDataFeature::AmenityPolice: return tr("Police");
     case GeoDataFeature::AmenityPostBox: return tr("Post Box");
     case GeoDataFeature::AmenityPostOffice: return tr("Post Office");
     case GeoDataFeature::AmenityPrison: return tr("Prison");
     case GeoDataFeature::AmenityRecycling: return tr("Recycling");
     case GeoDataFeature::AmenityTelephone: return tr("Telephone");
     case GeoDataFeature::AmenityToilets: return tr("Toilets");
     case GeoDataFeature::AmenityTownHall: return tr("Town Hall");
     case GeoDataFeature::AmenityWasteBasket: return tr("Waste Basket");
     case GeoDataFeature::AmenityDrinkingWater: return tr("Drinking Water");
     case GeoDataFeature::AmenityGraveyard: return tr("Graveyard");
     case GeoDataFeature::BarrierCityWall: return tr("City Wall");
     case GeoDataFeature::BarrierGate: return tr("Gate");
     case GeoDataFeature::BarrierLiftGate: return tr("Lift Gate");
     case GeoDataFeature::BarrierWall: return tr("Wall");
     case GeoDataFeature::NaturalPeak: return tr("Peak");
     case GeoDataFeature::NaturalTree: return tr("Tree");
     case GeoDataFeature::ShopBeverages: return tr("Beverages");
     case GeoDataFeature::ShopHifi: return tr("Hifi");
     case GeoDataFeature::ShopSupermarket: return tr("Supermarket");
     case GeoDataFeature::ShopAlcohol: return tr("Alcohol");
     case GeoDataFeature::ShopBakery: return tr("Bakery");
     case GeoDataFeature::ShopButcher: return tr("Butcher");
     case GeoDataFeature::ShopConfectionery: return tr("Confectionery");
     case GeoDataFeature::ShopConvenience: return tr("Convenience Shop");
     case GeoDataFeature::ShopGreengrocer: return tr("Greengrocer");
     case GeoDataFeature::ShopSeafood: return tr("Seafood");
     case GeoDataFeature::ShopDepartmentStore: return tr("Department Store");
     case GeoDataFeature::ShopKiosk: return tr("Kiosk");
     case GeoDataFeature::ShopBag: return tr("Bag");
     case GeoDataFeature::ShopClothes: return tr("Clothes");
     case GeoDataFeature::ShopFashion: return tr("Fashion");
     case GeoDataFeature::ShopJewelry: return tr("Jewelry");
     case GeoDataFeature::ShopShoes: return tr("Shoes");
     case GeoDataFeature::ShopVarietyStore: return tr("Variety Store");
     case GeoDataFeature::ShopBeauty: return tr("Beauty");
     case GeoDataFeature::ShopChemist: return tr("Chemist");
     case GeoDataFeature::ShopCosmetics: return tr("Cosmetics");
     case GeoDataFeature::ShopHairdresser: return tr("Hairdresser");
     case GeoDataFeature::ShopOptician: return tr("Optician");
     case GeoDataFeature::ShopPerfumery: return tr("Perfumery");
     case GeoDataFeature::ShopDoitYourself: return tr("Doit Yourself");
     case GeoDataFeature::ShopFlorist: return tr("Florist");
     case GeoDataFeature::ShopHardware: return tr("Hardware");
     case GeoDataFeature::ShopFurniture: return tr("Furniture");
     case GeoDataFeature::ShopElectronics: return tr("Electronics");
     case GeoDataFeature::ShopMobilePhone: return tr("Mobile Phone");
     case GeoDataFeature::ShopBicycle: return tr("Bicycle");
     case GeoDataFeature::ShopCar: return tr("Car");
     case GeoDataFeature::ShopCarRepair: return tr("Car Repair");
     case GeoDataFeature::ShopCarParts: return tr("Car Parts");
     case GeoDataFeature::ShopMotorcycle: return tr("Motorcycle");
     case GeoDataFeature::ShopOutdoor: return tr("Outdoor");
     case GeoDataFeature::ShopMusicalInstrument: return tr("Musical Instrument");
     case GeoDataFeature::ShopPhoto: return tr("Photo");
     case GeoDataFeature::ShopBook: return tr("Book");
     case GeoDataFeature::ShopGift: return tr("Gift");
     case GeoDataFeature::ShopStationery: return tr("Stationery");
     case GeoDataFeature::ShopLaundry: return tr("Laundry");
     case GeoDataFeature::ShopPet: return tr("Pet");
     case GeoDataFeature::ShopToys: return tr("Toys");
     case GeoDataFeature::ShopTravelAgency: return tr("Travel Agency");
     case GeoDataFeature::Shop: return tr("Shop");
     case GeoDataFeature::ManmadeBridge: return tr("Bridge");
     case GeoDataFeature::ManmadeLighthouse: return tr("Lighthouse");
     case GeoDataFeature::ManmadePier: return tr("Pier");
     case GeoDataFeature::ManmadeWaterTower: return tr("Water Tower");
     case GeoDataFeature::ManmadeWindMill: return tr("Wind Mill");
     case GeoDataFeature::TouristAttraction: return tr("Tourist Attraction");
     case GeoDataFeature::TouristCastle: return tr("Castle");
     case GeoDataFeature::TouristCinema: return tr("Cinema");
     case GeoDataFeature::TouristInformation: return tr("Information");
     case GeoDataFeature::TouristMonument: return tr("Monument");
     case GeoDataFeature::TouristMuseum: return tr("Museum");
     case GeoDataFeature::TouristRuin: return tr("Ruin");
     case GeoDataFeature::TouristTheatre: return tr("Theatre");
     case GeoDataFeature::TouristThemePark: return tr("Theme Park");
     case GeoDataFeature::TouristViewPoint: return tr("View Point");
     case GeoDataFeature::TouristZoo: return tr("Zoo");
     case GeoDataFeature::TouristAlpineHut: return tr("Alpine Hut");
     case GeoDataFeature::TransportAerodrome: return tr("Aerodrome");
     case GeoDataFeature::TransportHelipad: return tr("Helipad");
     case GeoDataFeature::TransportAirportTerminal: return tr("Airport Terminal");
     case GeoDataFeature::TransportBusStation: return tr("Bus Station");
     case GeoDataFeature::TransportBusStop: return tr("Bus Stop");
     case GeoDataFeature::TransportCarShare: return tr("Car Sharing");
     case GeoDataFeature::TransportFuel: return tr("Gas Station");
     case GeoDataFeature::TransportParking: return tr("Parking");
     case GeoDataFeature::TransportParkingSpace: return tr("Parking Space");
     case GeoDataFeature::TransportPlatform: return tr("Platform");
     case GeoDataFeature::TransportRentalBicycle: return tr("Rental Bicycle");
     case GeoDataFeature::TransportRentalCar: return tr("Rental Car");
     case GeoDataFeature::TransportTaxiRank: return tr("Taxi Rank");
     case GeoDataFeature::TransportTrainStation: return tr("Train Station");
     case GeoDataFeature::TransportTramStop: return tr("Tram Stop");
     case GeoDataFeature::TransportBicycleParking: return tr("Bicycle Parking");
     case GeoDataFeature::TransportMotorcycleParking: return tr("Motorcycle Parking");
     case GeoDataFeature::TransportSubwayEntrance: return tr("Subway Entrance");
     case GeoDataFeature::ReligionPlaceOfWorship: return tr("Place Of Worship");
     case GeoDataFeature::ReligionBahai: return tr("Bahai");
     case GeoDataFeature::ReligionBuddhist: return tr("Buddhist");
     case GeoDataFeature::ReligionChristian: return tr("Christian");
     case GeoDataFeature::ReligionMuslim: return tr("Muslim");
     case GeoDataFeature::ReligionHindu: return tr("Hindu");
     case GeoDataFeature::ReligionJain: return tr("Jain");
     case GeoDataFeature::ReligionJewish: return tr("Jewish");
     case GeoDataFeature::ReligionShinto: return tr("Shinto");
     case GeoDataFeature::ReligionSikh: return tr("Sikh");
     case GeoDataFeature::LeisureGolfCourse: return tr("Golf Course");
     case GeoDataFeature::LeisureMarina: return tr("Marina");
     case GeoDataFeature::LeisurePark: return tr("Park");
     case GeoDataFeature::LeisurePlayground: return tr("Playground");
     case GeoDataFeature::LeisurePitch: return tr("Pitch");
     case GeoDataFeature::LeisureSportsCentre: return tr("Sports Centre");
     case GeoDataFeature::LeisureStadium: return tr("Stadium");
     case GeoDataFeature::LeisureTrack: return tr("Track");
     case GeoDataFeature::LeisureSwimmingPool: return tr("Swimming Pool");
     case GeoDataFeature::LanduseAllotments: return tr("Allotments");
     case GeoDataFeature::LanduseBasin: return tr("Basin");
     case GeoDataFeature::LanduseCemetery: return tr("Cemetery");
     case GeoDataFeature::LanduseCommercial: return tr("Commercial");
     case GeoDataFeature::LanduseConstruction: return tr("Construction");
     case GeoDataFeature::LanduseFarmland: return tr("Farmland");
     case GeoDataFeature::LanduseFarmyard: return tr("Farmyard");
     case GeoDataFeature::LanduseGarages: return tr("Garages");
     case GeoDataFeature::LanduseGrass: return tr("Grass");
     case GeoDataFeature::LanduseIndustrial: return tr("Industrial");
     case GeoDataFeature::LanduseLandfill: return tr("Landfill");
     case GeoDataFeature::LanduseMeadow: return tr("Meadow");
     case GeoDataFeature::LanduseMilitary: return tr("Military");
     case GeoDataFeature::LanduseQuarry: return tr("Quarry");
     case GeoDataFeature::LanduseRailway: return tr("Railway");
     case GeoDataFeature::LanduseReservoir: return tr("Reservoir");
     case GeoDataFeature::LanduseResidential: return tr("Residential");
     case GeoDataFeature::LanduseRetail: return tr("Retail");
     case GeoDataFeature::LanduseOrchard: return tr("Orchard");
     case GeoDataFeature::LanduseVineyard: return tr("Vineyard");
     case GeoDataFeature::RailwayRail: return tr("Rail");
     case GeoDataFeature::RailwayNarrowGauge: return tr("Narrow Gauge");
     case GeoDataFeature::RailwayTram: return tr("Tram");
     case GeoDataFeature::RailwayLightRail: return tr("Light Rail");
     case GeoDataFeature::RailwayAbandoned: return tr("Abandoned Railway");
     case GeoDataFeature::RailwaySubway: return tr("Subway");
     case GeoDataFeature::RailwayPreserved: return tr("Preserved Railway");
     case GeoDataFeature::RailwayMiniature: return tr("Miniature Railway");
     case GeoDataFeature::RailwayConstruction: return tr("Railway Construction");
     case GeoDataFeature::RailwayMonorail: return tr("Monorail");
     case GeoDataFeature::RailwayFunicular: return tr("Funicular Railway");
     case GeoDataFeature::PowerTower: return tr("Power Tower");
     case GeoDataFeature::Satellite: return tr("Satellite");
     case GeoDataFeature::AdminLevel1: return tr("Admin Boundary (Level 1)");
     case GeoDataFeature::AdminLevel2: return tr("Admin Boundary (Level 2)");
     case GeoDataFeature::AdminLevel3: return tr("Admin Boundary (Level 3)");
     case GeoDataFeature::AdminLevel4: return tr("Admin Boundary (Level 4)");
     case GeoDataFeature::AdminLevel5: return tr("Admin Boundary (Level 5)");
     case GeoDataFeature::AdminLevel6: return tr("Admin Boundary (Level 6)");
     case GeoDataFeature::AdminLevel7: return tr("Admin Boundary (Level 7)");
     case GeoDataFeature::AdminLevel8: return tr("Admin Boundary (Level 8)");
     case GeoDataFeature::AdminLevel9: return tr("Admin Boundary (Level 9)");
     case GeoDataFeature::AdminLevel10: return tr("Admin Boundary (Level 10)");
     case GeoDataFeature::AdminLevel11: return tr("Admin Boundary (Level 11)");
     case GeoDataFeature::BoundaryMaritime: return tr("Boundary (Maritime)");
     case GeoDataFeature::Landmass: return tr("Land Mass");
     case GeoDataFeature::UrbanArea: return tr("Urban Area");
     case GeoDataFeature::InternationalDateLine: return tr("International Date Line");
+    case GeoDataFeature::Bathymetry: return tr("Bathymetry");
     case GeoDataFeature::Valley: return tr("Valley");
     case GeoDataFeature::OtherTerrain: return tr("Terrain");
     case GeoDataFeature::Crater: return tr("Crater");
     case GeoDataFeature::Mare: return tr("Sea");
     case GeoDataFeature::MannedLandingSite: return tr("Manned Landing Site");
     case GeoDataFeature::RoboticRover: return tr("Robotic Rover");
     case GeoDataFeature::UnmannedSoftLandingSite: return tr("Unmanned Soft Landing Site");
     case GeoDataFeature::UnmannedHardLandingSite: return tr("Unmanned Hard Landing Site");
     case GeoDataFeature::Mons: return tr("Mountain");
     case GeoDataFeature::Default:
     case GeoDataFeature::Unknown:
     case GeoDataFeature::None:
     case GeoDataFeature::LastIndex: return QString();
     }
 
     return QString();
 }
 
 void Placemark::addTagValue(QString &target, const QString &key) const
 {
     auto const & osmData = m_placemark.osmData();
     QString const value = osmData.tagValue(key);
     QString description = value;
     description.replace(';', " · ");
     addTagDescription(target, key, value, description);
 }
 
 void Placemark::addTagDescription(QString &target, const QString &key, const QString &value, const QString &description) const
 {
     auto const & osmData = m_placemark.osmData();
     if (osmData.containsTag(key, value)) {
         if (!target.isEmpty()) {
             target += " · ";
         }
         target += description;
     }
 }
 
 QString Placemark::addressFromOsmData() const
 {
 #ifdef HAVE_QT5_POSITIONING
     QGeoAddress address;
     OsmPlacemarkData const data = m_placemark.osmData();
     address.setCountry(data.tagValue("addr:country"));
     address.setState(data.tagValue("addr:state"));
     address.setCity(data.tagValue("addr:city"));
     address.setDistrict(data.tagValue("district"));
     address.setPostalCode(data.tagValue("addr:postcode"));
     QString const street = data.tagValue("addr:street");
     QString const houseNumber = data.tagValue("addr:housenumber");
     address.setStreet(formatStreet(street, houseNumber));
     return address.text().replace("<br/>", ", ");
 #else
     return QString();
 #endif
 }
 
 QString Placemark::formatStreet(const QString &street, const QString &houseNumber) const
 {
     return houseNumber.isEmpty() ? street : tr("%1 %2",
         "House number (first argument) and street name (second argument) in an address").arg(houseNumber).arg(street).trimmed();
 }
 
 }
 
 #include "moc_Placemark.cpp"
diff --git a/src/lib/marble/geodata/data/GeoDataFeature.h b/src/lib/marble/geodata/data/GeoDataFeature.h
index 25d1442c7..e36f7513d 100644
--- a/src/lib/marble/geodata/data/GeoDataFeature.h
+++ b/src/lib/marble/geodata/data/GeoDataFeature.h
@@ -1,651 +1,652 @@
 //
 // This file is part of the Marble Virtual Globe.
 //
 // This program is free software licensed under the GNU LGPL. You can
 // find a copy of this license in LICENSE.txt in the top directory of
 // the source code.
 //
 // Copyright 2007      Murad Tagirov <tmurad@gmail.com>
 // Copyright 2009      Patrick Spendrin <ps_ml@gmx.de>
 //
 
 
 #ifndef MARBLE_GEODATAFEATURE_H
 #define MARBLE_GEODATAFEATURE_H
 
 #include "GeoDataObject.h"
 
 #include "geodata_export.h"
 
 namespace Marble
 {
 
 // forward define all features we can find.
 class GeoDataRegion;
 class GeoDataAbstractView;
 
 class GeoDataStyle;
 class GeoDataStyleMap;
 
 class GeoDataExtendedData;
 
 class GeoDataTimeSpan;
 class GeoDataTimeStamp;
 
 class GeoDataFeaturePrivate;
 
 class GeoDataSnippet;
 
 /**
  * @short A base class for all geodata features
  *
  * GeoDataFeature is the base class for most geodata classes that
  * correspond to places on a map. It is never instantiated by itself,
  * but is always used as part of a derived class.
  *
  * @see GeoDataPlacemark
  * @see GeoDataContainer
  */
 
 // FIXME: Later also add NetworkLink and Overlay
 
 class GEODATA_EXPORT GeoDataFeature : public GeoDataObject
 {
  public:
     GeoDataFeature();
     /// Create a new GeoDataFeature with @p name as its name.
     explicit GeoDataFeature( const QString& name );
 
     GeoDataFeature( const GeoDataFeature& other );
 
     virtual ~GeoDataFeature();
 
     GeoDataFeature& operator=( const GeoDataFeature& other );
 
     /// Provides type information for downcasting a GeoData
     virtual const char* nodeType() const;
 
     EnumFeatureId featureId() const;
     /**
      * @brief  A categorization of a placemark as defined by ...FIXME.
      * There is an additional osm tag mapping to GeoDataVisualCategory
      * in OsmPresetLibrary.cpp
      */
     enum GeoDataVisualCategory {
         None,
         Default,
         Unknown,
 
         // The order of the cities needs to stay fixed as the
         // algorithms rely on that.
         SmallCity,
         SmallCountyCapital,
         SmallStateCapital,
         SmallNationCapital,
         MediumCity,
         MediumCountyCapital,
         MediumStateCapital,
         MediumNationCapital,
         BigCity,
         BigCountyCapital,
         BigStateCapital,
         BigNationCapital,
         LargeCity,
         LargeCountyCapital,
         LargeStateCapital,
         LargeNationCapital,
         Nation,
 
         PlaceCity,
         PlaceSuburb,
         PlaceHamlet,
         PlaceLocality,
         PlaceTown,
         PlaceVillage,
 
         // Terrain
         Mountain,
         Volcano,
         Mons,                    // m
         Valley,                  // v
         Continent,
         Ocean,
         OtherTerrain,            // o
 
         // Space Terrain
         Crater,                  // c
         Mare,                    // a
 
         // Places of Interest
         GeographicPole,
         MagneticPole,
         ShipWreck,
         AirPort,
         Observatory,
 
         // Military
         MilitaryDangerArea,
 
         // Runners
         OsmSite,
         Coordinate,
 
         // Planets
         MannedLandingSite,       // h
         RoboticRover,            // r
         UnmannedSoftLandingSite, // u
         UnmannedHardLandingSite, // i
 
         Folder,
         Bookmark,
 
         NaturalWater,
         NaturalReef,
         NaturalWood,
         NaturalBeach,
         NaturalWetland,
         NaturalGlacier,
         NaturalIceShelf,
         NaturalScrub,
         NaturalCliff,
         NaturalHeath,
 
         HighwayTrafficSignals,
 
         // OpenStreetMap highways
         HighwaySteps,
         HighwayUnknown,
         HighwayPath,
         HighwayFootway,
         HighwayTrack,
         HighwayPedestrian,
         HighwayCycleway,
         HighwayService,
         HighwayRoad,
         HighwayResidential,
         HighwayLivingStreet,
         HighwayUnclassified,
         HighwayTertiaryLink,
         HighwayTertiary,
         HighwaySecondaryLink,
         HighwaySecondary,
         HighwayPrimaryLink,
         HighwayPrimary,
         HighwayTrunkLink,
         HighwayTrunk,
         HighwayMotorwayLink,
         HighwayMotorway,
 
         //OSM building
         Building,
 
         // OpenStreetMap category Accomodation
         AccomodationCamping,
         AccomodationHostel,
         AccomodationHotel,
         AccomodationMotel,
         AccomodationYouthHostel,
         AccomodationGuestHouse,
 
         // OpenStreetMap category Amenity
         AmenityLibrary,
         AmenityKindergarten,
 
         // OpenStreetMap category Education
         EducationCollege,
         EducationSchool,
         EducationUniversity,
 
         // OpenStreetMap category Food
         FoodBar,
         FoodBiergarten,
         FoodCafe,
         FoodFastFood,
         FoodPub,
         FoodRestaurant,
 
         // OpenStreetMap category Health
         HealthDentist,
         HealthDoctors,
         HealthHospital,
         HealthPharmacy,
         HealthVeterinary,
 
         // OpenStreetMap category Money
         MoneyAtm,
         MoneyBank,
 
         AmenityArchaeologicalSite,
         AmenityEmbassy,
         AmenityEmergencyPhone,
         AmenityWaterPark,
         AmenityCommunityCentre,
         AmenityFountain,
         AmenityNightClub,
         AmenityBench,
         AmenityCourtHouse,
         AmenityFireStation,
         AmenityHuntingStand,
         AmenityPolice,
         AmenityPostBox,
         AmenityPostOffice,
         AmenityPrison,
         AmenityRecycling,
         AmenityTelephone,
         AmenityToilets,
         AmenityTownHall,
         AmenityWasteBasket,
         AmenityDrinkingWater,
         AmenityGraveyard,
 
         // OpenStreetMap category Barrier
         BarrierCityWall,
         BarrierGate,
         BarrierLiftGate,
         BarrierWall,
 
         NaturalPeak,
         NaturalTree,
 
         // OpenStreetMap category Shopping
         ShopBeverages,
         ShopHifi,
         ShopSupermarket,
         ShopAlcohol,
         ShopBakery,
         ShopButcher,
         ShopConfectionery,
         ShopConvenience,
         ShopGreengrocer,
         ShopSeafood,
         ShopDepartmentStore,
         ShopKiosk,
         ShopBag,
         ShopClothes,
         ShopFashion,
         ShopJewelry,
         ShopShoes,
         ShopVarietyStore,
         ShopBeauty,
         ShopChemist,
         ShopCosmetics,
         ShopHairdresser,
         ShopOptician,
         ShopPerfumery,
         ShopDoitYourself,
         ShopFlorist,
         ShopHardware,
         ShopFurniture,
         ShopElectronics,
         ShopMobilePhone,
         ShopBicycle,
         ShopCar,
         ShopCarRepair,
         ShopCarParts,
         ShopMotorcycle,
         ShopOutdoor,
         ShopMusicalInstrument,
         ShopPhoto,
         ShopBook,
         ShopGift,
         ShopStationery,
         ShopLaundry,
         ShopPet,
         ShopToys,
         ShopTravelAgency,
         Shop,
 
         ManmadeBridge,
         ManmadeLighthouse,
         ManmadePier,
         ManmadeWaterTower,
         ManmadeWindMill,
 
 
         // OpenStreetMap category Tourist
         TouristAttraction,
         TouristCastle,
         TouristCinema,
         TouristInformation,
         TouristMonument,
         TouristMuseum,
         TouristRuin,
         TouristTheatre,
         TouristThemePark,
         TouristViewPoint,
         TouristZoo,
         TouristAlpineHut,
 
         // OpenStreetMap category Transport
         TransportAerodrome,
         TransportHelipad,
         TransportAirportTerminal,
         TransportBusStation,
         TransportBusStop,
         TransportCarShare,
         TransportFuel,
         TransportParking,
         TransportParkingSpace,
         TransportPlatform,
         TransportRentalBicycle,
         TransportRentalCar,
         TransportTaxiRank,
         TransportTrainStation,
         TransportTramStop,
         TransportBicycleParking,
         TransportMotorcycleParking,
         TransportSubwayEntrance,
 
         // OpenStreetMap category religion
         ReligionPlaceOfWorship,
         ReligionBahai,
         ReligionBuddhist,
         ReligionChristian,
         ReligionMuslim,
         ReligionHindu,
         ReligionJain,
         ReligionJewish,
         ReligionShinto,
         ReligionSikh,
 
         // OpenStreetMap category Leisure
         LeisureGolfCourse,
         LeisureMarina,
         LeisurePark,
         LeisurePlayground,
         LeisurePitch,
         LeisureSportsCentre,
         LeisureStadium,
         LeisureTrack,
         LeisureSwimmingPool,
 
         LanduseAllotments,
         LanduseBasin,
         LanduseCemetery,
         LanduseCommercial,
         LanduseConstruction,
         LanduseFarmland,
         LanduseFarmyard,
         LanduseGarages,
         LanduseGrass,
         LanduseIndustrial,
         LanduseLandfill,
         LanduseMeadow,
         LanduseMilitary,
         LanduseQuarry,
         LanduseRailway,
         LanduseReservoir,
         LanduseResidential,
         LanduseRetail,
         LanduseOrchard,
         LanduseVineyard,
 
         RailwayRail,
         RailwayNarrowGauge,
         RailwayTram,
         RailwayLightRail,
         RailwayAbandoned,
         RailwaySubway,
         RailwayPreserved,
         RailwayMiniature,
         RailwayConstruction,
         RailwayMonorail,
         RailwayFunicular,
 
         // OpenStreetMap category Power
         PowerTower,
 
         Satellite,
 
         //Admin level tags for depicting boundary
         AdminLevel1,
         AdminLevel2,
         AdminLevel3,
         AdminLevel4,
         AdminLevel5,
         AdminLevel6,
         AdminLevel7,
         AdminLevel8,
         AdminLevel9,
         AdminLevel10,
         AdminLevel11,
 
         BoundaryMaritime,
 
         //Custom OSM Tags
         Landmass,
         UrbanArea,
         InternationalDateLine,
+        Bathymetry,
 
         // Important: Make sure that this is always the last
         // item and just use it to specify the array size
         LastIndex
 
     };
 
     /**
      * @brief The name of the feature
      *
      * The name of the feature should be a short string. It is often
      * shown directly on the map and need therefore not take up much
      * space.
      *
      * @return The name of this feature
      */
     QString name() const;
     /**
      * @brief Set a new name for this feature
      * @param value  the new name
      */
     void setName( const QString &value );
 
     /**
      * @brief A short description of the feature.
      *
      * HTML markup is not supported.
      * @TODO When the Snippet is not supplied, the first lines of description should be used.
      * @return The name of this feature
      */
     GeoDataSnippet snippet() const;
     /**
      * @brief Set a new name for this feature
      * @param value  the new name
      */
     void setSnippet( const GeoDataSnippet &value );
 
     /// Return the address of the feature
     QString address() const;
     /// Set the address of this feature to @p value.
     void setAddress( const QString &value);
 
     /// Return the phone number of the feature
     QString phoneNumber() const;
     /// Set the phone number of this feature to @p value.
     void setPhoneNumber( const QString &value );
 
     /// Return the text description of the feature.
     QString description() const;
     /// Set the description of this feature to @p value.
     void setDescription( const QString &value );
 
     /**
      * @brief test if the description is CDATA or not
      * CDATA allows for special characters to be included in XML and also allows
      * for other XML formats to be embedded in the XML without interfering with
      * parser namespace.
      * @return @true if the description should be treated as CDATA
      *         @false if the description is a plain string
      */
     bool descriptionIsCDATA() const;
     /// Set the description to be CDATA See: @see descriptionIsCDATA()
     void setDescriptionCDATA( bool cdata );
 
     /// Get the Abstract view of the feature
     const GeoDataAbstractView *abstractView() const;
     GeoDataAbstractView *abstractView();
     /// Set the abstract view of the feature
     void setAbstractView( GeoDataAbstractView *abstractView );
 
     /// Return the styleUrl of the feature.
     QString styleUrl() const;
     /// Set the styleUrl of this feature to @p value.
     void setStyleUrl( const QString &value );
 
     /// Return whether this feature is visible or not
     bool isVisible() const;
 
     /// Return whether this feature is visible or not in the context of its parenting
     bool isGloballyVisible() const;
 
     /**
      * @brief Set a new value for visibility
      * @param value  new value for the visibility
      *
      * This function sets the visibility, i.e. whether this feature
      * should be shown or not.  This can be changed either from a GUI
      * or through some action of the program.
      */
     void setVisible( bool value );
 
     /**
      * Return the timespan of the feature.
      */
     const GeoDataTimeSpan& timeSpan() const;
     GeoDataTimeSpan& timeSpan();
 
     /**
      * Set the timespan of the feature.
      * @param timeSpan new of timespan.
      */
     void setTimeSpan( const GeoDataTimeSpan &timeSpan );
 
     /**
      * Return the timestamp of the feature.
      */
     const GeoDataTimeStamp& timeStamp() const;
     GeoDataTimeStamp& timeStamp();
 
     /**
      * Set the timestamp of the feature.
      * @param timeStamp new of the timestamp.
      */
     void setTimeStamp( const GeoDataTimeStamp &timeStamp );
 
     /**
      * Return the style assigned to the placemark, or a default style if none has been set
      */
     QSharedPointer<const GeoDataStyle> style() const;
     /**
      * Return the style assigned to the placemark with setStyle (can be 0)
      */
     QSharedPointer<const GeoDataStyle> customStyle() const;
     /**
      * Sets the style of the placemark.
      * @param  style  the new style to be used.
      */
     void setStyle( const QSharedPointer<GeoDataStyle> &style );
 
     /**
      * Return the ExtendedData assigned to the feature.
      */
     GeoDataExtendedData& extendedData() const;
 
     /**
      * Sets the ExtendedData of the feature.
      * @param  extendedData  the new ExtendedData to be used.
      */
     void setExtendedData( const GeoDataExtendedData& extendedData );
 
     /**
      * Return the region assigned to the placemark.
      */
     GeoDataRegion& region() const;
     /**
      * @brief Sets the region of the placemark.
      * @param region new value for the region
      *
      * The feature is only shown when the region if active.
      */
     void setRegion( const GeoDataRegion& region );
 
     /**
      * Return the symbol index of the placemark.
      */
     GeoDataVisualCategory visualCategory() const;
     /**
      * Sets the symbol @p index of the placemark.
      * @param  category  the new category to be used.
      */
     void setVisualCategory( GeoDataVisualCategory category );
 
     /**
      * Return the role of the placemark.
      *
      * FIXME: describe roles here!
      */
     const QString role() const;
     /**
      * Sets the role of the placemark.
      * @param  role  the new role to be used.
      */
     void setRole( const QString &role );
 
     /**
      * @brief Return the popularity index of the placemark.
      *
      * The popularity index is a value which describes at which zoom
      * level the placemark will be shown.
      */
     int zoomLevel() const;
     /**
      * Sets the popularity @p index of the placemark.
      * @param  index  the new index to be used.
      */
     void setZoomLevel( int index );
 
     /**
      * Return the popularity of the feature.
      */
     qint64 popularity() const;
     /**
      * Sets the @p popularity of the feature.
      * @param  popularity  the new popularity value
      */
     void setPopularity( qint64 popularity );
 
     /**
      * Return a pointer to a GeoDataStyleMap object which represents the styleMap
      * of this feature. A styleMap is simply a QMap<QString,QString> which can connect
      * two styles with a keyword. This can be used to have a highlighted and a
      * normal style.
      * @see GeoDataStyleMap
      */
     const GeoDataStyleMap* styleMap() const;
     /**
      * Sets the styleMap of the feature
      */
     void setStyleMap( const GeoDataStyleMap* map );
 
     /// Serialize the contents of the feature to @p stream.
     virtual void pack( QDataStream& stream ) const;
     /// Unserialize the contents of the feature from @p stream.
     virtual void unpack( QDataStream& stream );
 
  protected:
     // the d-pointer needs to be protected to be accessible from derived classes
     GeoDataFeaturePrivate* d;
     explicit GeoDataFeature( GeoDataFeaturePrivate* priv );
 
     virtual void detach();
 
     bool equals( const GeoDataFeature &other ) const;
     using GeoDataObject::equals;
 
  private:
     // the private d pointer accessor - use it instead of the d pointer directly
     GeoDataFeaturePrivate* p() const;
 };
 
 }
 
 #endif
diff --git a/src/lib/marble/osm/OsmPresetLibrary.cpp b/src/lib/marble/osm/OsmPresetLibrary.cpp
index 178675596..40e440772 100644
--- a/src/lib/marble/osm/OsmPresetLibrary.cpp
+++ b/src/lib/marble/osm/OsmPresetLibrary.cpp
@@ -1,589 +1,590 @@
 //
 // This file is part of the Marble Virtual Globe.
 //
 // This program is free software licensed under the GNU LGPL. You can
 // find a copy of this license in LICENSE.txt in the top directory of
 // the source code.
 //
 // Copyright 2015    Marius-Valeriu Stanciu <stanciumarius94@gmail.com>
 //
 
 #include "OsmPresetLibrary.h"
 
 #include "GeoDataTypes.h"
 #include "GeoDataFeature.h"
 #include "GeoDataPlacemark.h"
 #include "GeoDataStyle.h"
 #include "OsmPlacemarkData.h"
 #include "StyleBuilder.h"
 
 #include <QMap>
 
 namespace Marble
 {
 
 QMap<OsmPresetLibrary::OsmTag, GeoDataFeature::GeoDataVisualCategory> OsmPresetLibrary::s_visualCategories;
 QList<OsmPresetLibrary::OsmTag> OsmPresetLibrary::s_additionalOsmTags;
 
 void OsmPresetLibrary::initializeOsmVisualCategories()
 {
     // Only initialize the map once
     if( !s_visualCategories.isEmpty() ) {
         return;
     }
 
     s_visualCategories[ OsmTag( "admin_level", "1" ) ]              = GeoDataFeature::AdminLevel1;
     s_visualCategories[ OsmTag( "admin_level", "2" ) ]              = GeoDataFeature::AdminLevel2;
     s_visualCategories[ OsmTag( "admin_level", "3" ) ]              = GeoDataFeature::AdminLevel3;
     s_visualCategories[ OsmTag( "admin_level", "4" ) ]              = GeoDataFeature::AdminLevel4;
     s_visualCategories[ OsmTag( "admin_level", "5" ) ]              = GeoDataFeature::AdminLevel5;
     s_visualCategories[ OsmTag( "admin_level", "6" ) ]              = GeoDataFeature::AdminLevel6;
     s_visualCategories[ OsmTag( "admin_level", "7" ) ]              = GeoDataFeature::AdminLevel7;
     s_visualCategories[ OsmTag( "admin_level", "8" ) ]              = GeoDataFeature::AdminLevel8;
     s_visualCategories[ OsmTag( "admin_level", "9" ) ]              = GeoDataFeature::AdminLevel9;
     s_visualCategories[ OsmTag( "admin_level", "10" ) ]             = GeoDataFeature::AdminLevel10;
     s_visualCategories[ OsmTag( "admin_level", "11" ) ]             = GeoDataFeature::AdminLevel11;
 
     s_visualCategories[ OsmTag( "boundary", "maritime" ) ]          = GeoDataFeature::BoundaryMaritime;
 
     s_visualCategories[ OsmTag( "amenity", "restaurant" ) ]         = GeoDataFeature::FoodRestaurant;
     s_visualCategories[ OsmTag( "amenity", "fast_food" ) ]          = GeoDataFeature::FoodFastFood;
     s_visualCategories[ OsmTag( "amenity", "pub" ) ]                = GeoDataFeature::FoodPub;
     s_visualCategories[ OsmTag( "amenity", "bar" ) ]                = GeoDataFeature::FoodBar;
     s_visualCategories[ OsmTag( "amenity", "cafe" ) ]               = GeoDataFeature::FoodCafe;
     s_visualCategories[ OsmTag( "amenity", "biergarten" ) ]         = GeoDataFeature::FoodBiergarten;
     s_visualCategories[ OsmTag( "amenity", "school" ) ]             = GeoDataFeature::EducationSchool;
     s_visualCategories[ OsmTag( "amenity", "college" ) ]            = GeoDataFeature::EducationCollege;
     s_visualCategories[ OsmTag( "amenity", "library" ) ]            = GeoDataFeature::AmenityLibrary;
     s_visualCategories[ OsmTag( "amenity", "kindergarten" ) ]       = GeoDataFeature::AmenityKindergarten;
     s_visualCategories[ OsmTag( "amenity", "childcare" ) ]          = GeoDataFeature::AmenityKindergarten;
     s_visualCategories[ OsmTag( "amenity", "university" ) ]         = GeoDataFeature::EducationUniversity;
     s_visualCategories[ OsmTag( "amenity", "bus_station" ) ]        = GeoDataFeature::TransportBusStation;
     s_visualCategories[ OsmTag( "amenity", "car_sharing" ) ]        = GeoDataFeature::TransportCarShare;
     s_visualCategories[ OsmTag( "amenity", "fuel" ) ]               = GeoDataFeature::TransportFuel;
     s_visualCategories[ OsmTag( "amenity", "parking" ) ]            = GeoDataFeature::TransportParking;
     s_visualCategories[ OsmTag( "amenity", "parking_space" ) ]      = GeoDataFeature::TransportParkingSpace;
     s_visualCategories[ OsmTag( "amenity", "atm" ) ]                = GeoDataFeature::MoneyAtm;
     s_visualCategories[ OsmTag( "amenity", "bank" ) ]               = GeoDataFeature::MoneyBank;
 
     s_visualCategories[ OsmTag( "historic", "archaeological_site" ) ] = GeoDataFeature::AmenityArchaeologicalSite;
     s_visualCategories[ OsmTag( "amenity", "embassy" ) ]            = GeoDataFeature::AmenityEmbassy;
     s_visualCategories[ OsmTag( "emergency", "phone" ) ]            = GeoDataFeature::AmenityEmergencyPhone;
     s_visualCategories[ OsmTag( "leisure", "water_park" ) ]         = GeoDataFeature::AmenityWaterPark;
     s_visualCategories[ OsmTag( "amenity", "community_centre" ) ]   = GeoDataFeature::AmenityCommunityCentre;
     s_visualCategories[ OsmTag( "amenity", "fountain" ) ]           = GeoDataFeature::AmenityFountain;
     s_visualCategories[ OsmTag( "amenity", "nightclub" ) ]          = GeoDataFeature::AmenityNightClub;
     s_visualCategories[ OsmTag( "amenity", "bench" ) ]              = GeoDataFeature::AmenityBench;
     s_visualCategories[ OsmTag( "amenity", "courthouse" ) ]         = GeoDataFeature::AmenityCourtHouse;
     s_visualCategories[ OsmTag( "amenity", "fire_station" ) ]       = GeoDataFeature::AmenityFireStation;
     s_visualCategories[ OsmTag( "amenity", "hunting_stand" ) ]      = GeoDataFeature::AmenityHuntingStand;
     s_visualCategories[ OsmTag( "amenity", "police" ) ]             = GeoDataFeature::AmenityPolice;
     s_visualCategories[ OsmTag( "amenity", "post_box" ) ]           = GeoDataFeature::AmenityPostBox;
     s_visualCategories[ OsmTag( "amenity", "post_office" ) ]        = GeoDataFeature::AmenityPostOffice;
     s_visualCategories[ OsmTag( "amenity", "prison" ) ]             = GeoDataFeature::AmenityPrison;
     s_visualCategories[ OsmTag( "amenity", "recycling" ) ]          = GeoDataFeature::AmenityRecycling;
     s_visualCategories[ OsmTag( "amenity", "telephone" ) ]          = GeoDataFeature::AmenityTelephone;
     s_visualCategories[ OsmTag( "amenity", "toilets" ) ]            = GeoDataFeature::AmenityToilets;
     s_visualCategories[ OsmTag( "amenity", "townhall" ) ]           = GeoDataFeature::AmenityTownHall;
     s_visualCategories[ OsmTag( "amenity", "waste_basket" ) ]       = GeoDataFeature::AmenityWasteBasket;
     s_visualCategories[ OsmTag( "amenity", "drinking_water" ) ]     = GeoDataFeature::AmenityDrinkingWater;
     s_visualCategories[ OsmTag( "amenity", "graveyard" ) ]          = GeoDataFeature::AmenityGraveyard;
 
     s_visualCategories[ OsmTag( "amenity", "dentist" ) ]            = GeoDataFeature::HealthDentist;
     s_visualCategories[ OsmTag( "amenity", "pharmacy" ) ]           = GeoDataFeature::HealthPharmacy;
     s_visualCategories[ OsmTag( "amenity", "hospital" ) ]           = GeoDataFeature::HealthHospital;
     s_visualCategories[ OsmTag( "amenity", "doctors" ) ]            = GeoDataFeature::HealthDoctors;
     s_visualCategories[ OsmTag( "amenity", "veterinary" ) ]         = GeoDataFeature::HealthVeterinary;
 
     s_visualCategories[ OsmTag( "amenity", "cinema" ) ]             = GeoDataFeature::TouristCinema;
     s_visualCategories[ OsmTag( "tourism", "information" ) ]        = GeoDataFeature::TouristInformation;
     s_visualCategories[ OsmTag( "amenity", "theatre" ) ]            = GeoDataFeature::TouristTheatre;
     s_visualCategories[ OsmTag( "amenity", "place_of_worship" ) ]   = GeoDataFeature::ReligionPlaceOfWorship;
 
     s_visualCategories[ OsmTag( "natural", "peak" ) ]               = GeoDataFeature::NaturalPeak;
     s_visualCategories[ OsmTag( "natural", "tree" ) ]               = GeoDataFeature::NaturalTree;
 
     s_visualCategories[ OsmTag( "shop", "beverages" ) ]             = GeoDataFeature::ShopBeverages;
     s_visualCategories[ OsmTag( "shop", "hifi" ) ]                  = GeoDataFeature::ShopHifi;
     s_visualCategories[ OsmTag( "shop", "supermarket" ) ]           = GeoDataFeature::ShopSupermarket;
     s_visualCategories[ OsmTag( "shop", "alcohol" ) ]               = GeoDataFeature::ShopAlcohol;
     s_visualCategories[ OsmTag( "shop", "bakery" ) ]                = GeoDataFeature::ShopBakery;
     s_visualCategories[ OsmTag( "shop", "butcher" ) ]               = GeoDataFeature::ShopButcher;
     s_visualCategories[ OsmTag( "shop", "confectionery" ) ]         = GeoDataFeature::ShopConfectionery;
     s_visualCategories[ OsmTag( "shop", "convenience" ) ]           = GeoDataFeature::ShopConvenience;
     s_visualCategories[ OsmTag( "shop", "greengrocer" ) ]           = GeoDataFeature::ShopGreengrocer;
     s_visualCategories[ OsmTag( "shop", "seafood" ) ]               = GeoDataFeature::ShopSeafood;
     s_visualCategories[ OsmTag( "shop", "department_store" ) ]      = GeoDataFeature::ShopDepartmentStore;
     s_visualCategories[ OsmTag( "shop", "kiosk" ) ]                 = GeoDataFeature::ShopKiosk;
     s_visualCategories[ OsmTag( "shop", "bag" ) ]                   = GeoDataFeature::ShopBag;
     s_visualCategories[ OsmTag( "shop", "clothes" ) ]               = GeoDataFeature::ShopClothes;
     s_visualCategories[ OsmTag( "shop", "fashion" ) ]               = GeoDataFeature::ShopFashion;
     s_visualCategories[ OsmTag( "shop", "jewelry" ) ]               = GeoDataFeature::ShopJewelry;
     s_visualCategories[ OsmTag( "shop", "shoes" ) ]                 = GeoDataFeature::ShopShoes;
     s_visualCategories[ OsmTag( "shop", "variety_store" ) ]         = GeoDataFeature::ShopVarietyStore;
     s_visualCategories[ OsmTag( "shop", "beauty" ) ]                = GeoDataFeature::ShopBeauty;
     s_visualCategories[ OsmTag( "shop", "chemist" ) ]               = GeoDataFeature::ShopChemist;
     s_visualCategories[ OsmTag( "shop", "cosmetics" ) ]             = GeoDataFeature::ShopCosmetics;
     s_visualCategories[ OsmTag( "shop", "hairdresser" ) ]           = GeoDataFeature::ShopHairdresser;
     s_visualCategories[ OsmTag( "shop", "optician" ) ]              = GeoDataFeature::ShopOptician;
     s_visualCategories[ OsmTag( "shop", "perfumery" ) ]             = GeoDataFeature::ShopPerfumery;
     s_visualCategories[ OsmTag( "shop", "doityourself" ) ]          = GeoDataFeature::ShopDoitYourself;
     s_visualCategories[ OsmTag( "shop", "florist" ) ]               = GeoDataFeature::ShopFlorist;
     s_visualCategories[ OsmTag( "shop", "hardware" ) ]              = GeoDataFeature::ShopHardware;
     s_visualCategories[ OsmTag( "shop", "furniture" ) ]             = GeoDataFeature::ShopFurniture;
     s_visualCategories[ OsmTag( "shop", "electronics" ) ]           = GeoDataFeature::ShopElectronics;
     s_visualCategories[ OsmTag( "shop", "mobile_phone" ) ]          = GeoDataFeature::ShopMobilePhone;
     s_visualCategories[ OsmTag( "shop", "bicycle" ) ]               = GeoDataFeature::ShopBicycle;
     s_visualCategories[ OsmTag( "shop", "car" ) ]                   = GeoDataFeature::ShopCar;
     s_visualCategories[ OsmTag( "shop", "car_repair" ) ]            = GeoDataFeature::ShopCarRepair;
     s_visualCategories[ OsmTag( "shop", "car_parts" ) ]             = GeoDataFeature::ShopCarParts;
     s_visualCategories[ OsmTag( "shop", "motorcycle" ) ]            = GeoDataFeature::ShopMotorcycle;
     s_visualCategories[ OsmTag( "shop", "outdoor" ) ]               = GeoDataFeature::ShopOutdoor;
     s_visualCategories[ OsmTag( "shop", "musical_instrument" ) ]    = GeoDataFeature::ShopMusicalInstrument;
     s_visualCategories[ OsmTag( "shop", "photo" ) ]                 = GeoDataFeature::ShopPhoto;
     s_visualCategories[ OsmTag( "shop", "books" ) ]                 = GeoDataFeature::ShopBook;
     s_visualCategories[ OsmTag( "shop", "gift" ) ]                  = GeoDataFeature::ShopGift;
     s_visualCategories[ OsmTag( "shop", "stationery" ) ]            = GeoDataFeature::ShopStationery;
     s_visualCategories[ OsmTag( "shop", "laundry" ) ]               = GeoDataFeature::ShopLaundry;
     s_visualCategories[ OsmTag( "shop", "pet" ) ]                   = GeoDataFeature::ShopPet;
     s_visualCategories[ OsmTag( "shop", "toys" ) ]                  = GeoDataFeature::ShopToys;
     s_visualCategories[ OsmTag( "shop", "travel_agency" ) ]         = GeoDataFeature::ShopTravelAgency;
 
     // Default for all other shops
     foreach(const QString &value, shopValues() ) {
         s_visualCategories[ OsmTag( "shop", value ) ]               = GeoDataFeature::Shop;
     }
 
 
     s_visualCategories[ OsmTag( "man_made", "bridge" ) ]            = GeoDataFeature::ManmadeBridge;
     s_visualCategories[ OsmTag( "man_made", "lighthouse" ) ]        = GeoDataFeature::ManmadeLighthouse;
     s_visualCategories[ OsmTag( "man_made", "pier" ) ]              = GeoDataFeature::ManmadePier;
     s_visualCategories[ OsmTag( "man_made", "water_tower" ) ]       = GeoDataFeature::ManmadeWaterTower;
     s_visualCategories[ OsmTag( "man_made", "windmill" ) ]          = GeoDataFeature::ManmadeWindMill;
 
     s_visualCategories[ OsmTag( "religion", "" ) ]                  = GeoDataFeature::ReligionPlaceOfWorship;
     s_visualCategories[ OsmTag( "religion", "bahai" ) ]             = GeoDataFeature::ReligionBahai;
     s_visualCategories[ OsmTag( "religion", "buddhist" ) ]          = GeoDataFeature::ReligionBuddhist;
     s_visualCategories[ OsmTag( "religion", "christian" ) ]         = GeoDataFeature::ReligionChristian;
     s_visualCategories[ OsmTag( "religion", "muslim" ) ]            = GeoDataFeature::ReligionMuslim;
     s_visualCategories[ OsmTag( "religion", "hindu" ) ]             = GeoDataFeature::ReligionHindu;
     s_visualCategories[ OsmTag( "religion", "jain" ) ]              = GeoDataFeature::ReligionJain;
     s_visualCategories[ OsmTag( "religion", "jewish" ) ]            = GeoDataFeature::ReligionJewish;
     s_visualCategories[ OsmTag( "religion", "shinto" ) ]            = GeoDataFeature::ReligionShinto;
     s_visualCategories[ OsmTag( "religion", "sikh" ) ]              = GeoDataFeature::ReligionSikh;
 
     s_visualCategories[ OsmTag( "historic", "memorial" ) ]          = GeoDataFeature::TouristAttraction;
     s_visualCategories[ OsmTag( "tourism", "attraction" ) ]         = GeoDataFeature::TouristAttraction;
     s_visualCategories[ OsmTag( "tourism", "camp_site" ) ]          = GeoDataFeature::AccomodationCamping;
     s_visualCategories[ OsmTag( "tourism", "hostel" ) ]             = GeoDataFeature::AccomodationHostel;
     s_visualCategories[ OsmTag( "tourism", "hotel" ) ]              = GeoDataFeature::AccomodationHotel;
     s_visualCategories[ OsmTag( "tourism", "motel" ) ]              = GeoDataFeature::AccomodationMotel;
     s_visualCategories[ OsmTag( "tourism", "guest_house" ) ]        = GeoDataFeature::AccomodationGuestHouse;
     s_visualCategories[ OsmTag( "tourism", "museum" ) ]             = GeoDataFeature::TouristMuseum;
     s_visualCategories[ OsmTag( "tourism", "theme_park" ) ]         = GeoDataFeature::TouristThemePark;
     s_visualCategories[ OsmTag( "tourism", "viewpoint" ) ]          = GeoDataFeature::TouristViewPoint;
     s_visualCategories[ OsmTag( "tourism", "zoo" ) ]                = GeoDataFeature::TouristZoo;
     s_visualCategories[ OsmTag( "tourism", "alpine_hut" ) ]         = GeoDataFeature::TouristAlpineHut;
 
     s_visualCategories[ OsmTag( "barrier", "city_wall" ) ]           = GeoDataFeature::BarrierCityWall;
     s_visualCategories[ OsmTag( "barrier", "gate" ) ]               = GeoDataFeature::BarrierGate;
     s_visualCategories[ OsmTag( "barrier", "lift_gate" ) ]           = GeoDataFeature::BarrierLiftGate;
     s_visualCategories[ OsmTag( "barrier", "wall" ) ]               = GeoDataFeature::BarrierWall;
 
     s_visualCategories[ OsmTag( "historic", "castle" ) ]            = GeoDataFeature::TouristCastle;
     s_visualCategories[ OsmTag( "historic", "fort" ) ]              = GeoDataFeature::TouristCastle;
     s_visualCategories[ OsmTag( "historic", "monument" ) ]          = GeoDataFeature::TouristMonument;
     s_visualCategories[ OsmTag( "historic", "ruins" ) ]             = GeoDataFeature::TouristRuin;
 
     s_visualCategories[ OsmTag( "highway", "traffic_signals" ) ]    = GeoDataFeature::HighwayTrafficSignals;
 
     s_visualCategories[ OsmTag( "highway", "unknown" ) ]            = GeoDataFeature::HighwayUnknown;
     s_visualCategories[ OsmTag( "highway", "steps" ) ]              = GeoDataFeature::HighwaySteps;
     s_visualCategories[ OsmTag( "highway", "footway" ) ]            = GeoDataFeature::HighwayFootway;
     s_visualCategories[ OsmTag( "highway", "cycleway" ) ]           = GeoDataFeature::HighwayCycleway;
     s_visualCategories[ OsmTag( "highway", "path" ) ]               = GeoDataFeature::HighwayPath;
     s_visualCategories[ OsmTag( "highway", "track" ) ]              = GeoDataFeature::HighwayTrack;
     s_visualCategories[ OsmTag( "highway", "pedestrian" ) ]         = GeoDataFeature::HighwayPedestrian;
     s_visualCategories[ OsmTag( "highway", "service" ) ]            = GeoDataFeature::HighwayService;
     s_visualCategories[ OsmTag( "highway", "living_street" ) ]      = GeoDataFeature::HighwayLivingStreet;
     s_visualCategories[ OsmTag( "highway", "unclassified" ) ]       = GeoDataFeature::HighwayUnclassified;
     s_visualCategories[ OsmTag( "highway", "residential" ) ]        = GeoDataFeature::HighwayResidential;
     s_visualCategories[ OsmTag( "highway", "road" ) ]               = GeoDataFeature::HighwayRoad;
     s_visualCategories[ OsmTag( "highway", "tertiary_link" ) ]      = GeoDataFeature::HighwayTertiaryLink;
     s_visualCategories[ OsmTag( "highway", "tertiary" ) ]           = GeoDataFeature::HighwayTertiary;
     s_visualCategories[ OsmTag( "highway", "secondary_link" ) ]     = GeoDataFeature::HighwaySecondaryLink;
     s_visualCategories[ OsmTag( "highway", "secondary" ) ]          = GeoDataFeature::HighwaySecondary;
     s_visualCategories[ OsmTag( "highway", "primary_link" ) ]       = GeoDataFeature::HighwayPrimaryLink;
     s_visualCategories[ OsmTag( "highway", "primary" ) ]            = GeoDataFeature::HighwayPrimary;
     s_visualCategories[ OsmTag( "highway", "trunk_link" ) ]         = GeoDataFeature::HighwayTrunkLink;
     s_visualCategories[ OsmTag( "highway", "trunk" ) ]              = GeoDataFeature::HighwayTrunk;
     s_visualCategories[ OsmTag( "highway", "motorway_link" ) ]      = GeoDataFeature::HighwayMotorwayLink;
     s_visualCategories[ OsmTag( "highway", "motorway" ) ]           = GeoDataFeature::HighwayMotorway;
 
     s_visualCategories[ OsmTag( "natural", "water" ) ]              = GeoDataFeature::NaturalWater;
     s_visualCategories[ OsmTag( "natural", "reef" ) ]               = GeoDataFeature::NaturalReef;
     s_visualCategories[ OsmTag( "natural", "bay" ) ]                = GeoDataFeature::NaturalWater;
     s_visualCategories[ OsmTag( "natural", "coastline" ) ]          = GeoDataFeature::NaturalWater;
     s_visualCategories[ OsmTag( "waterway", "stream" ) ]            = GeoDataFeature::NaturalWater;
     s_visualCategories[ OsmTag( "waterway", "river" ) ]             = GeoDataFeature::NaturalWater;
     s_visualCategories[ OsmTag( "waterway", "riverbank" ) ]         = GeoDataFeature::NaturalWater;
     s_visualCategories[ OsmTag( "waterway", "canal" ) ]             = GeoDataFeature::NaturalWater;
 
     s_visualCategories[ OsmTag( "natural", "wood" ) ]               = GeoDataFeature::NaturalWood;
     s_visualCategories[ OsmTag( "natural", "beach" ) ]              = GeoDataFeature::NaturalBeach;
     s_visualCategories[ OsmTag( "natural", "wetland" ) ]            = GeoDataFeature::NaturalWetland;
     s_visualCategories[ OsmTag( "natural", "glacier" ) ]            = GeoDataFeature::NaturalGlacier;
     s_visualCategories[ OsmTag( "glacier:type", "shelf" ) ]         = GeoDataFeature::NaturalIceShelf;
     s_visualCategories[ OsmTag( "natural", "scrub" ) ]              = GeoDataFeature::NaturalScrub;
     s_visualCategories[ OsmTag( "natural", "cliff" ) ]              = GeoDataFeature::NaturalCliff;
 
     s_visualCategories[ OsmTag( "military", "danger_area" ) ]       = GeoDataFeature::MilitaryDangerArea;
 
     s_visualCategories[ OsmTag( "landuse", "forest" ) ]             = GeoDataFeature::NaturalWood;
     s_visualCategories[ OsmTag( "landuse", "allotments" ) ]         = GeoDataFeature::LanduseAllotments;
     s_visualCategories[ OsmTag( "landuse", "basin" ) ]              = GeoDataFeature::LanduseBasin;
     s_visualCategories[ OsmTag( "landuse", "brownfield" ) ]         = GeoDataFeature::LanduseConstruction;
     s_visualCategories[ OsmTag( "landuse", "cemetery" ) ]           = GeoDataFeature::LanduseCemetery;
     s_visualCategories[ OsmTag( "landuse", "commercial" ) ]         = GeoDataFeature::LanduseCommercial;
     s_visualCategories[ OsmTag( "landuse", "construction" ) ]       = GeoDataFeature::LanduseConstruction;
     s_visualCategories[ OsmTag( "landuse", "farm" ) ]               = GeoDataFeature::LanduseFarmland;
     s_visualCategories[ OsmTag( "landuse", "farmland" ) ]           = GeoDataFeature::LanduseFarmland;
     s_visualCategories[ OsmTag( "landuse", "greenhouse_horticulture" ) ] = GeoDataFeature::LanduseFarmland;
     s_visualCategories[ OsmTag( "landuse", "farmyard" ) ]           = GeoDataFeature::LanduseFarmland;
     s_visualCategories[ OsmTag( "landuse", "garages" ) ]            = GeoDataFeature::LanduseGarages;
     s_visualCategories[ OsmTag( "landuse", "greenfield" ) ]         = GeoDataFeature::LanduseConstruction;
     s_visualCategories[ OsmTag( "landuse", "industrial" ) ]         = GeoDataFeature::LanduseIndustrial;
     s_visualCategories[ OsmTag( "landuse", "landfill" ) ]           = GeoDataFeature::LanduseLandfill;
     s_visualCategories[ OsmTag( "landuse", "meadow" ) ]             = GeoDataFeature::LanduseMeadow;
     s_visualCategories[ OsmTag( "landuse", "military" ) ]           = GeoDataFeature::LanduseMilitary;
     s_visualCategories[ OsmTag( "landuse", "orchard" ) ]            = GeoDataFeature::LanduseFarmland;
     s_visualCategories[ OsmTag( "landuse", "quarry" ) ]             = GeoDataFeature::LanduseQuarry;
     s_visualCategories[ OsmTag( "landuse", "railway" ) ]            = GeoDataFeature::LanduseRailway;
     s_visualCategories[ OsmTag( "landuse", "recreation_ground" ) ]  = GeoDataFeature::LeisurePark;
     s_visualCategories[ OsmTag( "landuse", "reservoir" ) ]          = GeoDataFeature::LanduseReservoir;
     s_visualCategories[ OsmTag( "landuse", "residential" ) ]        = GeoDataFeature::LanduseResidential;
     s_visualCategories[ OsmTag( "landuse", "retail" ) ]             = GeoDataFeature::LanduseRetail;
     s_visualCategories[ OsmTag( "landuse", "orchard" ) ]            = GeoDataFeature::LanduseOrchard;
     s_visualCategories[ OsmTag( "landuse", "vineyard" ) ]           = GeoDataFeature::LanduseVineyard;
     s_visualCategories[ OsmTag( "landuse", "village_green" ) ]      = GeoDataFeature::LanduseGrass;
     s_visualCategories[ OsmTag( "landuse", "grass" ) ]              = GeoDataFeature::LanduseGrass;
 
     s_visualCategories[ OsmTag( "leisure", "common" ) ]             = GeoDataFeature::LanduseGrass;
     s_visualCategories[ OsmTag( "leisure", "garden" ) ]             = GeoDataFeature::LanduseGrass;
     s_visualCategories[ OsmTag( "leisure", "golf_course" ) ]        = GeoDataFeature::LeisureGolfCourse;
     s_visualCategories[ OsmTag( "leisure", "marina" ) ]             = GeoDataFeature::LeisureMarina;
     s_visualCategories[ OsmTag( "leisure", "park" ) ]               = GeoDataFeature::LeisurePark;
     s_visualCategories[ OsmTag( "leisure", "playground" ) ]         = GeoDataFeature::LeisurePlayground;
     s_visualCategories[ OsmTag( "leisure", "pitch" ) ]              = GeoDataFeature::LeisurePitch;
     s_visualCategories[ OsmTag( "leisure", "sports_centre" ) ]      = GeoDataFeature::LeisureSportsCentre;
     s_visualCategories[ OsmTag( "leisure", "stadium" ) ]            = GeoDataFeature::LeisureStadium;
     s_visualCategories[ OsmTag( "leisure", "track" ) ]              = GeoDataFeature::LeisureTrack;
     s_visualCategories[ OsmTag( "leisure", "swimming_pool" ) ]      = GeoDataFeature::LeisureSwimmingPool;
 
     s_visualCategories[ OsmTag( "railway", "rail" ) ]               = GeoDataFeature::RailwayRail;
     s_visualCategories[ OsmTag( "railway", "narrow_gauge" ) ]       = GeoDataFeature::RailwayNarrowGauge;
     s_visualCategories[ OsmTag( "railway", "tram" ) ]               = GeoDataFeature::RailwayTram;
     s_visualCategories[ OsmTag( "railway", "light_rail" ) ]         = GeoDataFeature::RailwayLightRail;
     s_visualCategories[ OsmTag( "railway", "preserved" ) ]          = GeoDataFeature::RailwayPreserved;
     s_visualCategories[ OsmTag( "railway", "abandoned" ) ]          = GeoDataFeature::RailwayAbandoned;
     s_visualCategories[ OsmTag( "railway", "disused" ) ]            = GeoDataFeature::RailwayAbandoned;
     s_visualCategories[ OsmTag( "railway", "razed" ) ]              = GeoDataFeature::RailwayAbandoned;
     s_visualCategories[ OsmTag( "railway", "subway" ) ]             = GeoDataFeature::RailwaySubway;
     s_visualCategories[ OsmTag( "railway", "miniature" ) ]          = GeoDataFeature::RailwayMiniature;
     s_visualCategories[ OsmTag( "railway", "construction" ) ]       = GeoDataFeature::RailwayConstruction;
     s_visualCategories[ OsmTag( "railway", "monorail" ) ]           = GeoDataFeature::RailwayMonorail;
     s_visualCategories[ OsmTag( "railway", "funicular" ) ]          = GeoDataFeature::RailwayFunicular;
     s_visualCategories[ OsmTag( "railway", "platform" ) ]           = GeoDataFeature::TransportPlatform;
     s_visualCategories[ OsmTag( "railway", "station" ) ]            = GeoDataFeature::TransportTrainStation;
     s_visualCategories[ OsmTag( "railway", "halt" ) ]               = GeoDataFeature::TransportTrainStation;
 
     s_visualCategories[ OsmTag( "power", "tower" ) ]                = GeoDataFeature::PowerTower;
 
     s_visualCategories[ OsmTag( "aeroway", "aerodrome" ) ]          = GeoDataFeature::TransportAerodrome;
     s_visualCategories[ OsmTag( "aeroway", "helipad" ) ]            = GeoDataFeature::TransportHelipad;
     s_visualCategories[ OsmTag( "transport", "airpor_terminal" ) ]  = GeoDataFeature::TransportAirportTerminal;
     s_visualCategories[ OsmTag( "transport", "bus_station" ) ]      = GeoDataFeature::TransportBusStation;
     s_visualCategories[ OsmTag( "highway", "bus_stop" ) ]           = GeoDataFeature::TransportBusStop;
     s_visualCategories[ OsmTag( "transport", "car_share" ) ]        = GeoDataFeature::TransportCarShare;
     s_visualCategories[ OsmTag( "transport", "fuel" ) ]             = GeoDataFeature::TransportFuel;
     s_visualCategories[ OsmTag( "transport", "parking" ) ]          = GeoDataFeature::TransportParking;
     s_visualCategories[ OsmTag( "public_transport", "platform" ) ]  = GeoDataFeature::TransportPlatform;
     s_visualCategories[ OsmTag( "amenity", "bicycle_rental" ) ]     = GeoDataFeature::TransportRentalBicycle;
     s_visualCategories[ OsmTag( "amenity", "car_rental" ) ]         = GeoDataFeature::TransportRentalCar;
     s_visualCategories[ OsmTag( "amenity", "taxi" ) ]        = GeoDataFeature::TransportTaxiRank;
     s_visualCategories[ OsmTag( "transport", "train_station" ) ]    = GeoDataFeature::TransportTrainStation;
     s_visualCategories[ OsmTag( "transport", "tram_stop" ) ]        = GeoDataFeature::TransportTramStop;
     s_visualCategories[ OsmTag( "transport", "bus_stop" ) ]         = GeoDataFeature::TransportBusStop;
     s_visualCategories[ OsmTag( "amenity", "bicycle_parking" ) ]    = GeoDataFeature::TransportBicycleParking;
     s_visualCategories[ OsmTag( "amenity", "motorcycle_parking" ) ] = GeoDataFeature::TransportMotorcycleParking;
     s_visualCategories[ OsmTag( "railway", "subway_entrance" ) ]    = GeoDataFeature::TransportSubwayEntrance;
 
     s_visualCategories[ OsmTag( "place", "city" ) ]                 = GeoDataFeature::PlaceCity;
     s_visualCategories[ OsmTag( "place", "suburb" ) ]               = GeoDataFeature::PlaceSuburb;
     s_visualCategories[ OsmTag( "place", "hamlet" ) ]               = GeoDataFeature::PlaceHamlet;
     s_visualCategories[ OsmTag( "place", "locality" ) ]             = GeoDataFeature::PlaceLocality;
     s_visualCategories[ OsmTag( "place", "town" ) ]                 = GeoDataFeature::PlaceTown;
     s_visualCategories[ OsmTag( "place", "village" ) ]              = GeoDataFeature::PlaceVillage;
 
     //Custom Marble OSM Tags
     s_visualCategories[ OsmTag( "marble_land", "landmass" ) ]       = GeoDataFeature::Landmass;
     s_visualCategories[ OsmTag( "settlement", "yes" ) ]             = GeoDataFeature::UrbanArea;
     s_visualCategories[ OsmTag( "marble_line", "date" ) ]           = GeoDataFeature::InternationalDateLine;
+    s_visualCategories[ OsmTag( "marble:feature", "bathymetry" ) ]  = GeoDataFeature::Bathymetry;
 
     // Default for buildings
     foreach(const QString &value, buildingValues() ) {
         s_visualCategories[ OsmTag( "building", value ) ]           = GeoDataFeature::Building;
     }
 }
 
 void OsmPresetLibrary::initializeAdditionalOsmTags()
 {
     // Only initialize the list once
     if( !s_additionalOsmTags.isEmpty() ) {
         return;
     }
 
     // Recommended for nodes
     s_additionalOsmTags << OsmTag( "power", "pole" );
     s_additionalOsmTags << OsmTag( "power", "generator" );
     s_additionalOsmTags << OsmTag( "barrier", "fence" );
     s_additionalOsmTags << OsmTag( "barrier", "wall" );
     s_additionalOsmTags << OsmTag( "barrier", "gate" );
 
 
 
     // Recommended for ways
     s_additionalOsmTags << OsmTag( "lanes", "" );
     s_additionalOsmTags << OsmTag( "maxspeed", "" );
     s_additionalOsmTags << OsmTag( "maxheight", "" );
     s_additionalOsmTags << OsmTag( "maxweight", "" );
     s_additionalOsmTags << OsmTag( "oneway", "yes" );
     s_additionalOsmTags << OsmTag( "service", "driveway" );
     s_additionalOsmTags << OsmTag( "service", "parking_aisle" );
     s_additionalOsmTags << OsmTag( "service", "alley" );
     s_additionalOsmTags << OsmTag( "tunnel", "yes" );
     s_additionalOsmTags << OsmTag( "abutters", "commercial" );
     s_additionalOsmTags << OsmTag( "abutters", "industrial" );
     s_additionalOsmTags << OsmTag( "abutters", "mixed" );
     s_additionalOsmTags << OsmTag( "abutters", "residential" );
 
 
 
     // Recommended for areas
     s_additionalOsmTags << OsmTag( "surface", "unpaved" );
     s_additionalOsmTags << OsmTag( "surface", "paved" );
     s_additionalOsmTags << OsmTag( "surface", "gravel" );
     s_additionalOsmTags << OsmTag( "surface", "dirt" );
     s_additionalOsmTags << OsmTag( "surface", "grass" );
 
 
     // Relations
     s_additionalOsmTags << OsmTag( "type", "route" );
     s_additionalOsmTags << OsmTag( "type", "route_master" );
     s_additionalOsmTags << OsmTag( "type", "public_transport" );
     s_additionalOsmTags << OsmTag( "type", "destination_sign" );
     s_additionalOsmTags << OsmTag( "type", "waterway" );
     s_additionalOsmTags << OsmTag( "type", "enforcement" );
 
 
 
     // Relations: route
     s_additionalOsmTags << OsmTag( "route", "road" );
     s_additionalOsmTags << OsmTag( "route", "bicycle" );
     s_additionalOsmTags << OsmTag( "route", "foot" );
     s_additionalOsmTags << OsmTag( "route", "hiking" );
     s_additionalOsmTags << OsmTag( "route", "bus" );
     s_additionalOsmTags << OsmTag( "route", "trolleybus" );
     s_additionalOsmTags << OsmTag( "route", "ferry" );
     s_additionalOsmTags << OsmTag( "route", "detour" );
     s_additionalOsmTags << OsmTag( "route", "train" );
     s_additionalOsmTags << OsmTag( "route", "tram" );
     s_additionalOsmTags << OsmTag( "route", "mtb" );
     s_additionalOsmTags << OsmTag( "route", "horse" );
     s_additionalOsmTags << OsmTag( "route", "ski" );
     s_additionalOsmTags << OsmTag( "roundtrip", "yes" );
     s_additionalOsmTags << OsmTag( "network", "" );
     s_additionalOsmTags << OsmTag( "ref", "" );
     s_additionalOsmTags << OsmTag( "operator", "" );
 
 
 
     // Relations: route_master
     s_additionalOsmTags << OsmTag( "route_master", "train" );
     s_additionalOsmTags << OsmTag( "route_master", "subway" );
     s_additionalOsmTags << OsmTag( "route_master", "monorail" );
     s_additionalOsmTags << OsmTag( "route_master", "tram" );
     s_additionalOsmTags << OsmTag( "route_master", "bus" );
     s_additionalOsmTags << OsmTag( "route_master", "trolleybus" );
     s_additionalOsmTags << OsmTag( "route_master", "ferry" );
     s_additionalOsmTags << OsmTag( "route_master", "bicycle" );
 
 
 
     // Relations: public_transport
     s_additionalOsmTags << OsmTag( "public_transport", "stop_area" );
     s_additionalOsmTags << OsmTag( "public_transport", "stop_area_group" );
 
 
 
     // Relations: waterway
     s_additionalOsmTags << OsmTag( "waterway", "river" );
     s_additionalOsmTags << OsmTag( "waterway", "stream" );
     s_additionalOsmTags << OsmTag( "waterway", "canal" );
     s_additionalOsmTags << OsmTag( "waterway", "drain" );
     s_additionalOsmTags << OsmTag( "waterway", "ditch" );
 
 
 
     // Relations: enforcement
     s_additionalOsmTags << OsmTag( "enforcement", "maxheight" );
     s_additionalOsmTags << OsmTag( "enforcement", "maxweight" );
     s_additionalOsmTags << OsmTag( "enforcement", "maxspeed" );
     s_additionalOsmTags << OsmTag( "enforcement", "mindistance" );
     s_additionalOsmTags << OsmTag( "enforcement", "traffic_signals" );
     s_additionalOsmTags << OsmTag( "enforcement", "check" );
     s_additionalOsmTags << OsmTag( "enforcement", "access" );
     s_additionalOsmTags << OsmTag( "enforcement", "toll" );
 
 
 
     // Others
     s_additionalOsmTags << OsmTag( "height", "" );
     s_additionalOsmTags << OsmTag( "rooms", "" );
     s_additionalOsmTags << OsmTag( "beds", "" );
     s_additionalOsmTags << OsmTag( "wheelchair", "" );
     s_additionalOsmTags << OsmTag( "website", "" );
     s_additionalOsmTags << OsmTag( "email", "" );
     s_additionalOsmTags << OsmTag( "fee", "" );
     s_additionalOsmTags << OsmTag( "destination", "" );
     s_additionalOsmTags << OsmTag( "indoor", "yes" );
 
 
 
     // Recommended for all
     s_additionalOsmTags << OsmTag( "addr:street", "" );
     s_additionalOsmTags << OsmTag( "addr:housenumber", "" );
     s_additionalOsmTags << OsmTag( "addr:postcode", "" );
     s_additionalOsmTags << OsmTag( "addr:country", "" );
     s_additionalOsmTags << OsmTag( "access", "private" );
     s_additionalOsmTags << OsmTag( "access", "permissive" );
 }
 
 GeoDataStyle::ConstPtr OsmPresetLibrary::presetStyle( const OsmTag &tag )
 {
     static const StyleBuilder styleBuilder;
 
     const GeoDataFeature::GeoDataVisualCategory category = osmVisualCategory(tag.first + '=' + tag.second);
 
     return styleBuilder.presetStyle(category);
 }
 
 bool OsmPresetLibrary::hasVisualCategory ( const OsmTag &tag )
 {
 
     return s_visualCategories.contains( tag );
 }
 
 GeoDataFeature::GeoDataVisualCategory OsmPresetLibrary::osmVisualCategory( const QString &keyValue )
 {
     initializeOsmVisualCategories();
     QStringList tokens = keyValue.split( '=' );
 
     if ( tokens.size() != 2 ) {
         return GeoDataFeature::None;
     }
 
     QString key = tokens.at( 0 );
     QString value = tokens.at( 1 );
 
     return s_visualCategories.value( OsmTag( key, value ) );
 }
 
 QMap<OsmPresetLibrary::OsmTag, GeoDataFeature::GeoDataVisualCategory>::const_iterator OsmPresetLibrary::begin()
 {
     initializeOsmVisualCategories();
     return s_visualCategories.constBegin();
 }
 
 QMap<OsmPresetLibrary::OsmTag, GeoDataFeature::GeoDataVisualCategory>::const_iterator OsmPresetLibrary::end()
 {
     initializeOsmVisualCategories();
     return s_visualCategories.constEnd();
 }
 
 QList<OsmPresetLibrary::OsmTag>::const_iterator OsmPresetLibrary::additionalTagsBegin()
 {
     initializeAdditionalOsmTags();
     return s_additionalOsmTags.constBegin();
 }
 
 QList<OsmPresetLibrary::OsmTag>::const_iterator OsmPresetLibrary::additionalTagsEnd()
 {
     initializeAdditionalOsmTags();
     return s_additionalOsmTags.constEnd();
 }
 
 QStringList OsmPresetLibrary::shopValues()
 {
     // from https://taginfo.openstreetmap.org/keys/building#values
     static QStringList osmShopValues = QStringList()
         << "cheese" << "chocolate" << "coffee" << "deli" << "dairy" << "farm"
         << "pasta" << "pastry" << "tea" << "wine" << "general" << "mall"
         << "baby_goods" << "boutique" << "fabric" << "leather" << "tailor" << "watches"
         << "charity" << "second_hand" << "erotic" << "hearing_aids" << "herbalist" << "massage"
         << "medical_supply" << "tattoo" << "bathroom_furnishing" << "electrical" << "energy" << "furnace"
         << "garden_centre" << "garden_furniture" << "gas" << "glaziery" << "houseware" << "locksmith"
         << "paint" << "trade" << "antiques" << "bed" << "candles" << "carpet"
         << "curtain" << "interior_decoration" << "kitchen" << "lamps" << "window_blind" << "computer"
         << "radiotechnics" << "vacuum_cleaner" << "fishing" << "free_flying" << "hunting" << "outdoor"
         << "scuba_diving" << "sports" << "tyres" << "swimming_pool" << "art" << "craft"
         << "frame" << "games" << "model" << "music" << "trophy" << "video"
         << "video_games" << "anime" << "ticket" << "copyshop" << "dry_cleaning" << "e-cigarette"
         << "funeral_directors" << "money_lender" << "pawnbroker" << "pyrotechnics" << "religion" << "storage_rental"
         << "tobacco" << "weapons" << "user defined";
     return osmShopValues;
 }
 
 QStringList OsmPresetLibrary::buildingValues()
 {
     // from https://taginfo.openstreetmap.org/keys/building#values
     static QStringList osmBuildingValues = QStringList()
         << "yes" << "house" << "residential" << "garage" << "apartments"
         << "hut" << "industrial" << "detached" << "roof" << "garages"
         << "commercial" << "terrace" << "shed" << "school" << "retail"
         << "farm_auxiliary" << "church" << "cathedral" << "greenhouse" << "barn"
         << "service" << "manufacture" << "construction" << "cabin"
         << "farm" << "warehouse" << "House" << "office"
         << "civic" << "Residential" << "hangar" << "public" << "university"
         << "hospital" << "chapel" << "hotel" << "train_station" << "dormitory"
         << "kindergarten" << "stable" << "storage_tank" << "shop" << "college"
         << "supermarket" << "factory" << "bungalow" << "tower" << "silo"
         << "storage" << "station" << "education" << "carport" << "houseboat"
         << "castle" << "social_facility" << "water_tower" << "container"
         << "exhibition_hall" << "monastery" << "bunker" << "shelter";
     return osmBuildingValues;
 }
 
 GeoDataFeature::GeoDataVisualCategory OsmPresetLibrary::determineVisualCategory(const OsmPlacemarkData &osmData)
 {
     if (osmData.containsTagKey("building") && buildingValues().contains(osmData.tagValue("building")) ) {
         return GeoDataFeature::Building;
     }
 
     if( osmData.containsTag("natural", "glacier") && osmData.containsTag("glacier:type", "shelf") ){
         return GeoDataFeature::NaturalIceShelf;
     }
 
     for (auto iter = osmData.tagsBegin(), end=osmData.tagsEnd(); iter != end; ++iter) {
         QString const keyValue = QString("%1=%2").arg(iter.key()).arg(iter.value());
         GeoDataFeature::GeoDataVisualCategory category = osmVisualCategory(keyValue);
         if (category != GeoDataFeature::None) {
             return osmVisualCategory(keyValue);
         }
     }
 
 
     return GeoDataFeature::None;
 }
 
 }
diff --git a/tools/shp2osm/polyshp2osm.py b/tools/shp2osm/polyshp2osm.py
index ea3e4e2e6..fa9e8cf5d 100644
--- a/tools/shp2osm/polyshp2osm.py
+++ b/tools/shp2osm/polyshp2osm.py
@@ -1,817 +1,818 @@
 #!/usr/bin/python3
  
 """
 This script is designed to act as assistance in converting shapefiles
 to OpenStreetMap data. This file is optimized and tested with MassGIS
 shapefiles, converted to EPSG:4326 before being passed to the script.
 You can perform this conversion with 
  
    ogr2ogr -t_srs EPSG:4326 new_file.shp old_file.shp
  
 It is expected that you will modify the fixed_tags, tag_mapping, and
 boring_tags attributes of this script before running. You should read,
 or at least skim, the code up until it says:
  
   DO NOT CHANGE AFTER THIS LINE.
  
 to accomodate your own data. 
 """
  
 __author__ = "Christopher Schmidt <crschmidt@crschmidt.net>"
 __version__ = "$Id$"
  
 gdal_install = """
 Installing GDAL depends on your platform. Information is available at:
    
    http://trac.osgeo.org/gdal/wiki/DownloadingGdalBinaries
  
 For Debian-based systems:
  
    apt-get install python-gdal
  
 will usually suffice. 
 """
  
 # These tags are attached to all exterior ways. You can put any key/value pairs
 # in this dictionary. 
  
 fixed_tags = {
   'source': 'Natural Earth (http://www.naturalearthdata.com/)',
   'created_by': 'polyshp2osm'
 }  
  
 feat_dict = {}
 node_dict = {}
 non_geom = 0
 eflag = False
  
 nodes = []  #(id, lon, lat, tags)
 ways = []  #(id, node_refs, tags)
 relations = []  #(id, ways)
 
 element_indices = []
  
 non_polygons = ['Admin-1 aggregation', 'Admin-1 minor island', 'Admin-1 scale rank']
  
 # Here are a number of functions: These functions define tag mappings. The API
 # For these functions is that they are passed the attributes from a feature,
 # and they return a list of two-tuples which match to key/value pairs.
  
 def access(data):
     """Access restrictions."""  
     keys = {
         'Y': 'yes',
         'N': 'private',
         'L': 'restricted'
     }
     if 'pub_access' in data:
         if data['pub_access'] in keys:
             return [('access', keys[data['pub_access']])]
     return None        
  
 def protection(data):
     keys = {
         'P': 'perpetuity',
         'T': 'temporary',
         'L': 'limited',
     }
     if 'lev_prot' in data:
         if data['lev_prot'] in keys:
             return [('protected', keys[data['lev_prot']])]
     return None
  
 def owner_type(data):
     """See wiki:Key:ownership""" 
     keys = {
         'F': 'national',
         'S': 'state',
         'C': 'county',
         'M': 'municipal',
         'N': 'private_nonprofit',
         'P': 'private',
         'B': 'public_nonprofit',
         'L': 'land_trust',
         'G': 'conservation_rganization',
         'I': 'inholding',
     }
     if 'owner_type' in data:
         if data['owner_type'] in keys:
             return [['ownership', keys[data['owner_type']]]]
  
 def purpose(data):
     """Based on a discussion on IRC"""
     keys = {
         'R': [('leisure', 'recreation_ground')],
         'C': [('leisure', 'nature_reserve'), ('landuse', 'conservation')],
         'B': [('landuse','conservation'), ('leisure','recreation_ground')],
         'H': [('historical', 'yes')],
         'A': [('agricultural', 'yes'), ('landuse','farm')], 
         'W': [('landuse', 'resevoir')],
         'S': [('scenic','yes')],
         'F': [('landuse','land')],
         'Q': [('landuse','conservation')],
         'U': [('water','yes')]
     }
     if 'prim_purp' in data:
         if data['prim_purp'] in keys:
             return keys[data['prim_purp']]
- 
+
  
 def road_map(data):
     keys = {
     'Ferry Route': [('route','ferry')],
     'Major Highway': [('highway','motorway')],
     'Beltway': [('highway','primary')],
     'Track': [('highway','tertiary')],
     'Unknown': [('highway','unclassified')],
     'Secondary Highway': [('highway','trunk')],
     'Bypass': [('highway','secondary')],
     'Road': [('highway','primary')]
     }
     if 'type' in data:
         if data['type'] in keys:
             return keys[data['type']]
  
 def city_map(data):
     population = 0
     capital = 'no'
     country = ''
     if data['featurecla'] == 'Admin-0 capital' or data['featurecla'] == 'Admin-1 capital' or data['featurecla'] == 'Admin-0 region capital' or data['featurecla'] == 'Admin-1 region capital':
         capital = 'yes' 
     if 'pop_max' in data:
         population = data['pop_max']
     if 'adm0name' in data:
         country = data['adm0name']
     temp =  [('is_in:country', country), ('capital', capital), ('population', population), ('place', 'city') ]
     return temp
 
 def mountain_map(data):
     elevation = 0
     if 'elevation' in data:
         elevation = data['elevation']
     temp = [('natural', 'peak'), ('ele', elevation)]
     return temp
  
 def feature_class(data):
     global non_fcla_dict
     keys = {
     'Lake': [('natural', 'water')],
     'Alkaline Lake': [('natural', 'water')],
     'Reservoir': [('natural', 'water')],
     'Road': [(road_map,None)],
     'Ferry': [('route','ferry')],
     'River': [('waterway', 'river')],
     'Coastline': [('natural', 'coastline')],
     'Minor coastline': [('natural', 'coastline')],
     'Ocean': [('natural', 'water')],
     'Land': [('marble_land', 'landmass')],
     'Minor island': [('marble_land', 'landmass'), ('place', 'island')],
     'Reefs': [('natural', 'reef')],
     'Admin-0 country': [('marble_land', 'landmass')],
     'Admin-0 sovereignty': [('marble_land', 'landmass')],
     'Admin-0 map unit': [('marble_land', 'landmass')],
     'Adm-0 scale ranks': [('marble_land', 'landmass')],
     'International boundary (verify)': [('boundary', 'administrative'), ('admin_level', '2')],
     'Overlay limit': [('boundary', 'administrative'), ('admin_level', '2')],
     'Disputed (please verify)': [('boundary', 'administrative'), ('admin_level', '2')],
     'Line of control (please verify)': [('boundary', 'administrative'), ('admin_level', '2')],
     'Indefinite (please verify)': [('boundary', 'administrative'), ('admin_level', '2')],
     'Lease limit': [('boundary', 'administrative'), ('admin_level', '2')],
     'Indeterminant frontier': [('boundary', 'administrative'), ('admin_level', '2')],
     'Admin-0 lease': [('marble_land', 'landmass')],
     'Admin-0 claim area': [('marble_land', 'landmass')],
     'Admin-0 breakaway and disputed': [('marble_land', 'landmass')],
     'Admin-0 overlay': [('marble_land', 'landmass')],
     'Admin-0 indeterminant': [('marble_land', 'landmass')],
     'Admin-1 aggregation': [('boundary', 'administrative'), ('admin_level', '4')],
     'Admin-1 minor island': [('boundary', 'administrative'), ('admin_level', '4')],
     'Admin-1 scale rank': [('boundary', 'administrative'), ('admin_level', '4')],
     'Admin-1 region boundary': [('boundary', 'administrative'), ('admin_level', '4')],
     'Railroad': [('railway', 'rail')],
     'Railroad ferry': [('route', 'ferry')],
     'Urban area': [('settlement', 'yes')],
     'Timezone': [('marble_land', 'landmass')],
     'Historic place': [(city_map,None)],
     'Populated place': [(city_map,None)],
     'Scientific station': [(city_map,None)],
     'Meteorological Station': [(city_map,None)],
     'Admin-0 capital': [(city_map,None)],
     'Admin-1 capital': [(city_map,None)],
     'Admin-0 region capital': [(city_map,None)],
     'Admin-1 region capital': [(city_map,None)],
     'Admin-0 capital alt': [(city_map,None)],
     'Lake Centerline': [('waterway', 'river')],
     'Port': [('harbour', 'yes')],
     'Island': [('marble_land', 'landmass'), ('place', 'island')],
     'Island group': [('marble_land', 'landmass'), ('place', 'island')],
     'Wetlands': [('natural', 'wetland')],
     'Basin': [('landuse', 'basin')],
     'Desert': [('natural', 'desert')],  #no tag support in marble, no clue as to how to render
     'Depression': [('natural', 'sinkhole')],  #no tag support in marble, no clue as to how to render
     'Range/mtn': [('marble_land', 'landmass')], # no clue as to how to render
     'Geoarea': [('marble_land', 'landmass')], # no clue as to how to render
     'Plain' : [('marble_land', 'landmass')], # no clue as to how to render
     'Tundra': [('natural', 'tundra')], #no tag support in marble, no clue as to how to render
     'Foothills' : [('marble_land', 'landmass')], #no tag support in OSM, nothing in Marble, no clue as to how to render
     'Lowland' : [('marble_land', 'landmass')], #no tag support in OSM, nothing in Marble, no clue as to how to render
     'Dragons-be-here': [('marble_land', 'landmass')], #no tag support in OSM, nothing in Marble, no clue as to how to render
     'Delta': [('marble_land', 'landmass')], #no tag support in OSM, nothing in Marble, no clue as to how to render
     'Peninsula':  [('marble_land', 'landmass')],
     'Plateau' : [('marble_land', 'landmass')],
     'Pen/cape' : [('natural', 'cape')], #osm tag still in proposal stage, no clue as to how to render
     'Gorge': [('marble_land', 'landmass')],  #no tag support in OSM, nothing in Marble, no clue as to how to render
     'Coast':  [('marble_land', 'landmass')], #no tag support in OSM, nothing in Marble, no clue as to how to render
     'Continent':  [('marble_land', 'landmass')], #no tag support in OSM, nothing in Marble, redundant data
     'Isthmus': [('marble_land', 'landmass')], #no tag support in OSM, nothing in Marble, no clue as to how to render
     'Valley': [('natural', 'valley')],  #no tag support in marble
     'waterfall' : [('waterway', 'waterfall')], #no tag support in marble
     'cape': [('natural', 'cape')], #osm tag still in proposal stage, no clue as to how to render      'NONE'
     'pole': [],
     'plain': [],
     'island group': [],
     'island': [],
     'mountain': [(mountain_map,None)], #this tag has to be mapped to Mountain feature of Marble
     'spot elevation': [],
     'plateau': [],
     'depression': [],
     'pass': [],
     'sound': [('natural', 'water')],
     'river':  [('natural', 'water')],
     'generic': [('natural', 'water')], #still have to confirm what generic means exactly in marine_polygons?
     'lagoon': [('natural', 'water'), ('water', 'lagoon')], 
     'reef': [('natural', 'reef')],
     'gulf': [('natural', 'water')],
     'inlet': [('natural', 'water')],
     'strait': [('natural', 'water')],
     'bay': [('natural', 'water')],
     'fjord': [('natural', 'water')],
     'sea': [('natural', 'water')],  
     'ocean': [('natural', 'water')],
     'channel': [('natural', 'water')],
     'Playa': [('natural', 'water'), ('water', 'lake'), ('salt', 'yes')],
     #glacier:type is a proposed OSM tag - http://wiki.openstreetmap.org/wiki/Proposed_features/Glaciers_tags
     'Antarctic Ice Shelf': [('natural', 'glacier'), ('glacier:type','shelf')], 
     'Antarctic Ice Shelf Edge': [('glacier:edge', 'calving_line')], #marble does not support this osm tag
     'Glaciated areas': [('natural', 'glacier')],
     'Admin-0 Tiny Countries': [],
     'Admin-0 Tiny GeoUnit': [],
     'Admin-0 Tiny GeoSubunit': [],
     'Admin-0 Tiny Countries Pacific': [],
     'Pacific Groupings': [],
     'Admin-1 boundary': [('boundary', 'administrative'), ('admin_level', '4')],
     'Map unit boundary':[],
     'Marine Indicator Treaty':[('boundary', 'administrative'), ('admin_level', '2'), ('maritime', 'yes'), ('border_type', 'territorial')],
     'Marine Indicator Median':[('boundary', 'administrative'), ('admin_level', '2'), ('maritime', 'yes'), ('border_type', 'territorial')],
     'Boundary Treaty':[('boundary', 'administrative'), ('admin_level', '2'), ('maritime', 'yes'), ('border_type', 'territorial')],
     'Marine Indicator 200 mi nl':[('boundary', 'maritime'), ('border_type', 'eez')],
     'Marine Indicator Disputed':[('boundary', 'administrative'), ('admin_level', '2'), ('maritime', 'yes'), ('border_type', 'territorial'), ('marble:disputed', 'yes')],
     'Claim boundary': [('boundary', 'administrative'), ('admin_level', '2')],
     'Reference line': [('boundary', 'administrative'), ('admin_level', '2')],
     'Breakaway': [('boundary', 'administrative'), ('admin_level', '2')],
     'Elusive frontier': [('boundary', 'administrative'), ('admin_level', '2')],
     'Country': [('marble_land', 'landmass')],
     '1st Order Admin Lines': [('boundary', 'administrative'), ('admin_level', '4')],
     'Claim': [('boundary', 'administrative'), ('admin_level', '4')],
     'Airport': [('aeroway', 'aerodrome')],
-    'Date line': [('marble_line', 'date')]
+    'Date line': [('marble_line', 'date')],
+    'Bathymetry': [('marble:feature', 'bathymetry'), ('depth', data['depth'])]
     }
     if 'featurecla' in data:
         if data['featurecla'] in feat_dict:
             feat_dict[data['featurecla']] += 1
         else:
             feat_dict[data['featurecla']] = 1
         if data['featurecla'] in keys:
             if len(keys[data['featurecla']]) == 0:
                 return keys[data['featurecla']]
             if hasattr(keys[data['featurecla']][0][0], '__call__'):
                 return keys[data['featurecla']][0][0](data)
             else:
                 return keys[data['featurecla']]
         else:
             if data['featurecla'] in non_fcla_dict:
                 non_fcla_dict[data['featurecla']] += 1
             else:
                 non_fcla_dict[data['featurecla']] = 1
  
  
  
 def name_map(data):
     if 'name' in data:
         return [('name', data['name'])]
  
  
 def name_tags(data):
     """This function returns two things: a 'pretty' name to use, and
        may return a landuse of either 'cemetery' or 'forest' if the name
        contains those words; based on evaluation the dataset in question."""
     tags = [] 
     name = data.get('site_name', None)
     if not name: 
         return
     name = name.title()
     
     if "cemetery" in name.lower():
         tags.append(['landuse', 'cemetery']) 
     elif "forest" in name.lower():
         tags.append(['landuse', 'forest']) 
  
     tags.append(['name', name])
     return tags
  
 def cal_date(data):
     """Return YYYY-MM-DD or YYYY formatted dates, based on 
        (m)m/(d)d/yyyy dates"""
     date = data.get('cal_date_r', None)
     if not date: return
     try:
         m, d, y = map(int, date.split("/"))
         if m == 1 and d == 1:
             return [['start_date', '%4i' % y]]
         return [['start_date', '%04i-%02i-%02i' % (y, m, d)]] 
     except:
         print("Invalid date: %s" % date)
         eflag = True
         return None
  
 # The most important part of the code: define a set of key/value pairs
 # to iterate over to generate keys. This is a list of two-tuples: first
 # is a 'key', which is only used if the second value is a string. In
 # that case, it is a map of lowercased fielnames to OSM tag names: so
 # fee_owner maps to 'owner' in the OSM output.
  
 # if the latter is callable (has a __call__; is a function), then that
 # method is called, passing in a dict of feature attributes with
 # lowercased key names. Those functions can then return a list of
 # two-tuples to be used as tags, or nothin' to skip the tags.  
  
  
 tag_mapping = [ 
     ('fee_owner', 'owner'),
     ('cal_date', cal_date),
     ('pub_access', access),
     ('lev_prot', protection),
     ('owner_type', owner_type),
     ('prim_purp', purpose),
     ('site_name', name_tags),
     ('featurecla', feature_class),
     ('name', name_map)
 ]    
  
 # These tags are not exported, even with the source data; this should be
 # used for tags which are usually calculated in a GIS. AREA and LEN are
 # common.
  
 boring_tags = [ 'AREA', 'LEN', 'GIS_ACRES']
  
 # Namespace is used to prefix existing data attributes. If 'None', or 
 # '--no-source' is set, then source attributes are not exported, only
 # attributes in tag_mapping.
  
 namespace = "natural_earth"
 #namespace = None 
  
 # Uncomment the "DONT_RUN = False" line to get started. 
  
 #DONT_RUN = True
 DONT_RUN = False
  
 # =========== DO NOT CHANGE AFTER THIS LINE. ===========================
 # Below here is regular code, part of the file. This is not designed to
 # be modified by users.
 # ======================================================================
  
 import sys
  
 try:
     try:
         from osgeo import ogr
     except ImportError:
         import ogr
         eflag = True
 except ImportError:
     __doc__ += gdal_install 
     if DONT_RUN:
         print(__doc__)
         sys.exit(2)
     print("OGR Python Bindings not installed.\n%s" % gdal_install)
     sys.exit(1)
     eflag = True
  
 def close_file():
     """ Internal. Close an open file."""
     global open_file
     if not open_file.closed: 
         open_file.write("</osm>")
         open_file.close()
  
 def start_new_file():
     """ Internal. Open a new file, closing existing file if neccesary."""
     global open_file, file_counter, node_dict, file_name
     file_counter += 1
     if open_file:
         close_file()
     open_file = open("%s.%s.osm" % (file_name, file_counter), "w")
     print("<?xml version='1.0' encoding='UTF-8'?>" , end = '\n', file = open_file) 
     print("<osm version='0.5'>" , end = '\n', file = open_file)  
     node_dict = {}
 
 def write_osm_files():
     global nodes, ways, relations, element_indices, open_file, file_counter, file_name
     node_idx = 0
     way_idx = 0
     rel_idx = 0
     for indices in element_indices:
         start_new_file()
         while node_idx < indices[0]:
             write_node(nodes[node_idx])
             node_idx += 1
         while way_idx < indices[1]:
             write_way(ways[way_idx])
             way_idx += 1
         while rel_idx < indices[2]:
             write_relation_multipolygon(relations[rel_idx])
             rel_idx += 1
         close_file()
     element_indices = []
 
  
 def clean_attr(val):
     """Internal. Hacky way to make attribute XML safe."""
     val = str(val)
     val = val.replace("&", "&amp;").replace("'", "&quot;").replace("<", "&lt;").replace(">", "&gt;").strip()
     return val
 
 def check_featurecla(f):
     """
      Checks if featurecla field is present in the feature f.
      If present it implies that shp data is from Natural Earth dataset
     """
     if 'featurecla' in f.keys():
         return True
     else:
         return False
  
 def add_point(f):
     """Adds a point geometry to the OSM file"""
     global id_counter
     airport_metadata = None
     pt = f.GetGeometryRef()
     if check_featurecla(f):
         if f['featurecla'] == 'Airport':
             airport_metadata = f
             f = None
     node_id = add_node(id_counter, pt.GetX(0), pt.GetY(0), 'POINT', f)
     if node_id == id_counter:
         id_counter += 1
     if airport_metadata != None:
         add_way_around_node(airport_metadata)
     
     
  
 def add_relation_multipolygon(geom, f):
     """ Writes the multipolygon relation to the OSM file, returns 0 if no relation is formed"""
     global id_counter, file_counter, counter, file_name, open_file, namespace
     rel_ways = []
     rel_id = 0
     way_id = add_way(geom.GetGeometryRef(0), f, True)
     if way_id == None:
         print('Error in writing relation')
         return None
     rel_ways.append(way_id)
  
     if geom.GetGeometryCount() > 1:
         for i in range(1, geom.GetGeometryCount()):
             way_id = add_way(geom.GetGeometryRef(i), f, False)
             if way_id == None:
                 print('Error in writing relation')
                 return None
             rel_ways.append(way_id)
         rel_id = id_counter
         if check_featurecla(f):
             if f['featurecla'] in non_polygons:
                 return 0 #means no relation is there
         relations.append((rel_id, rel_ways))
         id_counter += 1
  
     return rel_id   #if rel_id return 0, means no relations is there
  
 def write_relation_multipolygon(relation):
     global open_file
     print("<relation id='-%s'><tag k='type' v='multipolygon' />" % relation[0] , end = '\n', file = open_file)  
     print('<member type="way" ref="-%s" role="outer" />' % relation[1][0] , end = '\n', file = open_file)    
     for way in relation[1][1:]:
         print('<member type="way" ref="-%s" role="inner" />' % way  , end = '\n', file = open_file)
     print("</relation>" , end = '\n', file = open_file)
  
 def write_tags(f):
     """Writes the tags associated with a way or a relation"""
     global id_counter, file_counter, counter, file_name, open_file, namespace
     field_count = f.GetFieldCount()
     fields  = {}
     for field in range(field_count):
         value = f.GetFieldAsString(field)
         name = f.GetFieldDefnRef(field).GetName()
         if namespace and name and value and name not in boring_tags:
             print(" <tag k='%s:%s' v='%s' />" % (namespace, name, clean_attr(value)) , end = '\n', file = open_file)
         fields[name.lower()] = value
     tags={}
     for tag_name, map_value in tag_mapping:
         if hasattr(map_value, '__call__'):
             tag_values = map_value(fields)
             if tag_values:
                 for tag in tag_values:
                     tags[tag[0]] = tag[1]
         else:
             if tag_name in fields:
                 tags[map_value] = fields[tag_name].title()
     for key, value in tags.items():
         if key and value:
             print(" <tag k='%s' v='%s' />" % (key, clean_attr(value))  , end = '\n', file = open_file)   
     for name, value in fixed_tags.items():
         print(" <tag k='%s' v='%s' />" % (name, clean_attr(value)) , end = '\n', file = open_file)   
     if f.GetGeometryRef().GetGeometryName() == 'POLYGON' or f.GetGeometryRef().GetGeometryName() == 'MULTIPOLYGON':
         if check_featurecla(f):
             if f['featurecla'] not in non_polygons:
                 print(" <tag k='area' v='yes' />" , end = '\n', file = open_file)  
  
 def add_way(geom, f, tag_flag):
     """ Writes the way of a particular geometry to the OSM file"""
     global open_file, id_counter, ways
     ids = add_way_nodes(geom, f)
     if len(ids) == 0:
         print('Error in writing way')
         return None
     way_id = id_counter
     id_counter += 1
     node_refs = ids
     if tag_flag:
         tags = f
     else:
         tags = None
     ways.append((way_id, node_refs, tags))
     return way_id
  
 def write_way(way):
     global open_file
     print("<way id='-%s'>" % way[0] , end = '\n', file = open_file)  
     for i in way[1]:
         print(" <nd ref='-%s' />" % i , end = '\n', file = open_file)  
     if way[2]:
         write_tags(way[2])
     print("</way>", end = '\n', file = open_file)  
  
 def add_way_nodes(geom, f):
     """Writes the nodes of a particular way"""
     global open_file, id_counter
     ids = []
     geom_name = geom.GetGeometryName()
     pt_count = geom.GetPointCount()
     if geom_name == 'LINESTRING':
         range_count = range(geom.GetPointCount())
     else:
         range_count = range(geom.GetPointCount() - 1)
     if range_count == 0 or pt_count == 0:
         print( "Degenerate ", geom_name , end = '\n', file = sys.stderr)  
         return
     #if geom_name != 'LINESTRING':
     #    pt_count -= 1
     for count in range(pt_count):
         node_id = add_node(id_counter, geom.GetX(count), geom.GetY(count), geom_name, f)
         if node_id == id_counter:   #means a new node is created, if not means node already exists
             id_counter += 1
         ids.append(node_id)
     return ids   
  
  
 def add_node(num_id, lon, lat, geom_name, f):
     """ Writes the node to the OSM file"""
     global open_file, node_dict
     key = (lon, lat)
     if geom_name == 'POINT':
         nodes.append((num_id, lon, lat, f))
         node_dict[key] = num_id
     else:
         if key in node_dict:
             num_id = node_dict[key]
         else:
             nodes.append((num_id, lon, lat, None))
             node_dict[key] = num_id
     return num_id
  
 def write_node(node):
     global open_file
     if node[3] == None:
         print("<node id='-{}' visible='true' lon='{:.10f}' lat='{:.10f}' />".format(node[0], node[1], node[2]), end = '\n', file = open_file)   
     else:
         print("<node id='-{}' visible='true' lon='{:.10f}' lat='{:.10f}' >".format(node[0], node[1], node[2]), end = '\n', file = open_file)
         write_tags(node[3]) 
         print("</node>", end = '\n', file = open_file)
  
 def add_way_around_node(f):
     """ Writes a way around a single point"""
     global id_counter, ways
     nid = id_counter - 1
     ways.append((id_counter, [nid], f))
     id_counter += 1
     
  
 open_file = None
  
 file_name = None 
  
 id_counter = 1
  
 file_counter = 0
 counter = 0
  
 geom_counter = {}
  
 class AppError(Exception): pass
  
 def run(filenames, slice_count=1, obj_count=5000000, output_location=None, no_source=False):
     """Run the converter. Requires open_file, file_name, id_counter,
     file_counter, counter to be defined in global space; not really a very good
     singleton."""
     global id_counter, file_counter, counter, file_name, open_file, namespace, non_geom, non_fcla_dict, nodes, ways, relations, geom_counter
     open_file = None
  
     file_name = None 
  
     id_counter = 1
  
     file_counter = 0
     counter = 0
  
     geom_counter = {}
     node_dict = {}
     if output_location:
        file_name = output_location
     # start_new_file()
     for filename in filenames:
         non_geom = 0
         non_fcla_dict = {}
         
         if no_source:
             namespace=None
  
         ds = ogr.Open(filename)
         if not ds:
             raise AppError("OGR Could not open the file %s" % filename)
             eflag = True
         l = ds.GetLayer(0)
        
         max_objs_per_file = obj_count 
  
         extent = l.GetExtent()
         #if extent[0] < -180 or extent[0] > 180 or extent[2] < -90 or extent[2] > 90:
         #   raise AppError("Extent does not look like degrees; are you sure it is? \n(%s, %s, %s, %s)" % (extent[0], extent[2], extent[1], extent[3]))  
         slice_width = (extent[1] - extent[0]) / slice_count
  
         seen = {}
  
         print("Running %s slices with %s base filename against shapefile %s" % (
                 slice_count, file_name, filename))
  
         for i in range(slice_count): 
  
             l.ResetReading()
             l.SetSpatialFilterRect(extent[0] + slice_width * i, extent[2], extent[0] + (slice_width * (i + 1)), extent[3])
  
             #start_new_file()
             f = l.GetNextFeature()
             
             obj_counter = 0
             last_obj_split = 0
  
             while f:
                 start_id_counter = id_counter
                 if f.GetFID() in seen:
                     f = l.GetNextFeature()
                     continue
                 seen[f.GetFID()] = True             
                 
                 if (obj_counter - last_obj_split) > max_objs_per_file:
                     print("Splitting file with %s objs" % (obj_counter - last_obj_split))
                     #start_new_file()
                     last_obj_split = obj_counter
                     element_indices.append((len(nodes), len(ways), len(relations)))
                     node_dict = {} 
                 feat_dict = f.items()
                 geom = f.GetGeometryRef()
                 geom_name = geom.GetGeometryName()
                 if geom_name in geom_counter:
                     geom_counter[geom_name] += 1
                 else:
                     geom_counter[geom_name] = 1
                 if geom_name == 'POLYGON':
                     rel_id = add_relation_multipolygon(geom, f)
                     if rel_id == None:
                         f = l.GetNextFeature()
                         continue
                 elif geom_name == 'LINESTRING':
                     way_id = add_way(geom, f, True)
                     if way_id == None:
                         f = l.GetNextFeature()
                         continue
                 elif geom_name == 'MULTILINESTRING':
                     for i in range(geom.GetGeometryCount()):
                         way_id = add_way(geom.GetGeometryRef(i), f, True)
                         if way_id == None:
                             f = l.GetNextFeature()
                             continue
                 elif geom_name == 'MULTIPOLYGON':
                     for i in range(geom.GetGeometryCount()):
                         rel_id = add_relation_multipolygon(geom.GetGeometryRef(i), f)
                         if rel_id == None:
                             f = l.GetNextFeature()
                             continue
                 elif geom_name == 'POINT':
                     add_point(f)
                 else:
                     ids = []
                     non_geom += 1       
                         
                 counter += 1
                 f = l.GetNextFeature()
                 obj_counter += (id_counter - start_id_counter)
  
     # for node in nodes:
     #     write_node(node)
     # for way in ways:
     #     write_way(way)
     # for relation in relations:
     #     write_relation_multipolygon(relation)
 
     element_indices.append((len(nodes), len(ways), len(relations))) 
     write_osm_files()
                     
     # close_file()
     nodes = []  #(id, lon, lat, tags)
     ways = []  #(id, node_refs, tags)
     relations = []  #(id, ways)
  
 if __name__ == "__main__":
     if DONT_RUN:
         print(__doc__)
         sys.exit(2)
     
     from optparse import OptionParser
     
     parse = OptionParser(usage="%prog [args] filename.shp", version=__version__)
     parse.add_option("-s", "--slice-count", dest="slice_count", 
                      help="Number of horizontal slices of data", default=1, 
                      action="store", type="int")
     parse.add_option("-o", "--obj-count", 
                      dest="obj_count", 
                      help="Target Maximum number of objects in a single .osm file", 
                      default=5000000, type="int")
     parse.add_option("-n", "--no-source", dest="no_source", 
                      help="Do not store source attributes as tags.",
                      action="store_true", default=False)
     parse.add_option("-l", "--output-location", 
                         dest="output_location", help="base filepath for output files.", 
                         default="poly_output") 
     (options, args) = parse.parse_args()
     
     if not len(args):
         print("No shapefile name given!")
         parse.print_help()
         sys.exit(3)
  
     kw = {}
     for key in  ('slice_count', 'obj_count', 'output_location', 'no_source'):
         kw[key] = getattr(options, key)
     
     try:
         run(args, **kw)
     except AppError as E:
         print("An error occurred: \n%s" % E)
         eflag = True
  
     print() 
     print('Geometry types present: ')
     for key in geom_counter:
         print(key, geom_counter[key])
     print() 
     print('Feature type present: ')
     for key in feat_dict:
         print(key, feat_dict[key])
     print()
  
     
     if eflag:
         print('Conversion not Successful :')
     else:
         if len(non_fcla_dict) == 0 and non_geom == 0:
             print('Conversion Successful')
         else:
             print('Conversion not Successful :')
             if len(non_fcla_dict) != 0:
                 print('Unknown features present in SHP file: ', len(non_fcla_dict))
                 print() 
                 for key in non_fcla_dict:
                     print(key, non_fcla_dict[key])
             if non_geom != 0:
                 print('Unknown geometry present in SHP file: ', non_geom)