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

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2011 Konstantin Oblaukhov <oblaukhov.konstantin@gmail.com>
 //
 
 #include "BuildingGraphicsItem.h"
 
 #include "MarbleDebug.h"
 #include "ViewportParams.h"
 #include "GeoDataPlacemark.h"
 #include "GeoDataLinearRing.h"
 #include "GeoDataPolygon.h"
 #include "GeoDataBuilding.h"
 #include "GeoDataMultiGeometry.h"
 #include "GeoDataPolyStyle.h"
 #include "OsmPlacemarkData.h"
 #include "GeoPainter.h"
 
 #include <QScreen>
 #include <QApplication>
 
 namespace Marble
 {
 
 BuildingGraphicsItem::BuildingGraphicsItem(const GeoDataPlacemark *placemark, const GeoDataBuilding *building)
     : AbstractGeoPolygonGraphicsItem(placemark, building)
 {
     if (const auto ring = geodata_cast<GeoDataLinearRing>(&building->multiGeometry()->at(0))) {
         setLinearRing(ring);
     } else if (const auto poly = geodata_cast<GeoDataPolygon>(&building->multiGeometry()->at(0))) {
         setPolygon(poly);
     }
 
     setZValue(building->height());
     Q_ASSERT(building->height() > 0.0);
 
     QStringList paintLayers;
     paintLayers << QStringLiteral("Polygon/Building/frame")
                 << QStringLiteral("Polygon/Building/roof");
     setPaintLayers(paintLayers);
 }
 
 BuildingGraphicsItem::~BuildingGraphicsItem()
 {
     qDeleteAll(m_cachedOuterPolygons);
     qDeleteAll(m_cachedInnerPolygons);
     qDeleteAll(m_cachedOuterRoofPolygons);
     qDeleteAll(m_cachedInnerRoofPolygons);
 }
 
 void BuildingGraphicsItem::initializeBuildingPainting(const GeoPainter* painter, const ViewportParams *viewport,
                                                       bool &drawAccurate3D, bool &isCameraAboveBuilding ) const
 {
     drawAccurate3D = false;
     isCameraAboveBuilding = false;
 
     auto const screen = QApplication::screens().first();
     double const physicalSize = 1.0; // mm
     int const pixelSize = qRound(physicalSize * screen->physicalDotsPerInch() / (IN2M * M2MM));
 
     QPointF offsetAtCorner = buildingOffset(QPointF(0, 0), viewport, &isCameraAboveBuilding);
     qreal maxOffset = qMax( qAbs( offsetAtCorner.x() ), qAbs( offsetAtCorner.y() ) );
     drawAccurate3D = painter->mapQuality() == HighQuality ? maxOffset > pixelSize : maxOffset > 1.5 * pixelSize;
 }
 
 // backface culling for the perspective drawing below assumes all polygons in clockwise order
 static void normalizeWindingOrder(QPolygonF *polygon)
 {
     double c = 0;
     for (int i = 0; i <polygon->size(); ++i) {
         c += (polygon->at((i + 1) % polygon->size()).x() - polygon->at(i).x()) * (polygon->at(i).y() + polygon->at((i + 1) % polygon->size()).y());
     }
     if (c < 0) {
         std::reverse(polygon->begin(), polygon->end());
     }
 }
 
 void BuildingGraphicsItem::updatePolygons(const ViewportParams &viewport,
                                           QVector<QPolygonF*>& outerPolygons,
                                           QVector<QPolygonF*>& innerPolygons,
                                           bool &hasInnerBoundaries) const
 {
     // Since subtracting one fully contained polygon from another results in a single
     // polygon with a "connecting line" between the inner and outer part we need
     // to first paint the inner area with no pen and then the outlines with the correct pen.
     hasInnerBoundaries = polygon() ? !polygon()->innerBoundaries().isEmpty() : false;
     if (polygon()) {
         if (hasInnerBoundaries) {
             screenPolygons(viewport, polygon(), innerPolygons, outerPolygons);
         }
         else {
             viewport.screenCoordinates(polygon()->outerBoundary(), outerPolygons);
         }
     } else if (ring()) {
         viewport.screenCoordinates(*ring(), outerPolygons);
     }
     for (auto *polygon : outerPolygons) {
         normalizeWindingOrder(polygon);
     }
     for (auto *polygon : innerPolygons) {
         normalizeWindingOrder(polygon);
     }
 }
 
 QPointF BuildingGraphicsItem::centroid(const QPolygonF &polygon, double &area)
 {
     auto centroid = QPointF(0.0, 0.0);
     area = 0.0;
     for (auto i=0, n=polygon.size(); i<n; ++i) {
         auto const x0 = polygon[i].x();
         auto const y0 = polygon[i].y();
         auto const j = i == n-1 ? 0 : i+1;
         auto const x1 = polygon[j].x();
         auto const y1 = polygon[j].y();
         auto const a = x0*y1 - x1*y0;
         area += a;
         centroid.rx() += (x0 + x1)*a;
         centroid.ry() += (y0 + y1)*a;
     }
 
     area *= 0.5;
     return area != 0 ? centroid / (6.0*area) : polygon.boundingRect().center();
 }
 
 QPointF BuildingGraphicsItem::buildingOffset(const QPointF &point, const ViewportParams *viewport, bool* isCameraAboveBuilding) const
 {
     qreal const cameraFactor = 0.5 * tan(0.5 * 110 * DEG2RAD);
     Q_ASSERT(building()->height() > 0.0);
     qreal const buildingFactor = building()->height() / EARTH_RADIUS;
 
     qreal const cameraHeightPixel = viewport->width() * cameraFactor;
     qreal buildingHeightPixel = viewport->radius() * buildingFactor;
     qreal const cameraDistance = cameraHeightPixel-buildingHeightPixel;
 
     if (isCameraAboveBuilding) {
         *isCameraAboveBuilding = cameraDistance > 0;
     }
 
     qreal const cc = cameraDistance * cameraHeightPixel;
     qreal const cb = cameraDistance * buildingHeightPixel;
 
     // The following lines calculate the same result, but are potentially slower due
     // to using more trigonometric method calls
     // qreal const alpha1 = atan2(offsetX, cameraHeightPixel);
     // qreal const alpha2 = atan2(offsetX, cameraHeightPixel-buildingHeightPixel);
     // qreal const shiftX = 2 * (cameraHeightPixel-buildingHeightPixel) * sin(0.5*(alpha2-alpha1));
 
     qreal const offsetX = point.x() - viewport->width() / 2.0;
     qreal const offsetY = point.y() - viewport->height() / 2.0;
 
     qreal const shiftX = offsetX * cb / (cc + offsetX);
     qreal const shiftY = offsetY * cb / (cc + offsetY);
 
     return QPointF(shiftX, shiftY);
 }
 
 void BuildingGraphicsItem::paint(GeoPainter* painter, const ViewportParams* viewport, const QString &layer, int tileZoomLevel)
 {
     // Just display flat buildings for tile level 17
     if (tileZoomLevel == 17) {
         setZValue(0.0);
         if (layer.endsWith(QLatin1String("/roof"))) {
             AbstractGeoPolygonGraphicsItem::paint(painter, viewport, layer, tileZoomLevel );
         }
         return;
     }
     setZValue(building()->height());
 
     // For level 18, 19 .. render 3D buildings in perspective
     if (layer.endsWith(QLatin1String("/frame"))) {
         qDeleteAll(m_cachedOuterPolygons);
         qDeleteAll(m_cachedInnerPolygons);
         qDeleteAll(m_cachedOuterRoofPolygons);
         qDeleteAll(m_cachedInnerRoofPolygons);
         m_cachedOuterPolygons.clear();
         m_cachedInnerPolygons.clear();
         m_cachedOuterRoofPolygons.clear();
         m_cachedInnerRoofPolygons.clear();
         updatePolygons(*viewport, m_cachedOuterPolygons,
                                  m_cachedInnerPolygons,
                                  m_hasInnerBoundaries);
         if (m_cachedOuterPolygons.isEmpty()) {
             return;
         }
         paintFrame(painter, viewport);
     } else if (layer.endsWith(QLatin1String("/roof"))) {
         if (m_cachedOuterPolygons.isEmpty()) {
             return;
         }
         paintRoof(painter, viewport);
     } else {
         mDebug() << "Didn't expect to have to paint layer " << layer << ", ignoring it.";
     }
 }
 
 void BuildingGraphicsItem::paintRoof(GeoPainter* painter, const ViewportParams* viewport)
 {
     bool drawAccurate3D;
     bool isCameraAboveBuilding;
     initializeBuildingPainting(painter, viewport, drawAccurate3D, isCameraAboveBuilding);
     if (!isCameraAboveBuilding) {
         return; // do not render roof if we look inside the building
     }
 
     bool isValid = true;
     if (s_previousStyle != style().data()) {
         isValid = configurePainter(painter, *viewport);
 
         QFont font = painter->font(); // TODO: better font configuration
         if (font.pointSize() != 10) {
             font.setPointSize( 10 );
             painter->setFont(font);
         }
     }
     s_previousStyle = style().data();
 
     if (!isValid) return;
 
     // first paint the area (and the outline if there are no inner boundaries)
 
     if ( drawAccurate3D) {
         if (m_hasInnerBoundaries) {
 
             QPen const currentPen = painter->pen();
 
             painter->setPen(Qt::NoPen);
             QVector<QPolygonF*> fillPolygons =
                     painter->createFillPolygons( m_cachedOuterRoofPolygons,
                                                  m_cachedInnerRoofPolygons );
 
             for( const QPolygonF* fillPolygon: fillPolygons ) {
                 painter->drawPolygon(*fillPolygon);
             }
 
             painter->setPen(currentPen);
 
             for( const QPolygonF* outerRoof: m_cachedOuterRoofPolygons ) {
                 painter->drawPolyline( *outerRoof );
             }
             for( const QPolygonF* innerRoof: m_cachedInnerRoofPolygons ) {
                 painter->drawPolyline( *innerRoof );
             }
             qDeleteAll(fillPolygons);
         }
         else {
             for( const QPolygonF* outerRoof: m_cachedOuterRoofPolygons ) {
                 painter->drawPolygon( *outerRoof );
             }
         }
     }
     else {
         QPointF const offset = buildingOffset(m_cachedOuterPolygons[0]->boundingRect().center(), viewport);
         painter->translate(offset);
 
         if (m_hasInnerBoundaries) {
 
             QPen const currentPen = painter->pen();
 
             painter->setPen(Qt::NoPen);
             QVector<QPolygonF*> fillPolygons = painter->createFillPolygons( m_cachedOuterPolygons,
                                                                    m_cachedInnerPolygons );
 
             for( const QPolygonF* fillPolygon: fillPolygons ) {
                 painter->drawPolygon(*fillPolygon);
             }
 
             painter->setPen(currentPen);
 
             for( const QPolygonF* outerPolygon:  m_cachedOuterPolygons ) {
                 painter->drawPolyline( *outerPolygon );
             }
             for( const QPolygonF* innerPolygon:  m_cachedInnerPolygons ) {
                 painter->drawPolyline( *innerPolygon );
             }
             qDeleteAll(fillPolygons);
         }
         else {
             for( const QPolygonF* outerPolygon:  m_cachedOuterPolygons ) {
                 painter->drawPolygon( *outerPolygon );
             }
         }
         painter->translate(-offset);
 
     }
 
 
     qreal maxSize(0.0);
     double maxArea = 0.0;
 
     for (int i = 0; i < m_cachedOuterRoofPolygons.size(); ++i) {
         const QPolygonF *outerRoof = m_cachedOuterRoofPolygons[i];
 
         QPointF roofCenter;
 
         // Label position calculation
         if (!building()->name().isEmpty() || !building()->entries().isEmpty()) {
             QSizeF const polygonSize = outerRoof->boundingRect().size();
             qreal size = polygonSize.width() * polygonSize.height();
             if (size > maxSize) {
                 maxSize = size;
                 double area;
                 roofCenter = centroid(*outerRoof, area);
                 maxArea = qMax(area, maxArea);
             }
         }
 
         // Draw the housenumber labels
         if (drawAccurate3D && !building()->name().isEmpty() && !roofCenter.isNull()) {
             double const w2 = 0.5 * painter->fontMetrics().horizontalAdvance(building()->name());
             double const ascent = painter->fontMetrics().ascent();
             double const descent = painter->fontMetrics().descent();
             double const a2 = 0.5 * painter->fontMetrics().ascent();
             QPointF const textPosition = roofCenter - QPointF(w2, -a2);
             if (outerRoof->containsPoint(textPosition + QPointF(-2, -ascent), Qt::OddEvenFill)
                     && outerRoof->containsPoint(textPosition + QPointF(-2, descent), Qt::OddEvenFill)
                     && outerRoof->containsPoint(textPosition + QPointF(2+2*w2, descent), Qt::OddEvenFill)
                     && outerRoof->containsPoint(textPosition + QPointF(2+2*w2, -ascent), Qt::OddEvenFill)
                     ) {
                 painter->drawTextFragment(roofCenter.toPoint(), building()->name(),
                                          painter->font().pointSize(), painter->brush().color());
             }
         }
     }
 
     // Render additional housenumbers at building entries
     if (!building()->entries().isEmpty() && maxArea > 1600 * building()->entries().size()) {
         for(const auto &entry: building()->entries()) {
             qreal x, y;
             viewport->screenCoordinates(entry.point, x, y);
             QPointF point(x, y);
             point += buildingOffset(point, viewport);
             painter->drawTextFragment(point.toPoint(),
                                      building()->name(), painter->font().pointSize(), painter->brush().color(),
                                      GeoPainter::RoundFrame);
         }
     }
 }
 
 void BuildingGraphicsItem::paintFrame(GeoPainter *painter, const ViewportParams *viewport)
 {
     // TODO: how does this match the Q_ASSERT in the constructor?
     if (building()->height() == 0.0) {
         return;
     }
 
     if ((polygon() && !viewport->resolves(polygon()->outerBoundary().latLonAltBox(), 4))
             || (ring() && !viewport->resolves(ring()->latLonAltBox(), 4))) {
         return;
     }
 
     bool drawAccurate3D;
     bool isCameraAboveBuilding;
     initializeBuildingPainting(painter, viewport, drawAccurate3D, isCameraAboveBuilding);
 
     bool isValid = true;
     if (s_previousStyle != style().data()) {
         isValid = configurePainterForFrame(painter);
     }
     s_previousStyle = style().data();
 
     if (!isValid) return;
 
     if ( drawAccurate3D && isCameraAboveBuilding ) {
         for (const QPolygonF *outline: m_cachedOuterPolygons) {
             if (outline->isEmpty()) {
                 continue;
             }
             // draw the building sides
             int const size = outline->size();
             QPolygonF * outerRoof = new QPolygonF;
             outerRoof->reserve(outline->size());
             QPointF a = (*outline)[0];
             QPointF shiftA = a + buildingOffset(a, viewport);
             outerRoof->append(shiftA);
             for (int i=1; i<size; ++i) {
                 QPointF const & b = (*outline)[i];
                 QPointF const shiftB = b + buildingOffset(b, viewport);
                 // perform backface culling
                 bool backface = (b.x() - a.x()) * (shiftA.y() - a.y())
                         - (b.y() - a.y()) * (shiftA.x() - a.x()) >= 0;
                 if (!backface) {
                     QPolygonF buildingSide;
                     buildingSide.reserve(4);
                     buildingSide << a << shiftA << shiftB << b;
                     painter->drawPolygon(buildingSide);
                 }
                 a = b;
                 shiftA = shiftB;
                 outerRoof->append(shiftA);
             }
             m_cachedOuterRoofPolygons.append(outerRoof);
         }
         for (const QPolygonF *outline: m_cachedInnerPolygons) {
             if (outline->isEmpty()) {
                 continue;
             }
             // draw the building sides
             int const size = outline->size();
             QPolygonF * innerRoof = new QPolygonF;
             innerRoof->reserve(outline->size());
             QPointF a = (*outline)[0];
             QPointF shiftA = a + buildingOffset(a, viewport);
             innerRoof->append(shiftA);
             for (int i=1; i<size; ++i) {
                 QPointF const & b = (*outline)[i];
                 QPointF const shiftB = b + buildingOffset(b, viewport);
                 // perform backface culling
                 bool backface = (b.x() - a.x()) * (shiftA.y() - a.y())
                         - (b.y() - a.y()) * (shiftA.x() - a.x()) >= 0;
                 if (backface) {
                     QPolygonF buildingSide;
                     buildingSide.reserve(4);
                     buildingSide << a << shiftA << shiftB << b;
                     painter->drawPolygon(buildingSide);
                 }
                 a = b;
                 shiftA = shiftB;
                 innerRoof->append(shiftA);
             }
             m_cachedInnerRoofPolygons.append(innerRoof);
         }
     } else {
             // don't draw the building sides - just draw the base frame instead
             QVector<QPolygonF*> fillPolygons = painter->createFillPolygons( m_cachedOuterPolygons,
                                                                    m_cachedInnerPolygons );
 
             for( QPolygonF* fillPolygon: fillPolygons ) {
                 painter->drawPolygon(*fillPolygon);
             }
             qDeleteAll(fillPolygons);
     }
 }
 
 void BuildingGraphicsItem::screenPolygons(const ViewportParams &viewport, const GeoDataPolygon *polygon,
                                                     QVector<QPolygonF *> &innerPolygons,
                                                     QVector<QPolygonF *> &outerPolygons
                                                     )
 {
     Q_ASSERT(polygon);
 
     viewport.screenCoordinates(polygon->outerBoundary(), outerPolygons);
 
     QVector<GeoDataLinearRing> const & innerBoundaries = polygon->innerBoundaries();
     for (const GeoDataLinearRing &innerBoundary: innerBoundaries) {
         QVector<QPolygonF*> innerPolygonsPerBoundary;
         viewport.screenCoordinates(innerBoundary, innerPolygonsPerBoundary);
 
         innerPolygons.reserve(innerPolygons.size() + innerPolygonsPerBoundary.size());
         for( QPolygonF* innerPolygonPerBoundary: innerPolygonsPerBoundary ) {
             innerPolygons << innerPolygonPerBoundary;
         }
     }
 }
 
 bool BuildingGraphicsItem::contains(const QPoint &screenPosition, const ViewportParams *viewport) const
 {
     if (m_cachedOuterPolygons.isEmpty()) {
         // Level 17
         return AbstractGeoPolygonGraphicsItem::contains(screenPosition, viewport);
     }
 
     QPointF const point = screenPosition;
     for (auto polygon: m_cachedOuterRoofPolygons) {
         if (polygon->containsPoint(point, Qt::OddEvenFill)) {
             for (auto polygon: m_cachedInnerRoofPolygons) {
                 if (polygon->containsPoint(point, Qt::OddEvenFill)) {
                     return false;
                 }
             }
             return true;
         }
     }
     for (auto polygon: m_cachedOuterPolygons) {
         if (polygon->containsPoint(point, Qt::OddEvenFill)) {
             for (auto polygon: m_cachedInnerPolygons) {
                 if (polygon->containsPoint(point, Qt::OddEvenFill)) {
                     return false;
                 }
             }
             return true;
         }
     }
     return false;
 }
 
 bool BuildingGraphicsItem::configurePainterForFrame(GeoPainter *painter) const
 {
     QPen currentPen = painter->pen();
 
     GeoDataStyle::ConstPtr style = this->style();
     if (!style) {
         painter->setPen( QPen() );
     }
     else {
         const GeoDataPolyStyle& polyStyle = style->polyStyle();
 
         if (currentPen.style() != Qt::NoPen) {
             painter->setPen(Qt::NoPen);
         }
 
         if (!polyStyle.fill()) {
             return false;
         }
         else {
             const QColor paintedColor = polyStyle.paintedColor().darker(150);
             if (painter->brush().color() != paintedColor) {
                 painter->setBrush(paintedColor);
             }
         }
     }
 
     return true;
 }
 
 }