qgeorectangle.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 "qgeorectangle.h"
#include "qgeorectangle_p.h"
 
#include "qwebmercator_p.h"
#include "qdoublevector2d_p.h"
#include "qgeocoordinate.h"
#include "qnumeric.h"
#include "qlocationutils_p.h"
#include <QList>
QT_BEGIN_NAMESPACE
 
QT_IMPL_METATYPE_EXTERN(QGeoRectangle)
 
 
inline QGeoRectanglePrivate *QGeoRectangle::d_func()
{
    return static_cast<QGeoRectanglePrivate *>(d_ptr.data());
}
 
inline const QGeoRectanglePrivate *QGeoRectangle::d_func() const
{
    return static_cast<const QGeoRectanglePrivate *>(d_ptr.constData());
}
 
QGeoRectangle::QGeoRectangle()
:   QGeoShape(new QGeoRectanglePrivate)
{
}
 
QGeoRectangle::QGeoRectangle(const QGeoCoordinate &center, double degreesWidth, double degreesHeight)
{
    d_ptr = new QGeoRectanglePrivate(center, center);
    setWidth(degreesWidth);
    setHeight(degreesHeight);
}
 
QGeoRectangle::QGeoRectangle(const QGeoCoordinate &topLeft, const QGeoCoordinate &bottomRight)
{
    d_ptr = new QGeoRectanglePrivate(topLeft, bottomRight);
}
 
QGeoRectangle::QGeoRectangle(const QList<QGeoCoordinate> &coordinates)
{
    if (coordinates.isEmpty()) {
        d_ptr = new QGeoRectanglePrivate;
    } else {
        const QGeoCoordinate &startCoordinate = coordinates.first();
        d_ptr = new QGeoRectanglePrivate(startCoordinate, startCoordinate);
 
        foreach (const QGeoCoordinate &coordinate, coordinates) {
            d_func()->extendRectangle(coordinate);
        }
    }
}
 
QGeoRectangle::QGeoRectangle(const QGeoRectangle &other)
:   QGeoShape(other)
{
}
 
QGeoRectangle::QGeoRectangle(const QGeoShape &other)
:   QGeoShape(other)
{
    if (type() != QGeoShape::RectangleType)
        d_ptr = new QGeoRectanglePrivate;
}
 
QGeoRectangle::~QGeoRectangle()
{
}
 
QGeoRectangle &QGeoRectangle::operator=(const QGeoRectangle &other)
{
    QGeoShape::operator=(other);
    return *this;
}
 
bool QGeoRectanglePrivate::isValid() const
{
    return topLeft.isValid() && bottomRight.isValid() &&
           topLeft.latitude() >= bottomRight.latitude();
}
 
bool QGeoRectanglePrivate::isEmpty() const
{
    if (!isValid())
        return true;
 
    return topLeft.latitude() == bottomRight.latitude() ||
           topLeft.longitude() == bottomRight.longitude();
}
 
void QGeoRectangle::setTopLeft(const QGeoCoordinate &topLeft)
{
    Q_D(QGeoRectangle);
 
    d->topLeft = topLeft;
}
 
QGeoCoordinate QGeoRectangle::topLeft() const
{
    Q_D(const QGeoRectangle);
 
    return d->topLeft;
}
 
void QGeoRectangle::setTopRight(const QGeoCoordinate &topRight)
{
    Q_D(QGeoRectangle);
 
    d->topLeft.setLatitude(topRight.latitude());
    d->bottomRight.setLongitude(topRight.longitude());
}
 
QGeoCoordinate QGeoRectangle::topRight() const
{
    // TODO remove?
    if (!isValid())
        return QGeoCoordinate();
 
    Q_D(const QGeoRectangle);
 
    return QGeoCoordinate(d->topLeft.latitude(), d->bottomRight.longitude());
}
 
void QGeoRectangle::setBottomLeft(const QGeoCoordinate &bottomLeft)
{
    Q_D(QGeoRectangle);
 
    d->bottomRight.setLatitude(bottomLeft.latitude());
    d->topLeft.setLongitude(bottomLeft.longitude());
}
 
QGeoCoordinate QGeoRectangle::bottomLeft() const
{
    // TODO remove?
    if (!isValid())
        return QGeoCoordinate();
 
    Q_D(const QGeoRectangle);
 
    return QGeoCoordinate(d->bottomRight.latitude(), d->topLeft.longitude());
}
 
void QGeoRectangle::setBottomRight(const QGeoCoordinate &bottomRight)
{
    Q_D(QGeoRectangle);
 
    d->bottomRight = bottomRight;
}
 
QGeoCoordinate QGeoRectangle::bottomRight() const
{
    Q_D(const QGeoRectangle);
 
    return d->bottomRight;
}
 
