qgeocoordinate.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 "qgeocoordinate.h"
#include "qgeocoordinate_p.h"
#include "qlocationutils_p.h"
 
#include <QDateTime>
#include <QHash>
#include <QDataStream>
#include <QDebug>
#include <QMetaType>
#include <qnumeric.h>
#include <qmath.h>
 
QT_BEGIN_NAMESPACE
 
QT_IMPL_METATYPE_EXTERN(QGeoCoordinate)
 
static const double qgeocoordinate_EARTH_MEAN_RADIUS = 6371.0072;
 
 
QGeoCoordinatePrivate::QGeoCoordinatePrivate():
    lat(qQNaN()),
    lng(qQNaN()),
    alt(qQNaN())
{}
 
QGeoCoordinatePrivate::QGeoCoordinatePrivate(const QGeoCoordinatePrivate &other)
    : QSharedData(other),
      lat(other.lat),
      lng(other.lng),
      alt(other.alt)
{}
 
QGeoCoordinatePrivate::~QGeoCoordinatePrivate()
{}
 
 
QGeoMercatorCoordinatePrivate::QGeoMercatorCoordinatePrivate():
    QGeoCoordinatePrivate(),
    m_mercatorX(qQNaN()),
    m_mercatorY(qQNaN())
{}
 
QGeoMercatorCoordinatePrivate::QGeoMercatorCoordinatePrivate(const QGeoMercatorCoordinatePrivate &other)
    : QGeoCoordinatePrivate(other),
      m_mercatorX(other.m_mercatorX),
      m_mercatorY(other.m_mercatorY)
{}
 
QGeoMercatorCoordinatePrivate::~QGeoMercatorCoordinatePrivate()
{}
 
QGeoCoordinate::QGeoCoordinate()
        : d(new QGeoCoordinatePrivate)
{
}
 
QGeoCoordinate::QGeoCoordinate(double latitude, double longitude)
        : d(new QGeoCoordinatePrivate)
{
    if (QLocationUtils::isValidLat(latitude) && QLocationUtils::isValidLong(longitude)) {
        d->lat = latitude;
        d->lng = longitude;
    }
}
 
QGeoCoordinate::QGeoCoordinate(double latitude, double longitude, double altitude)
        : d(new QGeoCoordinatePrivate)
{
    if (QLocationUtils::isValidLat(latitude) && QLocationUtils::isValidLong(longitude)) {
        d->lat = latitude;
        d->lng = longitude;
        d->alt = altitude;
    }
}
 
QGeoCoordinate::QGeoCoordinate(const QGeoCoordinate &other)
        : d(other.d)
{}
 
QGeoCoordinate &QGeoCoordinate::operator=(const QGeoCoordinate &other)
{
    if (this == &other)
        return *this;
 
    d = other.d;
    return (*this);
}
 
QGeoCoordinate::~QGeoCoordinate()
{
}
 
QT_DEFINE_QSDP_SPECIALIZATION_DTOR(QGeoCoordinatePrivate)
 
 
bool QGeoCoordinate::isValid() const
{
    CoordinateType t = type();
    return t == Coordinate2D || t == Coordinate3D;
}
 
QGeoCoordinate::CoordinateType QGeoCoordinate::type() const
{
    if (QLocationUtils::isValidLat(d->lat)
            && QLocationUtils::isValidLong(d->lng)) {
        if (qIsNaN(d->alt))
            return Coordinate2D;
        return Coordinate3D;
    }
    return InvalidCoordinate;
}
 
 
double QGeoCoordinate::latitude() const
{
    return d->lat;
}
 
void QGeoCoordinate::setLatitude(double latitude)
{
    d->lat = latitude;
}
 
double QGeoCoordinate::longitude() const
{
    return d->lng;
}
 
void QGeoCoordinate::setLongitude(double longitude)
{
    d->lng = longitude;
}
 
double QGeoCoordinate::altitude() const
{
    return d->alt;
}
 
void QGeoCoordinate::setAltitude(double altitude)
{
    d->alt = altitude;
}
 
qreal QGeoCoordinate::distanceTo(const QGeoCoordinate &other) const
{
    if (type() == QGeoCoordinate::InvalidCoordinate
            || other.type() == QGeoCoordinate::InvalidCoordinate) {
        return 0;
    }
 
    // Haversine formula
    double dlat = qDegreesToRadians(other.d->lat - d->lat);
    double dlon = qDegreesToRadians(other.d->lng - d->lng);
    double haversine_dlat = sin(dlat / 2.0);
    haversine_dlat *= haversine_dlat;
    double haversine_dlon = sin(dlon / 2.0);
    haversine_dlon *= haversine_dlon;
    double y = haversine_dlat
             + cos(qDegreesToRadians(d->lat))
             * cos(qDegreesToRadians(other.d->lat))
             * haversine_dlon;
    double x = 2 * asin(sqrt(y));
    return qreal(x * qgeocoordinate_EARTH_MEAN_RADIUS * 1000);
}
 
