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
// Qt-Security score:significant reason:default
 
#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_));
}
 
/*!
    \class QGeoCameraCapabilities
    \inmodule QtLocation
    \ingroup QtLocation-impl
    \since 5.6
    \internal
 
    \brief The QGeoCameraCapabilities class describes the limitations on camera settings imposed by a mapping plugin.
 
    Different mapping plugins will support different ranges of zoom levels, and not all mapping plugins will
    be able to support, bearing, tilting and rolling of the camera.
 
    This class describes what the plugin supports, and is used to restrict changes to the camera information
    associated with a \l QGeoMap such that the camera information stays within these limits.
*/
 
/*!
    \qmlvaluetype cameraCapabilities
    \inqmlmodule QtLocation
    \ingroup qml-QtLocation5-maps
    \since QtLocation 5.10
 
    \brief The cameraCapabilities type holds information about the camera capabilities for a specific map type.
 
    This includes the map minimum and maximum zoom level, minimum and maximum tilt angle and
    minimum and maximum field of view.
*/
 
/*!
    Constructs a camera capabilities object.
*/
QGeoCameraCapabilities::QGeoCameraCapabilities()
    : d(new QGeoCameraCapabilitiesPrivate()) {}
 
/*!
    Constructs a camera capabilities object from the contents of \a other.
*/
QGeoCameraCapabilities::QGeoCameraCapabilities(const QGeoCameraCapabilities &other) noexcept = default;
 
/*!
    Destroys this camera capabilities object.
*/
QGeoCameraCapabilities::~QGeoCameraCapabilities() = default;
 
/*!
    Assigns the contents of \a other to this camera capabilities object and
    returns a reference to this camera capabilities object.
*/
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_;
}
 
/*!
    Returns whether this instance of the class is considered "valid". To be
    valid, the instance must have had at least one capability set (to either
    true or false) using a set method, or copied from another instance
    (such as by the assignment operator).
*/
bool QGeoCameraCapabilities::isValid() const
{
    return d->valid_;
}
 
/*!
    \qmlproperty real cameraCapabilities::minimumZoomLevel
 
    This read-only property holds the minimum available zoom level with this map type.
*/
 
/*!
    \property QGeoCameraCapabilities::minimumZoomLevel
    \brief the minimum zoom level supported by the associated plugin.
 
    Larger values of the zoom level correspond to more detailed views of the
    map.
*/
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_));
}
 
/*!
    \qmlproperty real cameraCapabilities::maximumZoomLevel
 
    This read-only property holds the maximum available zoom level with this map type.
*/
 
/*!
    \property QGeoCameraCapabilities::maximumZoomLevel
    \brief the maximum zoom level supported by the associated plugin.
 
    Larger values of the zoom level correspond to more detailed views of the
    map.
*/
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_));
}
 
/*!
    Sets whether the associated plugin can render a map when the camera
    has an arbitrary bearing to \a supportsBearing.
*/
void QGeoCameraCapabilities::setSupportsBearing(bool supportsBearing)
{
    d->supportsBearing_ = supportsBearing;
    d->valid_ = true;
}
 
/*!
    Returns whether the associated plugin can render a map when the camera
    has an arbitrary bearing.
*/
bool QGeoCameraCapabilities::supportsBearing() const
{
    return d->supportsBearing_;
}
 
/*!
    Sets whether the associated plugin can render a map when the
    camera is rolled to \a supportsRolling.
*/
void QGeoCameraCapabilities::setSupportsRolling(bool supportsRolling)
{
    d->supportsRolling_ = supportsRolling;
    d->valid_ = true;
}
 
/*!
    Returns whether the associated plugin can render a map when the
    camera is rolled.
*/
bool QGeoCameraCapabilities::supportsRolling() const
{
    return d->supportsRolling_;
}
 
/*!
    Sets whether the associated plugin can render a map when the
    camera is tilted to \a supportsTilting.
*/
void QGeoCameraCapabilities::setSupportsTilting(bool supportsTilting)
{
    d->supportsTilting_ = supportsTilting;
    d->valid_ = true;
}
 