void QGeoRectangle::setCenter(const QGeoCoordinate &center)
{
    Q_D(QGeoRectangle);
 
    if (!isValid()) {
        d->topLeft = center;
        d->bottomRight = center;
        return;
    }
    double width = this->width();
    double height = this->height();
 
    double tlLat = center.latitude() + height / 2.0;
    double tlLon = center.longitude() - width / 2.0;
    double brLat = center.latitude() - height / 2.0;
    double brLon = center.longitude() + width / 2.0;
    tlLon = QLocationUtils::wrapLong(tlLon);
    brLon = QLocationUtils::wrapLong(brLon);
 
    if (tlLat > 90.0) {
        brLat = 2 * center.latitude() - 90.0;
        tlLat = 90.0;
    }
 
    if (tlLat < -90.0) {
        brLat = -90.0;
        tlLat = -90.0;
    }
 
    if (brLat > 90.0) {
        tlLat = 90.0;
        brLat = 90.0;
    }
 
    if (brLat < -90.0) {
        tlLat = 2 * center.latitude() + 90.0;
        brLat = -90.0;
    }
 
    if (width == 360.0) {
        tlLon = -180.0;
        brLon = 180.0;
    }
 
    d->topLeft = QGeoCoordinate(tlLat, tlLon);
    d->bottomRight = QGeoCoordinate(brLat, brLon);
}
 
QGeoCoordinate QGeoRectangle::center() const
{
    Q_D(const QGeoRectangle);
 
    return d->center();
}
 
void QGeoRectangle::setWidth(double degreesWidth)
{
    if (!isValid())
        return;
 
    if (degreesWidth < 0.0)
        return;
 
    Q_D(QGeoRectangle);
 
    if (degreesWidth >= 360.0) {
        d->topLeft.setLongitude(-180.0);
        d->bottomRight.setLongitude(180.0);
        return;
    }
 
    double tlLat = d->topLeft.latitude();
    double brLat = d->bottomRight.latitude();
 
    QGeoCoordinate c = center();
 
    double tlLon = c.longitude() - degreesWidth / 2.0;
    tlLon = QLocationUtils::wrapLong(tlLon);
 
    double brLon = c.longitude() + degreesWidth / 2.0;
    brLon = QLocationUtils::wrapLong(brLon);
 
    d->topLeft = QGeoCoordinate(tlLat, tlLon);
    d->bottomRight = QGeoCoordinate(brLat, brLon);
}
 
double QGeoRectangle::width() const
{
    if (!isValid())
        return qQNaN();
 
    Q_D(const QGeoRectangle);
 
    double result = d->bottomRight.longitude() - d->topLeft.longitude();
    if (result < 0.0)
        result += 360.0;
    if (result > 360.0)
        result -= 360.0;
 
    return result;
}
 
void QGeoRectangle::setHeight(double degreesHeight)
{
    if (!isValid())
        return;
 
    if (degreesHeight < 0.0)
        return;
 
    if (degreesHeight >= 180.0) {
        degreesHeight = 180.0;
    }
 
    Q_D(QGeoRectangle);
 
    double tlLon = d->topLeft.longitude();
    double brLon = d->bottomRight.longitude();
 
    QGeoCoordinate c = center();
 
    double tlLat = c.latitude() + degreesHeight / 2.0;
    double brLat = c.latitude() - degreesHeight / 2.0;
 
    if (tlLat > 90.0) {
        brLat = 2* c.latitude() - 90.0;
        tlLat = 90.0;
    }
 
    if (tlLat < -90.0) {
        brLat = -90.0;
        tlLat = -90.0;
    }
 
    if (brLat > 90.0) {
        tlLat = 90.0;
        brLat = 90.0;
    }
 
    if (brLat < -90.0) {
        tlLat = 2 * c.latitude() + 90.0;
        brLat = -90.0;
    }
 
    d->topLeft = QGeoCoordinate(tlLat, tlLon);
    d->bottomRight = QGeoCoordinate(brLat, brLon);
}
 
double QGeoRectangle::height() const
{
    if (!isValid())
        return qQNaN();
 
    Q_D(const QGeoRectangle);
 
    return d->topLeft.latitude() - d->bottomRight.latitude();
}
 
bool QGeoRectanglePrivate::contains(const QGeoCoordinate &coordinate) const
{
    if (!isValid() || !coordinate.isValid())
        return false;
 
    double left = topLeft.longitude();
    double right = bottomRight.longitude();
    double top = topLeft.latitude();
    double bottom = bottomRight.latitude();
 
    double lon = coordinate.longitude();
    double lat = coordinate.latitude();
 
    if (lat > top)
        return false;
    if (lat < bottom)
        return false;
 
    if ((lat == 90.0) && (top == 90.0))
        return true;
 
    if ((lat == -90.0) && (bottom == -90.0))
        return true;
 
    if (left <= right) {
        if ((lon < left) || (lon > right))
            return false;
    } else {
        if ((lon < left) && (lon > right))
            return false;
    }
 
    return true;
}
 