qreal QGeoCoordinate::azimuthTo(const QGeoCoordinate &other) const
{
    if (type() == QGeoCoordinate::InvalidCoordinate
            || other.type() == QGeoCoordinate::InvalidCoordinate) {
        return 0;
    }
 
    double dlon = qDegreesToRadians(other.d->lng - d->lng);
    double lat1Rad = qDegreesToRadians(d->lat);
    double lat2Rad = qDegreesToRadians(other.d->lat);
 
    double y = sin(dlon) * cos(lat2Rad);
    double x = cos(lat1Rad) * sin(lat2Rad) - sin(lat1Rad) * cos(lat2Rad) * cos(dlon);
 
    double azimuth = qRadiansToDegrees(atan2(y, x)) + 360.0;
    double whole;
    double fraction = modf(azimuth, &whole);
    return qreal((int(whole + 360) % 360) + fraction);
}
 
void QGeoCoordinatePrivate::atDistanceAndAzimuth(const QGeoCoordinate &coord,
                                                 qreal distance, qreal azimuth,
                                                 double *lon, double *lat)
{
    double latRad = qDegreesToRadians(coord.d->lat);
    double lonRad = qDegreesToRadians(coord.d->lng);
    double cosLatRad = cos(latRad);
    double sinLatRad = sin(latRad);
 
    double azimuthRad = qDegreesToRadians(azimuth);
 
    double ratio = (distance / (qgeocoordinate_EARTH_MEAN_RADIUS * 1000.0));
    double cosRatio = cos(ratio);
    double sinRatio = sin(ratio);
 
    double resultLatRad = asin(sinLatRad * cosRatio
                               + cosLatRad * sinRatio * cos(azimuthRad));
    double resultLonRad = lonRad + atan2(sin(azimuthRad) * sinRatio * cosLatRad,
                                   cosRatio - sinLatRad * sin(resultLatRad));
 
    *lat = qRadiansToDegrees(resultLatRad);
    *lon = qRadiansToDegrees(resultLonRad);
}
 
QGeoCoordinate QGeoCoordinate::atDistanceAndAzimuth(qreal distance, qreal azimuth, qreal distanceUp) const
{
    if (!isValid())
        return QGeoCoordinate();
 
    double resultLon, resultLat;
    QGeoCoordinatePrivate::atDistanceAndAzimuth(*this, distance, azimuth,
                                                &resultLon, &resultLat);
    double resultAlt = d->alt + distanceUp;
    return QGeoCoordinate(resultLat, QLocationUtils::wrapLong(resultLon), resultAlt);
}
 
QString QGeoCoordinate::toString(CoordinateFormat format) const
{
    if (type() == QGeoCoordinate::InvalidCoordinate)
        return QString();
 
    QString latStr;
    QString longStr;
 
    double absLat = qAbs(d->lat);
    double absLng = qAbs(d->lng);
    QChar symbol(0x00B0);   // degrees symbol
 
    switch (format) {
        case Degrees:
        case DegreesWithHemisphere: {
            latStr = QString::number(absLat, 'f', 5) + symbol;
            longStr = QString::number(absLng, 'f', 5) + symbol;
            break;
        }
        case DegreesMinutes:
        case DegreesMinutesWithHemisphere: {
            double latMin = (absLat - int(absLat)) * 60;
            double lngMin = (absLng - int(absLng)) * 60;
 
            // We use QString::number(val, 'f', 3) to represent minutes.
            // It rounds up to the next integer in case the fraction > 0.9995.
            // Such behavior should be handled specifically when the rounded
            // value is 60, so that we overflow to degrees correctly.
            // If we overflow, the minutes should unconditionally be 0.0.
            if (latMin > 59.9995) {
                absLat++;
                latMin = 0.0f;
            }
            if (lngMin > 59.9995) {
                absLng++;
                lngMin = 0.0f;
            }
 
            latStr = QString::fromLatin1("%1%2 %3'")
                     .arg(QString::number(int(absLat)))
                     .arg(symbol)
                     .arg(QString::number(latMin, 'f', 3));
            longStr = QString::fromLatin1("%1%2 %3'")
                      .arg(QString::number(int(absLng)))
                      .arg(symbol)
                      .arg(QString::number(lngMin, 'f', 3));
            break;
        }
        case DegreesMinutesSeconds:
        case DegreesMinutesSecondsWithHemisphere: {
            double latMin = (absLat - int(absLat)) * 60;
            double lngMin = (absLng - int(absLng)) * 60;
            double latSec = (latMin - int(latMin)) * 60;
            double lngSec = (lngMin - int(lngMin)) * 60;
 
            // We use QString::number(val, 'f', 1) to represent seconds.
            // It rounds up to the next integer in case the fraction >= 0.95.
            // Such behavior should be handled specifically when the rounded
            // value is 60, so that we overflow to minutes correctly.
            // If we overflow, the seconds should unconditionally be 0.0.
            if (latSec >= 59.95) {
                latMin++;
                latSec = 0.0f;
                // We cast to int to represent minutes, so we can use qRound()
                // to determine if we need to overflow to full degrees.
                // If we overflow, the minutes will unconditionally be 0.0.
                if (qRound(latMin) >= 60) {
                    absLat++;
                    latMin = 0.0f;
                }
            }
            if (lngSec >= 59.95) {
                lngMin++;
                lngSec = 0.0f;
                if (qRound(lngMin) >= 60) {
                    absLng++;
                    lngMin = 0.0f;
                }
            }
 
            latStr = QString::fromLatin1("%1%2 %3' %4\"")
                     .arg(QString::number(int(absLat)))
                     .arg(symbol)
                     .arg(QString::number(int(latMin)))
                     .arg(QString::number(latSec, 'f', 1));
            longStr = QString::fromLatin1("%1%2 %3' %4\"")
                      .arg(QString::number(int(absLng)))
                      .arg(symbol)
                      .arg(QString::number(int(lngMin)))
                      .arg(QString::number(lngSec, 'f', 1));
            break;
        }
    }
 
    // now add the "-" to the start, or append the hemisphere char
    switch (format) {
        case Degrees:
        case DegreesMinutes:
        case DegreesMinutesSeconds: {
            if (d->lat < 0)
                latStr.insert(0, QStringLiteral("-"));
            if (d->lng < 0)
                longStr.insert(0, QStringLiteral("-"));
            break;
        }
        case DegreesWithHemisphere:
        case DegreesMinutesWithHemisphere:
        case DegreesMinutesSecondsWithHemisphere: {
            if (d->lat < 0)
                latStr.append(QString::fromLatin1(" S"));
            else if (d->lat > 0)
                latStr.append(QString::fromLatin1(" N"));
            if (d->lng < 0)
                longStr.append(QString::fromLatin1(" W"));
            else if (d->lng > 0)
                longStr.append(QString::fromLatin1(" E"));
            break;
        }
    }
 
    if (qIsNaN(d->alt))
        return QString::fromLatin1("%1, %2").arg(latStr, longStr);
    return QString::fromLatin1("%1, %2, %3m").arg(latStr, longStr, QString::number(d->alt));
}
 
