qdeclarativecirclemapitem.cpp

Go to the documentation of this file.

// Copyright (C) 2015 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qdeclarativecirclemapitem_p.h"
#include "qdeclarativecirclemapitem_p_p.h"
 
#include <QtCore/QScopedValueRollback>
#include <QPen>
#include <qgeocircle.h>
 
#include <QtGui/private/qtriangulator_p.h>
#include <QtLocation/private/qgeomap_p.h>
#include <QtPositioning/private/qlocationutils_p.h>
 
#include <qmath.h>
#include <algorithm>
 
#include <QtQuick/private/qquickitem_p.h>
 
QT_BEGIN_NAMESPACE
 
struct Vertex
{
    QVector2D position;
};
 
QGeoMapCircleGeometry::QGeoMapCircleGeometry()
{
}
 
QDeclarativeCircleMapItem::QDeclarativeCircleMapItem(QQuickItem *parent)
:   QDeclarativeGeoMapItemBase(parent), m_border(this), m_color(Qt::transparent),
    m_updatingGeometry(false)
  , m_d(new QDeclarativeCircleMapItemPrivateCPU(*this))
{
    // ToDo: handle envvar, and switch implementation.
    m_itemType = QGeoMap::MapCircle;
    setFlag(ItemHasContents, true);
    QObject::connect(&m_border, &QDeclarativeMapLineProperties::colorChanged,
                     this, &QDeclarativeCircleMapItem::onLinePropertiesChanged);
    QObject::connect(&m_border, &QDeclarativeMapLineProperties::widthChanged,
                     this, &QDeclarativeCircleMapItem::onLinePropertiesChanged);
    QObject::connect(this, &QDeclarativeCircleMapItem::referenceSurfaceChanged,
                     [=]() {m_d->onGeoGeometryChanged();});
}
 
QDeclarativeCircleMapItem::~QDeclarativeCircleMapItem()
{
}
 
QDeclarativeMapLineProperties *QDeclarativeCircleMapItem::border()
{
    return &m_border;
}
 
void QDeclarativeCircleMapItem::markSourceDirtyAndUpdate()
{
    m_d->markSourceDirtyAndUpdate();
}
 
void QDeclarativeCircleMapItem::onLinePropertiesChanged()
{
    m_d->onLinePropertiesChanged();
}
 
void QDeclarativeCircleMapItem::setMap(QDeclarativeGeoMap *quickMap, QGeoMap *map)
{
    QDeclarativeGeoMapItemBase::setMap(quickMap,map);
    if (map)
        m_d->onMapSet();
}
 
void QDeclarativeCircleMapItem::setCenter(const QGeoCoordinate &center)
{
    if (m_circle.center() == center)
        return;
 
    m_circle.setCenter(center);
    m_d->onGeoGeometryChanged();
    emit centerChanged(center);
}
 
QGeoCoordinate QDeclarativeCircleMapItem::center()
{
    return m_circle.center();
}
 
void QDeclarativeCircleMapItem::setColor(const QColor &color)
{
    if (m_color == color)
        return;
 
    m_color = color;
    polishAndUpdate(); // in case color was transparent and now is not or vice versa
    emit colorChanged(m_color);
}
 
QColor QDeclarativeCircleMapItem::color() const
{
    return m_color;
}
 
void QDeclarativeCircleMapItem::setRadius(qreal radius)
{
    if (m_circle.radius() == radius)
        return;
 
    m_circle.setRadius(radius);
    m_d->onGeoGeometryChanged();
    emit radiusChanged(radius);
}
 
qreal QDeclarativeCircleMapItem::radius() const
{
    return m_circle.radius();
}
 
QSGNode *QDeclarativeCircleMapItem::updateMapItemPaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
{
    return m_d->updateMapItemPaintNode(oldNode, data);
}
 
