src/map/mbtilesmap.cpp

   1 #include <QSqlQuery>
   2 #include <QSqlRecord>
   3 #include <QSqlField>
   4 #include <QSqlError>
   5 #include <QPainter>
   6 #include <QPixmapCache>
   7 #include <QImageReader>
   8 #include <QBuffer>
   9 #include <QtConcurrent>
  10 #include "common/util.h"
  11 #include "osm.h"
  12 #include "mbtilesmap.h"
  13
  14
  15 #define META_TYPE(type) static_cast<QMetaType::Type>(type)
  16
  17 class MBTile
  18 {
  19 public:
  20         MBTile(int zoom, int scaledSize, const QPoint &xy, const QByteArray &data,
  21           const QString &key) : _zoom(zoom), _scaledSize(scaledSize), _xy(xy),
  22           _data(data), _key(key) {}
  23
  24         const QPoint &xy() const {return _xy;}
  25         const QString &key() const {return _key;}
  26         const QPixmap &pixmap() const {return _pixmap;}
  27
  28         void load() {
  29                 QByteArray z(QString::number(_zoom).toLatin1());
  30
  31                 QBuffer buffer(&_data);
  32                 QImageReader reader(&buffer, z);
  33                 if (_scaledSize)
  34                         reader.setScaledSize(QSize(_scaledSize, _scaledSize));
  35                 _pixmap = QPixmap::fromImage(reader.read());
  36         }
  37
  38 private:
  39         int _zoom;
  40         int _scaledSize;
  41         QPoint _xy;
  42         QByteArray _data;
  43         QString _key;
  44         QPixmap _pixmap;
  45 };
  46
  47
  48 MBTilesMap::MBTilesMap(const QString &fileName, QObject *parent)
  49   : Map(fileName, parent), _mapRatio(1.0), _tileRatio(1.0), _scalable(false),
  50   _scaledSize(0), _valid(false)
  51 {
  52         if (!Util::isSQLiteDB(fileName, _errorString))
  53                 return;
  54
  55         _db = QSqlDatabase::addDatabase("QSQLITE", fileName);
  56         _db.setDatabaseName(fileName);
  57         _db.setConnectOptions("QSQLITE_OPEN_READONLY");
  58
  59         if (!_db.open()) {
  60                 _errorString = _db.lastError().text();
  61                 return;
  62         }
  63
  64         QSqlRecord r = _db.record("tiles");
  65         if (r.isEmpty()
  66           || r.field(0).name() != "zoom_level"
  67           || META_TYPE(r.field(0).type()) != QMetaType::Int
  68           || r.field(1).name() != "tile_column"
  69           || META_TYPE(r.field(1).type()) != QMetaType::Int
  70           || r.field(2).name() != "tile_row"
  71           || META_TYPE(r.field(2).type()) != QMetaType::Int
  72           || r.field(3).name() != "tile_data"
  73           || META_TYPE(r.field(3).type()) != QMetaType::QByteArray) {
  74                 _errorString = "Invalid table format";
  75                 return;
  76         }
  77
  78         {
  79                 QSqlQuery query("SELECT DISTINCT zoom_level FROM tiles"
  80                   " ORDER BY zoom_level", _db);
  81                 while (query.next())
  82                         _zooms.append(query.value(0).toInt());
  83                 if (_zooms.isEmpty()) {
  84                         _errorString = "Empty tile set";
  85                         return;
  86                 }
  87                 if (_zooms.first() < 0) {
  88                         _errorString = "Invalid zoom levels";
  89                         return;
  90                 }
  91         }
  92         _zi = _zooms.size() - 1;
  93
  94         {
  95                 int z = _zooms.first();
  96                 QString sql = QString("SELECT min(tile_column), min(tile_row), "
  97                   "max(tile_column), max(tile_row) FROM tiles WHERE zoom_level = %1")
  98                   .arg(z);
  99                 QSqlQuery query(sql, _db);
 100                 query.first();
 101
 102                 int minX = qMin((1<<z) - 1, qMax(0, query.value(0).toInt()));
 103                 int minY = qMin((1<<z) - 1, qMax(0, query.value(1).toInt()));
 104                 int maxX = qMin((1<<z) - 1, qMax(0, query.value(2).toInt())) + 1;
 105                 int maxY = qMin((1<<z) - 1, qMax(0, query.value(3).toInt())) + 1;
 106                 Coordinates tl(OSM::tile2ll(QPoint(minX, maxY), z));
 107                 Coordinates br(OSM::tile2ll(QPoint(maxX, minY), z));
 108                 // Workaround of broken zoom levels 0 and 1 due to numerical instability
 109                 tl.rlat() = qMin(tl.lat(), OSM::BOUNDS.top());
 110                 br.rlat() = qMax(br.lat(), OSM::BOUNDS.bottom());
 111                 _bounds = RectC(tl, br);
 112         }
 113
 114         {
 115                 QString sql = QString("SELECT tile_data FROM tiles LIMIT 1");
 116                 QSqlQuery query(sql, _db);
 117                 query.first();
 118
 119                 QByteArray data = query.value(0).toByteArray();
 120                 QBuffer buffer(&data);
 121                 QImageReader reader(&buffer);
 122                 QSize tileSize(reader.size());
 123
 124                 if (!tileSize.isValid() || tileSize.width() != tileSize.height()) {
 125                         _errorString = "Unsupported/invalid tile images";
 126                         return;
 127                 }
 128                 _tileSize = tileSize.width();
 129         }
 130
 131         {
 132                 QSqlQuery query("SELECT value FROM metadata WHERE name = 'format'", _db);
 133                 if (query.first()) {
 134                         if (query.value(0).toString() == "pbf")
 135                                 _scalable = true;
 136                 } else
 137                         qWarning("%s: missing tiles format", qPrintable(fileName));
 138         }
 139
 140         {
 141                 QSqlQuery query("SELECT value FROM metadata WHERE name = 'name'", _db);
 142                 if (query.first())
 143                         _name = query.value(0).toString();
 144                 else {
 145                         qWarning("%s: missing map name", qPrintable(fileName));
 146                         _name = Util::file2name(fileName);
 147                 }
 148         }
 149
 150         {
 151                 QSqlQuery query(
 152                   "SELECT value FROM metadata WHERE name = 'tilepixelratio'", _db);
 153                 if (query.first()) {
 154                         bool ok;
 155                         _tileRatio = query.value(0).toString().toDouble(&ok);
 156                         if (!ok) {
 157                                 _errorString = "Invalid tile pixel ratio";
 158                                 return;
 159                         }
 160                 }
 161         }
 162
 163         _db.close();
 164
 165         _valid = true;
 166 }
 167
 168 void MBTilesMap::load(const Projection &in, const Projection &out,
 169   qreal deviceRatio, bool hidpi)
 170 {
 171         Q_UNUSED(in);
 172         Q_UNUSED(out);
 173
 174         _mapRatio = hidpi ? deviceRatio : 1.0;
 175
 176         if (_scalable) {
 177                 _scaledSize = _tileSize * deviceRatio;
 178                 _tileRatio = deviceRatio;
 179         }
 180
 181         _db.open();
 182 }
 183
 184 void MBTilesMap::unload()
 185 {
 186         _db.close();
 187 }
 188
 189 QRectF MBTilesMap::bounds()
 190 {
 191         return QRectF(ll2xy(_bounds.topLeft()), ll2xy(_bounds.bottomRight()));
 192 }
 193
 194 int MBTilesMap::zoomFit(const QSize &size, const RectC &rect)
 195 {
 196         if (!rect.isValid())
 197                 _zi = _zooms.size() - 1;
 198         else {
 199                 QRectF tbr(OSM::ll2m(rect.topLeft()), OSM::ll2m(rect.bottomRight()));
 200                 QPointF sc(tbr.width() / size.width(), tbr.height() / size.height());
 201                 int zoom = OSM::scale2zoom(qMax(sc.x(), -sc.y()) / coordinatesRatio(),
 202                   _tileSize);
 203
 204                 _zi = 0;
 205                 for (int i = 1; i < _zooms.size(); i++) {
 206                         if (_zooms.at(i) > zoom)
 207                                 break;
 208                         _zi = i;
 209                 }
 210         }
 211
 212         return _zi;
 213 }
 214
 215 qreal MBTilesMap::resolution(const QRectF &rect)
 216 {
 217         return OSM::resolution(rect.center(), _zooms.at(_zi), _tileSize);
 218 }
 219
 220 int MBTilesMap::zoomIn()
 221 {
 222         _zi = qMin(_zi + 1, _zooms.size() - 1);
 223         return _zi;
 224 }
 225
 226 int MBTilesMap::zoomOut()
 227 {
 228         _zi = qMax(_zi - 1, 0);
 229         return _zi;
 230 }
 231
 232 qreal MBTilesMap::coordinatesRatio() const
 233 {
 234         return _mapRatio > 1.0 ? _mapRatio / _tileRatio : 1.0;
 235 }
 236
 237 qreal MBTilesMap::imageRatio() const
 238 {
 239         return _mapRatio > 1.0 ? _mapRatio : _tileRatio;
 240 }
 241
 242 qreal MBTilesMap::tileSize() const
 243 {
 244         return (_tileSize / coordinatesRatio());
 245 }
 246
 247 QByteArray MBTilesMap::tileData(int zoom, const QPoint &tile) const
 248 {
 249         QSqlQuery query(_db);
 250         query.prepare("SELECT tile_data FROM tiles "
 251           "WHERE zoom_level=:zoom AND tile_column=:x AND tile_row=:y");
 252         query.bindValue(":zoom", zoom);
 253         query.bindValue(":x", tile.x());
 254         query.bindValue(":y", (1<<zoom) - tile.y() - 1);
 255         query.exec();
 256
 257         if (query.first())
 258                 return query.value(0).toByteArray();
 259
 260         return QByteArray();
 261 }
 262
 263 void MBTilesMap::draw(QPainter *painter, const QRectF &rect, Flags flags)
 264 {
 265         Q_UNUSED(flags);
 266         int zoom = _zooms.at(_zi);
 267         qreal scale = OSM::zoom2scale(zoom, _tileSize);
 268         QRectF b(bounds());
 269
 270
 271         QPoint tile = OSM::mercator2tile(QPointF(rect.topLeft().x() * scale,
 272           -rect.topLeft().y() * scale) * coordinatesRatio(), zoom);
 273         QPointF tl(floor(rect.left() / tileSize())
 274           * tileSize(), floor(rect.top() / tileSize()) * tileSize());
 275
 276         QSizeF s(qMin(rect.right() - tl.x(), b.width()),
 277           qMin(rect.bottom() - tl.y(), b.height()));
 278         int width = ceil(s.width() / tileSize());
 279         int height = ceil(s.height() / tileSize());
 280
 281
 282         QList<MBTile> tiles;
 283
 284         for (int i = 0; i < width; i++) {
 285                 for (int j = 0; j < height; j++) {
 286                         QPixmap pm;
 287                         QPoint t(tile.x() + i, tile.y() + j);
 288                         QString key = path() + "-" + QString::number(zoom) + "_"
 289                           + QString::number(t.x()) + "_" + QString::number(t.y());
 290
 291                         if (QPixmapCache::find(key, &pm)) {
 292                                 QPointF tp(qMax(tl.x(), b.left()) + (t.x() - tile.x())
 293                                   * tileSize(), qMax(tl.y(), b.top()) + (t.y() - tile.y())
 294                                   * tileSize());
 295                                 drawTile(painter, pm, tp);
 296                         } else {
 297                                 tiles.append(MBTile(zoom, _scaledSize, t, tileData(zoom, t),
 298                                   key));
 299                         }
 300                 }
 301         }
 302
 303         QFuture<void> future = QtConcurrent::map(tiles, &MBTile::load);
 304         future.waitForFinished();
 305
 306         for (int i = 0; i < tiles.size(); i++) {
 307                 const MBTile &mt = tiles.at(i);
 308                 QPixmap pm(mt.pixmap());
 309                 if (pm.isNull())
 310                         continue;
 311
 312                 QPixmapCache::insert(mt.key(), pm);
 313
 314                 QPointF tp(qMax(tl.x(), b.left()) + (mt.xy().x() - tile.x())
 315                   * tileSize(), qMax(tl.y(), b.top()) + (mt.xy().y() - tile.y())
 316                   * tileSize());
 317                 drawTile(painter, pm, tp);
 318         }
 319 }
 320
 321 void MBTilesMap::drawTile(QPainter *painter, QPixmap &pixmap, QPointF &tp)
 322 {
 323         pixmap.setDevicePixelRatio(imageRatio());
 324         painter->drawPixmap(tp, pixmap);
 325 }
 326
 327 QPointF MBTilesMap::ll2xy(const Coordinates &c)
 328 {
 329         qreal scale = OSM::zoom2scale(_zooms.at(_zi), _tileSize);
 330         QPointF m = OSM::ll2m(c);
 331         return QPointF(m.x() / scale, m.y() / -scale) / coordinatesRatio();
 332 }
 333
 334 Coordinates MBTilesMap::xy2ll(const QPointF &p)
 335 {
 336         qreal scale = OSM::zoom2scale(_zooms.at(_zi), _tileSize);
 337         return OSM::m2ll(QPointF(p.x() * scale, -p.y() * scale)
 338           * coordinatesRatio());
 339 }
 340
 341 Map *MBTilesMap::create(const QString &path, const Projection &proj, bool *isDir)
 342 {
 343         Q_UNUSED(proj);
 344
 345         if (isDir)
 346                 *isDir = false;
 347
 348         return new MBTilesMap(path);
 349 }