bool QGeoCoordinate::equals(const QGeoCoordinate &lhs, const QGeoCoordinate &rhs)
{
    bool latEqual = (qIsNaN(lhs.d->lat) && qIsNaN(rhs.d->lat))
                        || qFuzzyCompare(lhs.d->lat, rhs.d->lat);
    bool lngEqual = (qIsNaN(lhs.d->lng) && qIsNaN(rhs.d->lng))
                        || qFuzzyCompare(lhs.d->lng, rhs.d->lng);
    bool altEqual = (qIsNaN(lhs.d->alt) && qIsNaN(rhs.d->alt))
                        || qFuzzyCompare(lhs.d->alt, rhs.d->alt);
 
    if (!qIsNaN(lhs.d->lat) && ((lhs.d->lat == 90.0) || (lhs.d->lat == -90.0)))
        lngEqual = true;
 
    return (latEqual && lngEqual && altEqual);
}
 
QGeoCoordinate::QGeoCoordinate(QGeoCoordinatePrivate &dd):
    d(&dd)
{
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug QGeoCoordinate::debugStreaming(QDebug dbg, const QGeoCoordinate &coord)
{
    QDebugStateSaver saver(dbg);
    double lat = coord.latitude();
    double lng = coord.longitude();
 
    QTextStreamManipulator tsm = qSetRealNumberPrecision(11);
    dbg << tsm;
    dbg.nospace() << "QGeoCoordinate(";
    if (qIsNaN(lat))
        dbg << '?';
    else
        dbg << lat;
    dbg << ", ";
    if (qIsNaN(lng))
        dbg << '?';
    else
        dbg << lng;
    if (coord.type() == QGeoCoordinate::Coordinate3D) {
        dbg << ", ";
        dbg << coord.altitude();
    }
    dbg << ')';
    return dbg;
}
#endif
 
#ifndef QT_NO_DATASTREAM
QDataStream &QGeoCoordinate::dataStreamOut(QDataStream &stream, const QGeoCoordinate &coordinate)
{
    stream << coordinate.latitude();
    stream << coordinate.longitude();
    stream << coordinate.altitude();
    return stream;
}
#endif
 
#ifndef QT_NO_DATASTREAM
QDataStream &QGeoCoordinate::dataStreamIn(QDataStream &stream, QGeoCoordinate &coordinate)
{
    double value;
    stream >> value;
    coordinate.setLatitude(value);
    stream >> value;
    coordinate.setLongitude(value);
    stream >> value;
    coordinate.setAltitude(value);
    return stream;
}
#endif
 
size_t qHash(const QGeoCoordinate &coordinate, size_t seed)
{
    QtPrivate::QHashCombine hash;
    // north and south pole are geographically equivalent (no matter the longitude)
    if (coordinate.latitude() != 90.0 && coordinate.latitude() != -90.0)
        seed = hash(seed, coordinate.longitude());
    seed = hash(seed, coordinate.latitude());
    seed = hash(seed, coordinate.altitude());
    return seed;
}
 
QT_END_NAMESPACE
 
#include "moc_qgeocoordinate.cpp"