1
0
mirror of https://github.com/tumic0/GPXSee.git synced 2025-03-18 20:47:46 +01:00
GPXSee/src/map/onlinemap.h

141 lines
3.2 KiB
C
Raw Normal View History

#ifndef ONLINEMAP_H
#define ONLINEMAP_H
#include <QImageReader>
#include <QPixmap>
#include <QtConcurrent>
2017-11-26 18:54:03 +01:00
#include "common/range.h"
#include "common/rectc.h"
#include "map.h"
2018-02-20 23:37:19 +01:00
#include "tileloader.h"
class OnlineMapTile
{
public:
OnlineMapTile(const QPoint &xy, const QString &file, int zoom, int overzoom,
int scaledSize, const QString &key) : _zoom(zoom), _overzoom(overzoom),
_scaledSize(scaledSize), _xy(xy), _file(file), _key(key) {}
void load()
{
QByteArray format(_overzoom
? QByteArray::number(_zoom) + ';' + QByteArray::number(_overzoom)
: QByteArray::number(_zoom));
QImageReader reader(_file, format);
if (_scaledSize)
reader.setScaledSize(QSize(_scaledSize, _scaledSize));
_pixmap = QPixmap::fromImage(reader.read());
}
const QPoint &xy() const {return _xy;}
const QPixmap &pixmap() const {return _pixmap;}
const QString &key() const {return _key;}
private:
int _zoom;
int _overzoom;
int _scaledSize;
QPoint _xy;
QString _file;
QString _key;
QPixmap _pixmap;
};
class OnlineMapJob : public QObject
{
Q_OBJECT
public:
OnlineMapJob(const QList<OnlineMapTile> &tiles) : _tiles(tiles) {}
void run()
{
connect(&_watcher, &QFutureWatcher<void>::finished, this,
&OnlineMapJob::handleFinished);
_future = QtConcurrent::map(_tiles, &OnlineMapTile::load);
_watcher.setFuture(_future);
}
void cancel(bool wait)
{
_future.cancel();
if (wait)
_future.waitForFinished();
}
const QList<OnlineMapTile> &tiles() const {return _tiles;}
signals:
void finished(OnlineMapJob *job);
private slots:
void handleFinished() {emit finished(this);}
private:
QFutureWatcher<void> _watcher;
QFuture<void> _future;
QList<OnlineMapTile> _tiles;
};
class OnlineMap : public Map
{
Q_OBJECT
public:
2020-12-02 23:58:11 +01:00
OnlineMap(const QString &fileName, const QString &name, const QString &url,
const Range &zooms, const RectC &bounds, qreal tileRatio,
const QList<HTTPHeader> &headers, int tileSize, bool scalable,
2020-12-02 23:58:11 +01:00
bool invertY, bool quadTiles, QObject *parent = 0);
2018-07-13 09:51:41 +02:00
QString name() const {return _name;}
2018-07-13 09:51:41 +02:00
QRectF bounds();
RectC llBounds() {return _bounds;}
qreal resolution(const QRectF &rect);
int zoom() const {return _zoom;}
2018-04-28 22:18:11 +02:00
void setZoom(int zoom) {_zoom = zoom;}
int zoomFit(const QSize &size, const RectC &rect);
int zoomIn();
int zoomOut();
2018-07-13 09:51:41 +02:00
QPointF ll2xy(const Coordinates &c);
Coordinates xy2ll(const QPointF &p);
2018-08-23 20:26:10 +02:00
void draw(QPainter *painter, const QRectF &rect, Flags flags);
void load(const Projection &in, const Projection &out, qreal deviceRatio,
bool hidpi);
void unload();
void clearCache();
2017-10-04 23:15:39 +02:00
private slots:
void jobFinished(OnlineMapJob *job);
private:
int limitZoom(int zoom) const;
2018-08-18 21:06:36 +02:00
qreal tileSize() const;
qreal coordinatesRatio() const;
qreal imageRatio() const;
QPoint tileCoordinates(int x, int y, int zoom);
void drawTile(QPainter *painter, QPixmap &pixmap, QPointF &tp);
bool isRunning(const QString &key) const;
void runJob(OnlineMapJob *job);
void removeJob(OnlineMapJob *job);
void cancelJobs(bool wait);
TileLoader *_tileLoader;
QString _name;
Range _zooms;
RectC _bounds;
int _zoom;
int _tileSize;
2023-12-11 21:13:11 +01:00
int _baseZoom;
qreal _mapRatio, _tileRatio;
bool _scalable;
int _scaledSize;
2018-09-22 13:32:54 +02:00
bool _invertY;
QList<OnlineMapJob*> _jobs;
};
#endif // ONLINEMAP_H