diff --git a/src/lib/marble/geodata/graphicsitem/AbstractGeoPolygonGraphicsItem.cpp b/src/lib/marble/geodata/graphicsitem/AbstractGeoPolygonGraphicsItem.cpp
index 9bc6774fd..3227b0ac1 100644
--- a/src/lib/marble/geodata/graphicsitem/AbstractGeoPolygonGraphicsItem.cpp
+++ b/src/lib/marble/geodata/graphicsitem/AbstractGeoPolygonGraphicsItem.cpp
@@ -1,175 +1,173 @@
 //
 // 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      Konstantin Oblaukhov <oblaukhov.konstantin@gmail.com>
 //
 
 #include "AbstractGeoPolygonGraphicsItem.h"
 
 #include "GeoDataLinearRing.h"
 #include "GeoDataPolygon.h"
 #include "GeoPainter.h"
 #include "GeoDataLatLonAltBox.h"
 #include "GeoDataStyle.h"
 #include "GeoDataIconStyle.h"
 #include "GeoDataLineStyle.h"
 #include "GeoDataPlacemark.h"
 #include "GeoDataPolyStyle.h"
 #include "GeoDataTypes.h"
 #include "OsmPlacemarkData.h"
 #include "MarbleDebug.h"
 #include "ViewportParams.h"
 
 #include <QtMath>
 
 namespace Marble
 {
 
 QPixmapCache AbstractGeoPolygonGraphicsItem::m_textureCache = QPixmapCache();
 
 AbstractGeoPolygonGraphicsItem::AbstractGeoPolygonGraphicsItem(const GeoDataPlacemark *placemark, const GeoDataPolygon *polygon) :
     GeoGraphicsItem(placemark),
     m_polygon(polygon),
     m_ring(0)
 {
 }
 
 AbstractGeoPolygonGraphicsItem::AbstractGeoPolygonGraphicsItem(const GeoDataPlacemark *placemark, const GeoDataLinearRing *ring) :
     GeoGraphicsItem(placemark),
     m_polygon(0),
     m_ring(ring)
 {
 }
 
 AbstractGeoPolygonGraphicsItem::~AbstractGeoPolygonGraphicsItem()
 {
 }
 
 const GeoDataLatLonAltBox& AbstractGeoPolygonGraphicsItem::latLonAltBox() const
 {
     if( m_polygon ) {
         return m_polygon->latLonAltBox();
     }
 
     return m_ring->latLonAltBox();
 }
 
 void AbstractGeoPolygonGraphicsItem::paint( GeoPainter* painter, const ViewportParams* viewport, const QString &layer, int tileZoomLevel)
 {
     Q_UNUSED(layer);
     Q_UNUSED(tileZoomLevel);
 
     painter->save();
     configurePainter(painter, viewport);
     if ( m_polygon ) {
         bool innerResolved = false;
 
         for(auto const & ring : m_polygon->innerBoundaries()) {
             if (viewport->resolves(ring.latLonAltBox(), 4)) {
                innerResolved = true;
                break;
             }
         }
 
         if (innerResolved) {
             painter->drawPolygon(*m_polygon);
         }
         else {
             painter->drawPolygon(m_polygon->outerBoundary());
         }
     } else if ( m_ring ) {
         painter->drawPolygon( *m_ring );
     }
 
     painter->restore();
 }
 
 QPen AbstractGeoPolygonGraphicsItem::configurePainter(GeoPainter *painter, const ViewportParams *viewport)
 {
     QPen currentPen = painter->pen();
 
     GeoDataStyle::ConstPtr style = this->style();
     if (!style) {
         painter->setPen( QPen() ); // "style-less" polygons: a 1px black solid line
     }
     else {
         const GeoDataPolyStyle& polyStyle = style->polyStyle();
 
         if (polyStyle.outline()) { // polygons without outline: Qt::NoPen (not drawn)
             const GeoDataLineStyle& lineStyle = style->lineStyle();
 
             currentPen.setColor(lineStyle.paintedColor());
             currentPen.setWidthF(lineStyle.width());
             currentPen.setCapStyle(lineStyle.capStyle());
             currentPen.setStyle(lineStyle.penStyle());
 
             if (painter->pen().color() != currentPen.color()) {
                 painter->setPen(currentPen);
             }
         }
 
         if (!polyStyle.fill()) {
             painter->setBrush(QColor(Qt::transparent));
         }
         else {
             const QColor paintedColor = polyStyle.paintedColor();
             if (painter->brush().color() != paintedColor ||
                 painter->brush().style() != polyStyle.brushStyle()) {
                 if (!polyStyle.texturePath().isEmpty() || !polyStyle.textureImage().isNull()) {
                     GeoDataCoordinates coords = latLonAltBox().center();
                     qreal x, y;
                     viewport->screenCoordinates(coords, x, y);
-                    QBrush brush(texture(polyStyle.texturePath(), polyStyle.textureImage(), paintedColor));
+                    QBrush brush(texture(polyStyle.texturePath(), paintedColor));
                     painter->setBrush(brush);
                     painter->setBrushOrigin(QPoint(x,y));
                 }
                 else {
                     painter->setBrush(QBrush(paintedColor, polyStyle.brushStyle()));
                 }
             }
         }
     }
 
     return currentPen;
 }
 
 int AbstractGeoPolygonGraphicsItem::extractElevation(const GeoDataPlacemark &placemark)
 {
     int elevation = 0;
 
     const OsmPlacemarkData &osmData = placemark.osmData();
 
     const auto tagIter = osmData.findTag(QStringLiteral("ele"));
     if (tagIter != osmData.tagsEnd()) {
         elevation = tagIter.value().toInt();
     }
 
     return elevation;
 }
 
-QPixmap AbstractGeoPolygonGraphicsItem::texture(const QString &texturePath, const QImage &textureImage, const QColor &color)
+QPixmap AbstractGeoPolygonGraphicsItem::texture(const QString &texturePath, const QColor &color)
 {
     QString const key = QString("%1/%2").arg(color.rgba()).arg(texturePath);
     QPixmap texture;
     if (!m_textureCache.find(key, texture)) {
-        if (textureImage.hasAlphaChannel()) {
-            QImage image (textureImage.size(), QImage::Format_ARGB32_Premultiplied);
-            image.fill(color);
-            QPainter imagePainter(&image);
-            imagePainter.drawImage(0, 0, textureImage);
+        texture.load(style()->polyStyle().resolvePath(texturePath));
+        if (texture.hasAlphaChannel()) {
+            QPixmap pixmap (texture.size());
+            pixmap.fill(color);
+            QPainter imagePainter(&pixmap);
+            imagePainter.drawPixmap(0, 0, texture);
             imagePainter.end();
-            texture = QPixmap::fromImage(image);
-        }
-        else {
-            texture = QPixmap::fromImage(textureImage);
+            texture = pixmap;
         }
         m_textureCache.insert(key, texture);
     }
     return texture;
 }
 
 }
diff --git a/src/lib/marble/geodata/graphicsitem/AbstractGeoPolygonGraphicsItem.h b/src/lib/marble/geodata/graphicsitem/AbstractGeoPolygonGraphicsItem.h
index 4171e169c..41baa7c6a 100644
--- a/src/lib/marble/geodata/graphicsitem/AbstractGeoPolygonGraphicsItem.h
+++ b/src/lib/marble/geodata/graphicsitem/AbstractGeoPolygonGraphicsItem.h
@@ -1,58 +1,58 @@
 //
 // 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      Konstantin Oblaukhov <oblaukhov.konstantin@gmail.com>
 //
 
 #ifndef MARBLE_ABSTRACTGEOPOLYGONGRAPHICSITEM_H
 #define MARBLE_ABSTRACTGEOPOLYGONGRAPHICSITEM_H
 
 #include "GeoGraphicsItem.h"
 #include "marble_export.h"
 
 #include <QImage>
 #include <QColor>
 #include <QPixmapCache>
 
 namespace Marble
 {
 
 class GeoDataLinearRing;
 class GeoDataPlacemark;
 class GeoDataPolygon;
 
 class MARBLE_EXPORT AbstractGeoPolygonGraphicsItem : public GeoGraphicsItem
 {
 protected:
     explicit AbstractGeoPolygonGraphicsItem(const GeoDataPlacemark *placemark, const GeoDataPolygon *polygon);
     explicit AbstractGeoPolygonGraphicsItem(const GeoDataPlacemark *placemark, const GeoDataLinearRing *ring);
     ~AbstractGeoPolygonGraphicsItem();
 
 public:
     virtual const GeoDataLatLonAltBox& latLonAltBox() const;
     virtual void paint(GeoPainter* painter, const ViewportParams *viewport, const QString &layer, int tileZoomLevel);
 
 protected:
     QPen configurePainter(GeoPainter* painter, const ViewportParams *viewport);
     inline
     const GeoDataPolygon *polygon() const { return m_polygon; }
     inline
     const GeoDataLinearRing *ring() const { return m_ring; }
 
     static int extractElevation(const GeoDataPlacemark &placemark);
 
 private:
-    QPixmap texture(const QString &path, const QImage &textureImage, const QColor &color);
+    QPixmap texture(const QString &path, const QColor &color);
 
     const GeoDataPolygon *const m_polygon;
     const GeoDataLinearRing *const m_ring;
     static QPixmapCache m_textureCache;
 };
 
 }
 
 #endif