qgeocameracapabilities.cpp

Go to the documentation of this file.

// Copyright (C) 2022 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 "qgeocameracapabilities_p.h"
 
#include <QSharedData>
#include <cmath>
 
static double zoomLevelTo256(double zoomLevelForTileSize, double tileSize)
{
    return std::log(std::pow(2.0, zoomLevelForTileSize) * tileSize / 256.0) * (1.0 / std::log(2.0));
}
 
QT_BEGIN_NAMESPACE
 
class QGeoCameraCapabilitiesPrivate : public QSharedData
{
public:
    bool operator==(const QGeoCameraCapabilitiesPrivate &rhs) const noexcept;
 
    bool supportsBearing_ = false;
    bool supportsRolling_ = false;
    bool supportsTilting_ = false;
 
    // this is mutable so that it can be set from accessor functions that are const
    // TODO: remove the mutable here
    mutable bool valid_ = false;
 
    double minZoom_ = 0.0;
    double maxZoom_ = 0.0;
    double minTilt_ = 0.0;
    double maxTilt_ = 0.0;
    int tileSize_ = 256;
    double minimumFieldOfView_ = 45.0; // Defaulting to a fixed FOV of 45 degrees.
    double maximumFieldOfView_ = 45.0; // Too large FOVs cause the loading of too many tiles.
    bool overzoomEnabled_ = false;
};
 
QT_DEFINE_QSDP_SPECIALIZATION_DTOR(QGeoCameraCapabilitiesPrivate)
 
bool QGeoCameraCapabilitiesPrivate::operator==(const QGeoCameraCapabilitiesPrivate &rhs) const noexcept
{
    return ((supportsBearing_ == rhs.supportsBearing_)
            && (supportsRolling_ == rhs.supportsRolling_)
            && (supportsTilting_ == rhs.supportsTilting_)
            && (valid_ == rhs.valid_)
            && (minZoom_ == rhs.minZoom_)
            && (maxZoom_ == rhs.maxZoom_)
            && (minTilt_ == rhs.minTilt_)
            && (maxTilt_ == rhs.maxTilt_)
            && (tileSize_ == rhs.tileSize_)
            && (minimumFieldOfView_ == rhs.minimumFieldOfView_)
            && (maximumFieldOfView_ == rhs.maximumFieldOfView_)
            && (overzoomEnabled_ == rhs.overzoomEnabled_));
}
 
QGeoCameraCapabilities::QGeoCameraCapabilities()
    : d(new QGeoCameraCapabilitiesPrivate()) {}
 
QGeoCameraCapabilities::QGeoCameraCapabilities(const QGeoCameraCapabilities &other) noexcept = default;
 
QGeoCameraCapabilities::~QGeoCameraCapabilities() = default;
 
QGeoCameraCapabilities &QGeoCameraCapabilities::operator=(const QGeoCameraCapabilities &other) noexcept
{
    if (this == &other)
        return *this;
 
    d = other.d;
    return *this;
}
 
bool QGeoCameraCapabilities::isEqual(const QGeoCameraCapabilities &other) const
{
    return (*(d.constData()) == *(other.d.constData()));
}
 
void QGeoCameraCapabilities::setTileSize(int tileSize)
{
    if (tileSize < 1)
        return;
    d->tileSize_ = tileSize;
}
 
int QGeoCameraCapabilities::tileSize() const
{
    return d->tileSize_;
}
 
bool QGeoCameraCapabilities::isValid() const
{
    return d->valid_;
}
 
void QGeoCameraCapabilities::setMinimumZoomLevel(double minimumZoomLevel)
{
    d->minZoom_ = minimumZoomLevel;
    d->valid_ = true;
}
 
double QGeoCameraCapabilities::minimumZoomLevel() const
{
    return d->minZoom_;
}
 
double QGeoCameraCapabilities::minimumZoomLevelAt256() const
{
    if (d->tileSize_ == 256)
        return d->minZoom_;
    return qMax<double>(0, zoomLevelTo256(d->minZoom_, d->tileSize_));
}
 
void QGeoCameraCapabilities::setMaximumZoomLevel(double maximumZoomLevel)
{
    d->maxZoom_ = maximumZoomLevel;
    d->valid_ = true;
}
 
double QGeoCameraCapabilities::maximumZoomLevel() const
{
    return d->maxZoom_;
}
 
double QGeoCameraCapabilities::maximumZoomLevelAt256() const
{
    if (d->tileSize_ == 256)
        return d->maxZoom_;
    return qMax<double>(0, zoomLevelTo256(d->maxZoom_, d->tileSize_));
}
 
void QGeoCameraCapabilities::setSupportsBearing(bool supportsBearing)
{
    d->supportsBearing_ = supportsBearing;
    d->valid_ = true;
}
 
bool QGeoCameraCapabilities::supportsBearing() const
{
    return d->supportsBearing_;
}
 
void QGeoCameraCapabilities::setSupportsRolling(bool supportsRolling)
{
    d->supportsRolling_ = supportsRolling;
    d->valid_ = true;
}
 
bool QGeoCameraCapabilities::supportsRolling() const
{
    return d->supportsRolling_;
}
 
void QGeoCameraCapabilities::setSupportsTilting(bool supportsTilting)
{
    d->supportsTilting_ = supportsTilting;
    d->valid_ = true;
}
 
bool QGeoCameraCapabilities::supportsTilting() const
{
    return d->supportsTilting_;
}
 
void QGeoCameraCapabilities::setMinimumTilt(double minimumTilt)
{
    d->minTilt_ = minimumTilt;
    d->valid_ = true;
}
 
double QGeoCameraCapabilities::minimumTilt() const
{
    return d->minTilt_;
}
 
void QGeoCameraCapabilities::setMaximumTilt(double maximumTilt)
{
    d->maxTilt_ = maximumTilt;
    d->valid_ = true;
}
 
double QGeoCameraCapabilities::maximumTilt() const
{
    return d->maxTilt_;
}
 
void QGeoCameraCapabilities::setMinimumFieldOfView(double minimumFieldOfView)
{
    d->minimumFieldOfView_ = qBound(1.0, minimumFieldOfView, 179.0);
    d->valid_ = true;
}
 
double QGeoCameraCapabilities::minimumFieldOfView() const
{
    return d->minimumFieldOfView_;
}
 
void QGeoCameraCapabilities::setMaximumFieldOfView(double maximumFieldOfView)
{
    d->maximumFieldOfView_ = qBound(1.0, maximumFieldOfView, 179.0);
    d->valid_ = true;
}
 
double QGeoCameraCapabilities::maximumFieldOfView() const
{
    return d->maximumFieldOfView_;
}
 
void QGeoCameraCapabilities::setOverzoomEnabled(bool overzoomEnabled)
{
    d->overzoomEnabled_ = overzoomEnabled;
    d->valid_ = true;
}
 
bool QGeoCameraCapabilities::overzoomEnabled() const
{
    return d->overzoomEnabled_;
}
 
 
QT_END_NAMESPACE
 
#include "moc_qgeocameracapabilities_p.cpp"