void QDeclarativeCircleMapItem::updatePolish()
{
    if (!map() || map()->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
        return;
    m_d->updatePolish();
}
 
void QDeclarativeCircleMapItem::afterViewportChanged(const QGeoMapViewportChangeEvent &event)
{
    if (event.mapSize.isEmpty())
        return;
 
    m_d->afterViewportChanged();
}
 
bool QDeclarativeCircleMapItem::contains(const QPointF &point) const
{
    return m_d->contains(point);
}
 
const QGeoShape &QDeclarativeCircleMapItem::geoShape() const
{
    return m_circle;
}
 
void QDeclarativeCircleMapItem::setGeoShape(const QGeoShape &shape)
{
    if (shape == m_circle)
        return;
 
    const QGeoCircle circle(shape); // if shape isn't a circle, circle will be created as a default-constructed circle
    const bool centerHasChanged = circle.center() != m_circle.center();
    const bool radiusHasChanged = circle.radius() != m_circle.radius();
    m_circle = circle;
 
    m_d->onGeoGeometryChanged();
    if (centerHasChanged)
        emit centerChanged(m_circle.center());
    if (radiusHasChanged)
        emit radiusChanged(m_circle.radius());
}
 
void QDeclarativeCircleMapItem::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
{
    if (!map() || !m_circle.isValid() || m_updatingGeometry || newGeometry == oldGeometry) {
        QDeclarativeGeoMapItemBase::geometryChange(newGeometry, oldGeometry);
        return;
    }
 
    QDoubleVector2D newPoint = QDoubleVector2D(x(),y()) + QDoubleVector2D(width(), height()) * 0.5;
    QGeoCoordinate newCoordinate = map()->geoProjection().itemPositionToCoordinate(newPoint, false);
    if (newCoordinate.isValid())
        setCenter(newCoordinate); // ToDo: this is incorrect. setting such center might yield to another geometry changed.
 
    // Not calling QDeclarativeGeoMapItemBase::geometryChange() as it will be called from a nested
    // call to this function.
}
 
QDeclarativeCircleMapItemPrivate::~QDeclarativeCircleMapItemPrivate()
{
}
 
QDeclarativeCircleMapItemPrivateCPU::QDeclarativeCircleMapItemPrivateCPU(QDeclarativeCircleMapItem &circle)
    : QDeclarativeCircleMapItemPrivate(circle)
{
    m_shape = new QQuickShape(&m_circle);
    m_shape->setObjectName("_qt_map_item_shape");
    m_shape->setZ(-1);
    m_shape->setContainsMode(QQuickShape::FillContains);
 
    m_shapePath = new QQuickShapePath(m_shape);
    m_painterPath = new QDeclarativeGeoMapPainterPath(m_shapePath);
 
    auto pathElements = m_shapePath->pathElements();
    pathElements.append(&pathElements, m_painterPath);
 
    auto shapePaths = m_shape->data();
    shapePaths.append(&shapePaths, m_shapePath);
}
 
QDeclarativeCircleMapItemPrivateCPU::~QDeclarativeCircleMapItemPrivateCPU()
{
    delete m_shape;
}
 
/*
 * A workaround for circle path to be drawn correctly using a polygon geometry
 * This method generates a polygon like
 *  ______________
 *  |    ____    |
 *   \__/    \__/
 */
void QDeclarativeCircleMapItemPrivate::includeOnePoleInPath(QList<QDoubleVector2D> &path,
                                                             const QGeoCoordinate &center,
                                                             qreal distance, const QGeoProjectionWebMercator &p)
{
    const qreal poleLat = 90;
    const qreal distanceToNorthPole = center.distanceTo(QGeoCoordinate(poleLat, 0));
    const qreal distanceToSouthPole = center.distanceTo(QGeoCoordinate(-poleLat, 0));
    const bool crossNorthPole = distanceToNorthPole < distance;
    const bool crossSouthPole = distanceToSouthPole < distance;
 
    if (!crossNorthPole && !crossSouthPole)
        return;
 
    if (crossNorthPole && crossSouthPole)
        return;
 
    const QRectF cameraRect = QDeclarativeGeoMapItemUtils::boundingRectangleFromList(p.visibleGeometry());
    const qreal xAtBorder = cameraRect.left();
 
    // The strategy is to order the points from left to right as they appear on the screen.
    // Then add the 3 missing sides that form the box for painting at the front and at the end of the list.
    // We ensure that the box aligns with the cameraRect in order to avoid rendering it twice (wrap around).
    // Notably, this leads to outlines at the right side of the map.
    // Set xAtBorder to 0.0 to avoid this, however, for an increased rendering cost.
    for (auto &c : path) {
        c.setX(c.x());
        while (c.x() - xAtBorder > 1.0)
            c.setX(c.x() - 1.0);
        while (c.x() - xAtBorder < 0.0)
            c.setX(c.x() + 1.0);
    }
 
    std::sort(path.begin(), path.end(),
              [](const QDoubleVector2D &a, const QDoubleVector2D &b) -> bool
                {return a.x() < b.x();});
 
    const qreal newPoleLat = crossNorthPole ? -0.1 : 1.1;
    const QDoubleVector2D P1 = path.first() + QDoubleVector2D(1.0, 0.0);
    const QDoubleVector2D P2 = path.last() - QDoubleVector2D(1.0, 0.0);
    path.push_front(P2);
    path.push_front(QDoubleVector2D(P2.x(), newPoleLat));
    path.append(P1);
    path.append(QDoubleVector2D(P1.x(), newPoleLat));
}
 
int QDeclarativeCircleMapItemPrivate::crossEarthPole(const QGeoCoordinate &center, qreal distance)
{
    qreal poleLat = 90;
    QGeoCoordinate northPole = QGeoCoordinate(poleLat, center.longitude());
    QGeoCoordinate southPole = QGeoCoordinate(-poleLat, center.longitude());
    // approximate using great circle distance
    qreal distanceToNorthPole = center.distanceTo(northPole);
    qreal distanceToSouthPole = center.distanceTo(southPole);
    return (distanceToNorthPole < distance? 1 : 0) +
           (distanceToSouthPole < distance? 1 : 0);
}
 
void QDeclarativeCircleMapItemPrivate::calculatePeripheralPointsSimple(QList<QDoubleVector2D> &path,
                                      const QGeoCoordinate &center,
                                      qreal distance,
                                      const QGeoProjectionWebMercator &p,
                                      int steps)
{
    const double lambda = 0.0001;
    const QDoubleVector2D c = p.geoToMapProjection(center);
    const double lambda_geo = center.distanceTo(p.mapProjectionToGeo(c + QDoubleVector2D(lambda, 0)));
    const qreal mapDistance = distance * lambda / lambda_geo;
 
    for (int i = 0; i < steps; ++i) {
        const qreal rad = 2 * M_PI * i / steps;
        path << c + QDoubleVector2D(cos(rad), sin(rad)) * mapDistance;
    }
}
 
void QDeclarativeCircleMapItemPrivate::calculatePeripheralPointsGreatCircle(QList<QDoubleVector2D> &path,
                                      const QGeoCoordinate &center,
                                      qreal distance,
                                      const QGeoProjectionWebMercator &p,
                                      int steps)
{
    // Calculate points based on great-circle distance
    // Calculation is the same as GeoCoordinate's atDistanceAndAzimuth function
    // but tweaked here for computing multiple points
 
    // pre-calculations
    steps = qMax(steps, 3);
    qreal centerLon = center.longitude();
    qreal latRad = QLocationUtils::radians(center.latitude());
    qreal lonRad = QLocationUtils::radians(centerLon);
    qreal cosLatRad = std::cos(latRad);
    qreal sinLatRad = std::sin(latRad);
    qreal ratio = (distance / QLocationUtils::earthMeanRadius());
    qreal cosRatio = std::cos(ratio);
    qreal sinRatio = std::sin(ratio);
    qreal sinLatRad_x_cosRatio = sinLatRad * cosRatio;
    qreal cosLatRad_x_sinRatio = cosLatRad * sinRatio;
    for (int i = 0; i < steps; ++i) {
        const qreal azimuthRad = 2 * M_PI * i / steps;
        const qreal resultLatRad = std::asin(sinLatRad_x_cosRatio
                                 + cosLatRad_x_sinRatio * std::cos(azimuthRad));
        const qreal resultLonRad = lonRad + std::atan2(std::sin(azimuthRad) * cosLatRad_x_sinRatio,
                                   cosRatio - sinLatRad * std::sin(resultLatRad));
        const qreal lat2 = QLocationUtils::degrees(resultLatRad);
        qreal lon2 =  QLocationUtils::degrees(resultLonRad);
 
        //Workaround as QGeoCoordinate does not take Longitudes outside [-180,180]
        qreal offset = 0.0;
        while (lon2 > 180.0) {
            offset += 1.0;
            lon2 -= 360.0;
        }
        while (lon2 < -180.0) {
            offset -= 1.0;
            lon2 += 360.0;
        }
        path << p.geoToMapProjection(QGeoCoordinate(lat2, lon2, center.altitude())) + QDoubleVector2D(offset, 0.0);
    }
}
 
 
void QDeclarativeCircleMapItemPrivateCPU::updatePolish()
{
    if (!m_circle.m_circle.isValid()) {
        m_geometry.clear();
        m_circle.setWidth(0);
        m_circle.setHeight(0);
        m_shape->setVisible(false);
        return;
    }
 
    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_circle.map()->geoProjection());
    QScopedValueRollback<bool> rollback(m_circle.m_updatingGeometry);
    m_circle.m_updatingGeometry = true;
 
    QList<QDoubleVector2D> circlePath = m_circlePath;
 
    const QGeoCoordinate &center = m_circle.m_circle.center();
    const qreal &radius = m_circle.m_circle.radius();
 
    // if circle crosses north/south pole, then don't preserve circular shape,
    int crossingPoles = m_circle.referenceSurface() == QLocation::ReferenceSurface::Globe ? crossEarthPole(center, radius) : 0;
    if (crossingPoles == 1) { // If the circle crosses both poles, we will remove it from a rectangle
        includeOnePoleInPath(circlePath, center, radius, p);
        m_geometry.updateSourcePoints(*m_circle.map(), QList<QList<QDoubleVector2D>>{circlePath}, QGeoMapPolygonGeometry::DrawOnce);
    }
    else if (crossingPoles == 2) { // If the circle crosses both poles, we will remove it from a rectangle
        // The circle covers both poles. This appears on the map as a total fill with a hole on the opposite side of the planet
        // This can be represented by a rectangle that spans the entire planet with a hole defined by the calculated points.
        // The points on one side have to be wraped around the globe
        const qreal centerX = p.geoToMapProjection(center).x();
        for (int i = 0; i < circlePath.count(); i++) {
            if (circlePath.at(i).x() > centerX)
                circlePath[i].setX(circlePath.at(i).x() - 1.0);
        }
        QRectF cameraRect = QDeclarativeGeoMapItemUtils::boundingRectangleFromList(p.visibleGeometry());
        const QRectF circleRect = QDeclarativeGeoMapItemUtils::boundingRectangleFromList(circlePath);
        QGeoMapPolygonGeometry::MapBorderBehaviour wrappingMode = QGeoMapPolygonGeometry::DrawOnce;
        QList<QDoubleVector2D> surroundingRect;
        if (cameraRect.contains(circleRect)){
            cameraRect = cameraRect.adjusted(-0.1, -0.1, 0.2, 0.2);
            surroundingRect = {{cameraRect.left(), cameraRect.top()}, {cameraRect.right(), cameraRect.top()},
                               {cameraRect.right(), cameraRect.bottom()}, {cameraRect.left() , cameraRect.bottom()}};
        } else {
            const qreal anchorRect = centerX;
 
            surroundingRect = {{anchorRect, -0.1}, {anchorRect + 1.0, -0.1},
                               {anchorRect + 1.0, 1.1}, {anchorRect, 1.1}};
            wrappingMode = QGeoMapPolygonGeometry::Duplicate;
        }
        m_geometry.updateSourcePoints(*m_circle.map(), {surroundingRect, circlePath}, wrappingMode);
    } else {
        m_geometry.updateSourcePoints(*m_circle.map(), QList<QList<QDoubleVector2D>>{circlePath});
    }
 
    m_circle.setShapeTriangulationScale(m_shape, m_geometry.maxCoord());
 
    const bool hasBorder = m_circle.m_border.color().alpha() != 0 && m_circle.m_border.width() > 0;
    const float borderWidth = hasBorder ? m_circle.m_border.width() : 0.0f;
    m_shapePath->setStrokeColor(hasBorder ? m_circle.m_border.color() : Qt::transparent);
    m_shapePath->setStrokeWidth(hasBorder ? borderWidth : -1.0f);
    m_shapePath->setFillColor(m_circle.color());
 
    const QRectF bb = m_geometry.sourceBoundingBox();
    QPainterPath path = m_geometry.srcPath();
    path.translate(-bb.left() + borderWidth, -bb.top() + borderWidth);
    path.closeSubpath();
    m_painterPath->setPath(path);
 
    m_circle.setSize(bb.size());
    m_shape->setSize(m_circle.size());
    m_shape->setOpacity(m_circle.zoomLevelOpacity());
    m_shape->setVisible(true);
 
    m_circle.setPositionOnMap(m_geometry.origin(), -1 * bb.topLeft() + QPointF(borderWidth, borderWidth));
}
 
QSGNode *QDeclarativeCircleMapItemPrivateCPU::updateMapItemPaintNode(QSGNode *oldNode,
                                                            QQuickItem::UpdatePaintNodeData *data)
{
    Q_UNUSED(data);
    delete oldNode;
    if (m_geometry.isScreenDirty()) {
        m_geometry.markClean();
    }
    return nullptr;
}
 
bool QDeclarativeCircleMapItemPrivateCPU::contains(const QPointF &point) const
{
    return m_shape->contains(m_circle.mapToItem(m_shape, point));
}
 
QT_END_NAMESPACE