File indexing completed on 2024-05-19 03:51:39

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2011 Konstantin Oblaukhov <oblaukhov.konstantin@gmail.com>
 //
 
 #include "AbstractGeoPolygonGraphicsItem.h"
 
 #include "GeoDataLinearRing.h"
 #include "GeoDataPolygon.h"
 #include "GeoDataBuilding.h"
 #include "GeoPainter.h"
 #include "GeoDataLatLonAltBox.h"
 #include "GeoDataStyle.h"
 #include "GeoDataIconStyle.h"
 #include "GeoDataLineStyle.h"
 #include "GeoDataPlacemark.h"
 #include "GeoDataPolyStyle.h"
 #include "OsmPlacemarkData.h"
 #include "MarbleDebug.h"
 #include "ViewportParams.h"
 
 #include <QtMath>
 #include <QImageReader>
 #include <QPixmapCache>
 
 namespace Marble
 {
 
 const void *AbstractGeoPolygonGraphicsItem::s_previousStyle = nullptr;
 
 AbstractGeoPolygonGraphicsItem::AbstractGeoPolygonGraphicsItem(const GeoDataPlacemark *placemark, const GeoDataPolygon *polygon) :
     GeoGraphicsItem(placemark),
     m_polygon(polygon),
     m_ring(nullptr),
     m_building(nullptr)
 {
 }
 
 AbstractGeoPolygonGraphicsItem::AbstractGeoPolygonGraphicsItem(const GeoDataPlacemark *placemark, const GeoDataLinearRing *ring) :
     GeoGraphicsItem(placemark),
     m_polygon(nullptr),
     m_ring(ring),
     m_building(nullptr)
 {
 }
 
 AbstractGeoPolygonGraphicsItem::AbstractGeoPolygonGraphicsItem(const GeoDataPlacemark *placemark, const GeoDataBuilding *building) :
     GeoGraphicsItem(placemark),
     m_polygon(nullptr),
     m_ring(nullptr),
     m_building(building)
 {
 }
 
 AbstractGeoPolygonGraphicsItem::~AbstractGeoPolygonGraphicsItem()
 {
 }
 
 const GeoDataLatLonAltBox& AbstractGeoPolygonGraphicsItem::latLonAltBox() const
 {
     if(m_polygon) {
         return m_polygon->latLonAltBox();
     } else if (m_ring) {
         return m_ring->latLonAltBox();
     }
 
     return m_building->latLonAltBox();
 }
 
 void AbstractGeoPolygonGraphicsItem::paint( GeoPainter* painter, const ViewportParams* viewport, const QString &layer, int tileZoomLevel)
 {
     Q_UNUSED(layer);
     Q_UNUSED(tileZoomLevel);
 
     bool isValid = true;
     if (s_previousStyle != style().data()) {
         isValid = configurePainter(painter, *viewport);
     }
     s_previousStyle = style().data();
 
     if (!isValid) return;
 
     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 );
     }
 }
 
 bool AbstractGeoPolygonGraphicsItem::contains(const QPoint &screenPosition, const ViewportParams *viewport) const
 {
     auto const visualCategory = static_cast<const GeoDataPlacemark*>(feature())->visualCategory();
     if (visualCategory == GeoDataPlacemark::Landmass ||
             visualCategory == GeoDataPlacemark::UrbanArea ||
             (visualCategory >= GeoDataPlacemark::LanduseAllotments && visualCategory <= GeoDataPlacemark::LanduseVineyard)) {
         return false;
     }
 
     double lon, lat;
     viewport->geoCoordinates(screenPosition.x(), screenPosition.y(), lon, lat, GeoDataCoordinates::Radian);
     auto const coordinates = GeoDataCoordinates(lon, lat);
     if (m_polygon) {
         return m_polygon->contains(coordinates);
     } else if (m_ring) {
         return m_ring->contains(coordinates);
     }
     return false;
 }
 
 bool AbstractGeoPolygonGraphicsItem::configurePainter(GeoPainter *painter, const ViewportParams &viewport) const
 {
     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()) {
             const GeoDataLineStyle& lineStyle = style->lineStyle();
 
             // To save performance we avoid making changes to the painter's pen.
             // So we first take a copy of the actual painter pen, make changes to it
             // and only if the resulting pen is different from the actual pen
             // we replace the painter's pen with our new pen.
 
             // We want to avoid the mandatory detach in QPen::setColor(),
             // so we carefully check whether applying the setter is needed
             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);
             }
         }
         else {
             // polygons without outline: Qt::NoPen (not drawn)
             if (currentPen.style() != Qt::NoPen) {
                 painter->setPen(Qt::NoPen);
             }
         }
 
         if (!polyStyle.fill()) {            
             painter->setBrush(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(), paintedColor));
                     painter->setBrush(brush);
                     painter->setBrushOrigin(QPoint(x,y));
                 }
                 else {
                     painter->setBrush(QBrush(paintedColor, polyStyle.brushStyle()));
                 }
             }
         }
     }
 
     return true;
 }
 
 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 QColor &color) const
 {
     QString const key = QString::number(color.rgba()) + '/' + texturePath;
     QPixmap texture;
     if (!QPixmapCache::find(key, &texture)) {
         QImageReader imageReader(style()->polyStyle().resolvePath(texturePath));
         texture = QPixmap::fromImageReader(&imageReader);
 
         if (texture.hasAlphaChannel()) {
             QPixmap pixmap (texture.size());
             pixmap.fill(color);
             QPainter imagePainter(&pixmap);
             imagePainter.drawPixmap(0, 0, texture);
             imagePainter.end();
             texture = pixmap;
         }
         QPixmapCache::insert(key, texture);
     }
     return texture;
 }
 
 void AbstractGeoPolygonGraphicsItem::setLinearRing(GeoDataLinearRing *ring)
 {
     Q_ASSERT(m_building);
     Q_ASSERT(!m_polygon);
     m_ring = ring;
 }
 
 void AbstractGeoPolygonGraphicsItem::setPolygon(GeoDataPolygon *polygon)
 {
     Q_ASSERT(m_building);
     Q_ASSERT(!m_ring);
     m_polygon = polygon;
 }
 
 }