QGeoCoordinate QGeoRectanglePrivate::center() const
{
    if (!isValid())
        return QGeoCoordinate();
 
    double cLat = (topLeft.latitude() + bottomRight.latitude()) / 2.0;
    double cLon = (bottomRight.longitude() + topLeft.longitude()) / 2.0;
 
    if (topLeft.longitude() > bottomRight.longitude())
        cLon = cLon - 180.0;
 
    cLon = QLocationUtils::wrapLong(cLon);
    return QGeoCoordinate(cLat, cLon);
}
 
QGeoRectangle QGeoRectanglePrivate::boundingGeoRectangle() const
{
    return QGeoRectangle(topLeft, bottomRight);
}
 
bool QGeoRectangle::contains(const QGeoRectangle &rectangle) const
{
    Q_D(const QGeoRectangle);
 
    return (d->contains(rectangle.topLeft())
            && d->contains(rectangle.topRight())
            && d->contains(rectangle.bottomLeft())
            && d->contains(rectangle.bottomRight()));
}
 
bool QGeoRectangle::intersects(const QGeoRectangle &rectangle) const
{
    Q_D(const QGeoRectangle);
 
    double left1 = d->topLeft.longitude();
    double right1 = d->bottomRight.longitude();
    double top1 = d->topLeft.latitude();
    double bottom1 = d->bottomRight.latitude();
 
    double left2 = rectangle.d_func()->topLeft.longitude();
    double right2 = rectangle.d_func()->bottomRight.longitude();
    double top2 = rectangle.d_func()->topLeft.latitude();
    double bottom2 = rectangle.d_func()->bottomRight.latitude();
 
    if (top1 < bottom2)
        return false;
 
    if (bottom1 > top2)
        return false;
 
    if ((top1 == 90.0) && (top1 == top2))
        return true;
 
    if ((bottom1 == -90.0) && (bottom1 == bottom2))
        return true;
 
    if (left1 < right1) {
        if (left2 < right2) {
            if ((left1 > right2) || (right1 < left2))
                return false;
        } else {
            if ((left1 > right2) && (right1 < left2))
                return false;
        }
    } else {
        if (left2 < right2) {
            if ((left2 > right1) && (right2 < left1))
                return false;
        } else {
            // if both wrap then they have to intersect
        }
    }
 
    return true;
}
 
void QGeoRectangle::translate(double degreesLatitude, double degreesLongitude)
{
    // TODO handle dlat, dlon larger than 360 degrees
 
    Q_D(QGeoRectangle);
 
    double tlLat = d->topLeft.latitude();
    double tlLon = d->topLeft.longitude();
    double brLat = d->bottomRight.latitude();
    double brLon = d->bottomRight.longitude();
 
    if (degreesLatitude >= 0.0)
        degreesLatitude = qMin(degreesLatitude, 90.0 - tlLat);
    else
        degreesLatitude = qMax(degreesLatitude, -90.0 - brLat);
 
    if ( (tlLon != -180.0) || (brLon != 180.0) ) {
        tlLon = QLocationUtils::wrapLong(tlLon + degreesLongitude);
        brLon = QLocationUtils::wrapLong(brLon + degreesLongitude);
    }
 
    tlLat += degreesLatitude;
    brLat += degreesLatitude;
 
    d->topLeft = QGeoCoordinate(tlLat, tlLon);
    d->bottomRight = QGeoCoordinate(brLat, brLon);
}
 
QGeoRectangle QGeoRectangle::translated(double degreesLatitude, double degreesLongitude) const
{
    QGeoRectangle result(*this);
    result.translate(degreesLatitude, degreesLongitude);
    return result;
}
 
void QGeoRectangle::extendRectangle(const QGeoCoordinate &coordinate)
{
    Q_D(QGeoRectangle);
    d->extendRectangle(coordinate);
}
 
QGeoRectangle QGeoRectangle::united(const QGeoRectangle &rectangle) const
{
    QGeoRectangle result(*this);
    if (rectangle.isValid())
        result |= rectangle;
    return result;
}
 