/*!
    Returns whether the associated plugin can render a map when the
    camera is tilted.
*/
bool QGeoCameraCapabilities::supportsTilting() const
{
    return d->supportsTilting_;
}
 
/*!
    \qmlproperty real cameraCapabilities::minimumTilt
 
    This read-only property holds the minimum available tilt with this map type.
*/
 
/*!
    \property QGeoCameraCapabilities::minimumTilt
    \brief the minimum tilt supported by the associated plugin.
 
    The value is in degrees where 0 is equivalent to 90 degrees between
    the line of view and earth's surface, that is, looking straight down to earth.
*/
void QGeoCameraCapabilities::setMinimumTilt(double minimumTilt)
{
    d->minTilt_ = minimumTilt;
    d->valid_ = true;
}
 
double QGeoCameraCapabilities::minimumTilt() const
{
    return d->minTilt_;
}
 
/*!
    \qmlproperty real cameraCapabilities::maximumTilt
 
    This read-only property holds the maximum available tilt with this map type.
*/
 
/*!
    \property QGeoCameraCapabilities::maximumTilt
    \brief the maximum tilt supported by the associated plugin.
 
    The value is in degrees where 0 is equivalent to 90 degrees between
    the line of view and earth's surface, that is, looking straight down to earth.
*/
void QGeoCameraCapabilities::setMaximumTilt(double maximumTilt)
{
    d->maxTilt_ = maximumTilt;
    d->valid_ = true;
}
 
double QGeoCameraCapabilities::maximumTilt() const
{
    return d->maxTilt_;
}
 
/*!
    \qmlproperty real cameraCapabilities::minimumFieldOfView
 
    This read-only property holds the minimum available field of view with this map type.
*/
 
/*!
    \property QGeoCameraCapabilities::minimumFieldOfView
    \brief the minimum field of view supported by the associated plugin.
 
    The value is in degrees and is clamped against a [1, 179] range.
 
    \since 5.9
*/
void QGeoCameraCapabilities::setMinimumFieldOfView(double minimumFieldOfView)
{
    d->minimumFieldOfView_ = qBound(1.0, minimumFieldOfView, 179.0);
    d->valid_ = true;
}
 
double QGeoCameraCapabilities::minimumFieldOfView() const
{
    return d->minimumFieldOfView_;
}
 
/*!
    \qmlproperty real cameraCapabilities::maximumFieldOfView
 
    This read-only property holds the maximum available field of view with this map type.
*/
 
/*!
    \property QGeoCameraCapabilities::maximumFieldOfView
    \brief the maximum field of view supported by the associated plugin.
 
    The value is in degrees and is clamped against a [1, 179] range.
 
    \since 5.9
*/
void QGeoCameraCapabilities::setMaximumFieldOfView(double maximumFieldOfView)
{
    d->maximumFieldOfView_ = qBound(1.0, maximumFieldOfView, 179.0);
    d->valid_ = true;
}
 
double QGeoCameraCapabilities::maximumFieldOfView() const
{
    return d->maximumFieldOfView_;
}
 
/*!
    Sets whether overzooming is supported by the associated plugin.
 
    Overzooming means that zoom levels outside the [minimumZL, maximumZL] range can be set,
    and if tiles aren't available for those zoom levels, either tiles from other zoom levels
    will be used, or nothing will be shown.
 
    Set this value to false if the plugin is not capable of that. For example if using
    a mapping engine that always clamp the zoomLevel value, which may cause misalignment in case
    of stacked map elements.
 
    \since 5.9
*/
void QGeoCameraCapabilities::setOverzoomEnabled(bool overzoomEnabled)
{
    d->overzoomEnabled_ = overzoomEnabled;
    d->valid_ = true;
}
 
/*!
    Returns whether overzooming is supported by the associated plugin.
 
    \since 5.9
*/
bool QGeoCameraCapabilities::overzoomEnabled() const
{
    return d->overzoomEnabled_;
}
 
 
QT_END_NAMESPACE
 
#include "moc_qgeocameracapabilities_p.cpp"