src/map/onlinemap.cpp

   1 #include <QPainter>
   2 #include <QDir>
   3 #include <QPixmapCache>
   4 #include "common/rectc.h"
   5 #include "common/programpaths.h"
   6 #include "common/downloader.h"
   7 #include "osm.h"
   8 #include "onlinemap.h"
   9
  10
  11 #define MAX_TILE_SIZE 4096
  12
  13 OnlineMap::OnlineMap(const QString &fileName, const QString &name,
  14   const QString &url, const Range &zooms, const RectC &bounds, qreal tileRatio,
  15   const QList<HTTPHeader> &headers, int tileSize, bool scalable, bool invertY,
  16   bool quadTiles, QObject *parent)
  17     : Map(fileName, parent), _name(name), _zooms(zooms), _bounds(bounds),
  18         _zoom(_zooms.max()), _tileSize(tileSize), _baseZoom(0), _mapRatio(1.0),
  19         _tileRatio(tileRatio), _scalable(scalable), _scaledSize(0), _invertY(invertY)
  20 {
  21         _tileLoader = new TileLoader(QDir(ProgramPaths::tilesDir()).filePath(_name),
  22           this);
  23         _tileLoader->setUrl(url, quadTiles ? TileLoader::QuadTiles : TileLoader::XYZ);
  24         _tileLoader->setHeaders(headers);
  25         connect(_tileLoader, &TileLoader::finished, this, &OnlineMap::tilesLoaded);
  26
  27         _baseZoom = _zooms.max();
  28 }
  29
  30 QRectF OnlineMap::bounds()
  31 {
  32         return QRectF(ll2xy(_bounds.topLeft()), ll2xy(_bounds.bottomRight()));
  33 }
  34
  35 int OnlineMap::limitZoom(int zoom) const
  36 {
  37         if (zoom < _zooms.min())
  38                 return _zooms.min();
  39         if (zoom > _zooms.max())
  40                 return _zooms.max();
  41
  42         return zoom;
  43 }
  44
  45 int OnlineMap::zoomFit(const QSize &size, const RectC &rect)
  46 {
  47         if (!rect.isValid())
  48                 _zoom = _zooms.max();
  49         else {
  50                 QRectF tbr(OSM::ll2m(rect.topLeft()), OSM::ll2m(rect.bottomRight()));
  51                 QPointF sc(tbr.width() / size.width(), tbr.height() / size.height());
  52                 _zoom = limitZoom(OSM::scale2zoom(qMax(sc.x(), -sc.y())
  53                   / coordinatesRatio(), _tileSize));
  54         }
  55
  56         return _zoom;
  57 }
  58
  59 qreal OnlineMap::resolution(const QRectF &rect)
  60 {
  61         return OSM::resolution(rect.center(), _zoom, _tileSize);
  62 }
  63
  64 int OnlineMap::zoomIn()
  65 {
  66         cancelJobs(false);
  67
  68         _zoom = qMin(_zoom + 1, _zooms.max());
  69         return _zoom;
  70 }
  71
  72 int OnlineMap::zoomOut()
  73 {
  74         cancelJobs(false);
  75
  76         _zoom = qMax(_zoom - 1, _zooms.min());
  77         return _zoom;
  78 }
  79
  80 void OnlineMap::load(const Projection &in, const Projection &out,
  81   qreal deviceRatio, bool hidpi)
  82 {
  83         Q_UNUSED(in);
  84         Q_UNUSED(out);
  85
  86         _mapRatio = hidpi ? deviceRatio : 1.0;
  87         _zooms.setMax(_baseZoom);
  88
  89         if (_scalable) {
  90                 _scaledSize = _tileSize * deviceRatio;
  91                 _tileRatio = deviceRatio;
  92
  93                 for (int i = _baseZoom + 1; i <= OSM::ZOOMS.max(); i++) {
  94                         if (_tileSize * _tileRatio * (1U<<(i - _baseZoom)) > MAX_TILE_SIZE)
  95                                 break;
  96                         _zooms.setMax(i);
  97                 }
  98         }
  99 }
 100
 101 void OnlineMap::unload()
 102 {
 103         cancelJobs(true);
 104 }
 105
 106 qreal OnlineMap::coordinatesRatio() const
 107 {
 108         return _mapRatio > 1.0 ? _mapRatio / _tileRatio : 1.0;
 109 }
 110
 111 qreal OnlineMap::imageRatio() const
 112 {
 113         return _mapRatio > 1.0 ? _mapRatio : _tileRatio;
 114 }
 115
 116 qreal OnlineMap::tileSize() const
 117 {
 118         return (_tileSize / coordinatesRatio());
 119 }
 120
 121 QPoint OnlineMap::tileCoordinates(int x, int y, int zoom)
 122 {
 123         return QPoint(x, _invertY ? (1<<zoom) - y - 1 : y);
 124 }
 125
 126 bool OnlineMap::isRunning(const QString &key) const
 127 {
 128         for (int i = 0; i < _jobs.size(); i++) {
 129                 const QList<OnlineMapTile> &tiles = _jobs.at(i)->tiles();
 130                 for (int j = 0; j < tiles.size(); j++)
 131                         if (tiles.at(j).key() == key)
 132                                 return true;
 133         }
 134
 135         return false;
 136 }
 137
 138 void OnlineMap::runJob(OnlineMapJob *job)
 139 {
 140         _jobs.append(job);
 141
 142         connect(job, &OnlineMapJob::finished, this, &OnlineMap::jobFinished);
 143         job->run();
 144 }
 145
 146 void OnlineMap::removeJob(OnlineMapJob *job)
 147 {
 148         _jobs.removeOne(job);
 149         job->deleteLater();
 150 }
 151
 152 void OnlineMap::jobFinished(OnlineMapJob *job)
 153 {
 154         const QList<OnlineMapTile> &tiles = job->tiles();
 155
 156         for (int i = 0; i < tiles.size(); i++) {
 157                 const OnlineMapTile &mt = tiles.at(i);
 158                 if (!mt.pixmap().isNull())
 159                         QPixmapCache::insert(mt.key(), mt.pixmap());
 160         }
 161
 162         removeJob(job);
 163
 164         emit tilesLoaded();
 165 }
 166
 167 void OnlineMap::cancelJobs(bool wait)
 168 {
 169         for (int i = 0; i < _jobs.size(); i++)
 170                 _jobs.at(i)->cancel(wait);
 171 }
 172
 173 void OnlineMap::draw(QPainter *painter, const QRectF &rect, Flags flags)
 174 {
 175         int baseZoom = qMin(_baseZoom, _zoom);
 176         unsigned overzoom = _zoom - baseZoom;
 177         unsigned f = 1U<<overzoom;
 178
 179         qreal scale = OSM::zoom2scale(baseZoom, _tileSize * f);
 180         QPoint tile = OSM::mercator2tile(QPointF(rect.topLeft().x() * scale,
 181           -rect.topLeft().y() * scale) * coordinatesRatio(), baseZoom);
 182         Coordinates ctl(OSM::tile2ll(tile, baseZoom));
 183         QPointF tl(ll2xy(Coordinates(ctl.lon(), -ctl.lat())));
 184         QSizeF s(rect.right() - tl.x(), rect.bottom() - tl.y());
 185         int width = ceil(s.width() / (tileSize() * f));
 186         int height = ceil(s.height() / (tileSize() * f));
 187
 188         QVector<TileLoader::Tile> fetchTiles;
 189         fetchTiles.reserve(width * height);
 190         for (int i = 0; i < width; i++) {
 191                 for (int j = 0; j < height; j++) {
 192                         QPoint tc(tileCoordinates(tile.x() + i, tile.y() + j, baseZoom));
 193                         fetchTiles.append(TileLoader::Tile(tc, baseZoom));
 194                 }
 195         }
 196
 197         if (flags & Map::Block)
 198                 _tileLoader->loadTilesSync(fetchTiles);
 199         else
 200                 _tileLoader->loadTilesAsync(fetchTiles);
 201
 202         QList<OnlineMapTile> renderTiles;
 203         for (int i = 0; i < fetchTiles.count(); i++) {
 204                 const TileLoader::Tile &t = fetchTiles.at(i);
 205                 if (t.file().isNull())
 206                         continue;
 207
 208                 QString key(overzoom
 209                   ? t.file() + ":" + QString::number(overzoom) : t.file());
 210                 if (isRunning(key))
 211                         continue;
 212
 213                 QPixmap pm;
 214                 if (QPixmapCache::find(key, &pm)) {
 215                         QPoint tc(tileCoordinates(t.xy().x(), t.xy().y(), baseZoom));
 216                         QPointF tp(tl.x() + (tc.x() - tile.x()) * tileSize() * f,
 217                           tl.y() + (tc.y() - tile.y()) * tileSize() * f);
 218                         drawTile(painter, pm, tp);
 219                 } else
 220                         renderTiles.append(OnlineMapTile(t.xy(), t.file(), _zoom, overzoom,
 221                           _scaledSize, key));
 222         }
 223
 224         if (!renderTiles.isEmpty()) {
 225                 if (flags & Map::Block || !_scalable) {
 226                         QFuture<void> future = QtConcurrent::map(renderTiles,
 227                           &OnlineMapTile::load);
 228                         future.waitForFinished();
 229
 230                         for (int i = 0; i < renderTiles.size(); i++) {
 231                                 const OnlineMapTile &mt = renderTiles.at(i);
 232                                 QPixmap pm(mt.pixmap());
 233                                 if (pm.isNull())
 234                                         continue;
 235
 236                                 QPixmapCache::insert(mt.key(), pm);
 237
 238                                 QPoint tc(tileCoordinates(mt.xy().x(), mt.xy().y(), baseZoom));
 239                                 QPointF tp(tl.x() + (tc.x() - tile.x()) * tileSize() * f,
 240                                   tl.y() + (tc.y() - tile.y()) * tileSize() * f);
 241                                 drawTile(painter, pm, tp);
 242                         }
 243                 } else
 244                         runJob(new OnlineMapJob(renderTiles));
 245         }
 246 }
 247
 248 void OnlineMap::drawTile(QPainter *painter, QPixmap &pixmap, QPointF &tp)
 249 {
 250         pixmap.setDevicePixelRatio(imageRatio());
 251         painter->drawPixmap(tp, pixmap);
 252 }
 253
 254 QPointF OnlineMap::ll2xy(const Coordinates &c)
 255 {
 256         qreal scale = OSM::zoom2scale(_zoom, _tileSize);
 257         QPointF m = OSM::ll2m(c);
 258         return QPointF(m.x() / scale, m.y() / -scale) / coordinatesRatio();
 259 }
 260
 261 Coordinates OnlineMap::xy2ll(const QPointF &p)
 262 {
 263         qreal scale = OSM::zoom2scale(_zoom, _tileSize);
 264         return OSM::m2ll(QPointF(p.x() * scale, -p.y() * scale)
 265           * coordinatesRatio());
 266 }
 267
 268 void OnlineMap::clearCache()
 269 {
 270         _tileLoader->clearCache();
 271         QPixmapCache::clear();
 272 }