void QGeoRectanglePrivate::extendRectangle(const QGeoCoordinate &coordinate)
{
    if (!isValid() || !coordinate.isValid() || contains(coordinate))
        return;
 
    double left = topLeft.longitude();
    double right = bottomRight.longitude();
    double top = topLeft.latitude();
    double bottom = bottomRight.latitude();
 
    double inputLat = coordinate.latitude();
    double inputLon = coordinate.longitude();
 
    top = qMax(top, inputLat);
    bottom = qMin(bottom, inputLat);
 
    bool wrap = left > right;
 
    if (wrap && inputLon > right && inputLon < left) {
        if (qAbs(left - inputLon) < qAbs(right - inputLon))
            left = inputLon;
        else
            right = inputLon;
    } else if (!wrap) {
        if (inputLon < left) {
            if (360 - (right - inputLon) < left - inputLon)
                right = inputLon;
            else
                left = inputLon;
        } else if (inputLon > right) {
            if (360 - (inputLon - left) < inputLon - right)
                left = inputLon;
            else
                right = inputLon;
        }
    }
    topLeft = QGeoCoordinate(top, left);
    bottomRight = QGeoCoordinate(bottom, right);
}
 
QGeoRectangle &QGeoRectangle::operator|=(const QGeoRectangle &rectangle)
{
    // If non-intersecting goes for most narrow box
 
    Q_D(QGeoRectangle);
 
    double top = qMax(d->topLeft.latitude(), rectangle.d_func()->topLeft.latitude());
    double bottom = qMin(d->bottomRight.latitude(), rectangle.d_func()->bottomRight.latitude());
 
    QGeoRectangle candidate(
        {top, d->topLeft.longitude()},
        {bottom, rectangle.d_func()->bottomRight.longitude()}
    );
    QGeoRectangle otherCandidate(
        {top, rectangle.d_func()->topLeft.longitude()},
        {bottom, d->bottomRight.longitude()}
    );
    double unwrappedWidth = (candidate.width() < rectangle.width() ? 360 : 0) + candidate.width();
    double otherUnwrappedWidth = (otherCandidate.width() < width() ? 360 : 0) + otherCandidate.width();
    if (otherUnwrappedWidth < unwrappedWidth) {
        candidate = otherCandidate;
        unwrappedWidth = otherUnwrappedWidth;
    }
    if (360 <= unwrappedWidth) {
        candidate.d_func()->topLeft.setLongitude(-180.0);
        candidate.d_func()->bottomRight.setLongitude(180.0);
    }
 
    candidate = (candidate.width() < width() ? *this : candidate);
    candidate = (candidate.width() < rectangle.width() ? rectangle : candidate);
 
    double middle1 = center().longitude();
    double middle2 = rectangle.center().longitude();
    if ((middle1 <= middle2 ? 0 : 360) + middle2 - middle1 == 180) {
        candidate.d_func()->topLeft.setLongitude(-180.0);
        candidate.d_func()->bottomRight.setLongitude(180.0);
    }
 
    *this = candidate;
    this->d_func()->topLeft.setLatitude(top);
    this->d_func()->bottomRight.setLatitude(bottom);
 
    return *this;
}
 
QString QGeoRectangle::toString() const
{
    if (type() != QGeoShape::RectangleType) {
        qWarning("Not a rectangle a %d\n", type());
        return QStringLiteral("QGeoRectangle(not a rectangle)");
    }
 
    return QStringLiteral("QGeoRectangle({%1, %2}, {%3, %4})")
        .arg(topLeft().latitude())
        .arg(topLeft().longitude())
        .arg(bottomRight().latitude())
        .arg(bottomRight().longitude());
}
 
/*******************************************************************************
*******************************************************************************/
 
QGeoRectanglePrivate::QGeoRectanglePrivate()
:   QGeoShapePrivate(QGeoShape::RectangleType)
{
}
 
QGeoRectanglePrivate::QGeoRectanglePrivate(const QGeoCoordinate &topLeft,
                                               const QGeoCoordinate &bottomRight)
:   QGeoShapePrivate(QGeoShape::RectangleType), topLeft(topLeft), bottomRight(bottomRight)
{
}
 
QGeoRectanglePrivate::QGeoRectanglePrivate(const QGeoRectanglePrivate &other)
:   QGeoShapePrivate(QGeoShape::RectangleType), topLeft(other.topLeft),
    bottomRight(other.bottomRight)
{
}
 
QGeoRectanglePrivate::~QGeoRectanglePrivate() {}
 
QGeoShapePrivate *QGeoRectanglePrivate::clone() const
{
    return new QGeoRectanglePrivate(*this);
}
 
bool QGeoRectanglePrivate::operator==(const QGeoShapePrivate &other) const
{
    if (!QGeoShapePrivate::operator==(other))
        return false;
 
    const QGeoRectanglePrivate &otherBox = static_cast<const QGeoRectanglePrivate &>(other);
 
    return topLeft == otherBox.topLeft && bottomRight == otherBox.bottomRight;
}
 
size_t QGeoRectanglePrivate::hash(size_t seed) const
{
    return qHashMulti(seed, topLeft, bottomRight);
}
 
QT_END_NAMESPACE
 
#include "moc_qgeorectangle.cpp"