src/map/encmap.cpp

   1 #include <QPainter>
   2 #include <QPixmapCache>
   3 #include "common/range.h"
   4 #include "common/wgs84.h"
   5 #include "rectd.h"
   6 #include "pcs.h"
   7 #include "encmap.h"
   8
   9 #define TILE_SIZE 512
  10 #define TEXT_EXTENT 160
  11
  12 using namespace ENC;
  13
  14
  15 ENCMap::ENCMap(const QString &fileName, QObject *parent)
  16   : Map(fileName, parent), _data(fileName), _projection(PCS::pcs(3857)),
  17   _tileRatio(1.0), _zoom(0)
  18 {
  19         if (_data.isValid()) {
  20                 _llBounds = _data.bounds();
  21                 updateTransform();
  22         }
  23 }
  24
  25 void ENCMap::load(const Projection &in, const Projection &out,
  26   qreal deviceRatio, bool hidpi)
  27 {
  28         Q_UNUSED(in);
  29         Q_UNUSED(hidpi);
  30
  31         _tileRatio = deviceRatio;
  32         _projection = out;
  33         _data.load();
  34         QPixmapCache::clear();
  35 }
  36
  37 void ENCMap::unload()
  38 {
  39         cancelJobs(true);
  40         _data.clear();
  41 }
  42
  43 int ENCMap::zoomFit(const QSize &size, const RectC &rect)
  44 {
  45         if (rect.isValid()) {
  46                 RectD pr(rect, _projection, 10);
  47
  48                 _zoom = _data.zooms().min();
  49                 for (int i = _data.zooms().min() + 1; i <= _data.zooms().max(); i++) {
  50                         Transform t(transform(i));
  51                         QRectF r(t.proj2img(pr.topLeft()), t.proj2img(pr.bottomRight()));
  52                         if (size.width() < r.width() || size.height() < r.height())
  53                                 break;
  54                         _zoom = i;
  55                 }
  56         } else
  57                 _zoom = _data.zooms().max();
  58
  59         updateTransform();
  60
  61         return _zoom;
  62 }
  63
  64 int ENCMap::zoomIn()
  65 {
  66         cancelJobs(false);
  67
  68         _zoom = qMin(_zoom + 1, _data.zooms().max());
  69         updateTransform();
  70         return _zoom;
  71 }
  72
  73 int ENCMap::zoomOut()
  74 {
  75         cancelJobs(false);
  76
  77         _zoom = qMax(_zoom - 1, _data.zooms().min());
  78         updateTransform();
  79         return _zoom;
  80 }
  81
  82 void ENCMap::setZoom(int zoom)
  83 {
  84         _zoom = zoom;
  85         updateTransform();
  86 }
  87
  88 Transform ENCMap::transform(int zoom) const
  89 {
  90         int z = zoom + Util::log2i(TILE_SIZE);
  91
  92         double scale = _projection.isGeographic()
  93           ? 360.0 / (1<<z) : (2.0 * M_PI * WGS84_RADIUS) / (1<<z);
  94         PointD topLeft(_projection.ll2xy(_llBounds.topLeft()));
  95         return Transform(ReferencePoint(PointD(0, 0), topLeft),
  96           PointD(scale, scale));
  97 }
  98
  99 void ENCMap::updateTransform()
 100 {
 101         _transform = transform(_zoom);
 102
 103         RectD prect(_llBounds, _projection);
 104         _bounds = QRectF(_transform.proj2img(prect.topLeft()),
 105           _transform.proj2img(prect.bottomRight()));
 106 }
 107
 108 bool ENCMap::isRunning(int zoom, const QPoint &xy) const
 109 {
 110         for (int i = 0; i < _jobs.size(); i++) {
 111                 const QList<ENC::RasterTile> &tiles = _jobs.at(i)->tiles();
 112                 for (int j = 0; j < tiles.size(); j++) {
 113                         const ENC::RasterTile &mt = tiles.at(j);
 114                         if (mt.zoom() == zoom && mt.xy() == xy)
 115                                 return true;
 116                 }
 117         }
 118
 119         return false;
 120 }
 121
 122 void ENCMap::runJob(ENCMapJob *job)
 123 {
 124         _jobs.append(job);
 125
 126         connect(job, &ENCMapJob::finished, this, &ENCMap::jobFinished);
 127         job->run();
 128 }
 129
 130 void ENCMap::removeJob(ENCMapJob *job)
 131 {
 132         _jobs.removeOne(job);
 133         job->deleteLater();
 134 }
 135
 136 void ENCMap::jobFinished(ENCMapJob *job)
 137 {
 138         const QList<ENC::RasterTile> &tiles = job->tiles();
 139
 140         for (int i = 0; i < tiles.size(); i++) {
 141                 const ENC::RasterTile &mt = tiles.at(i);
 142                 if (mt.isValid())
 143                         QPixmapCache::insert(key(mt.zoom(), mt.xy()), mt.pixmap());
 144         }
 145
 146         removeJob(job);
 147
 148         emit tilesLoaded();
 149 }
 150
 151 void ENCMap::cancelJobs(bool wait)
 152 {
 153         for (int i = 0; i < _jobs.size(); i++)
 154                 _jobs.at(i)->cancel(wait);
 155 }
 156
 157 QString ENCMap::key(int zoom, const QPoint &xy) const
 158 {
 159         return path() + "-" + QString::number(zoom) + "_"
 160           + QString::number(xy.x()) + "_" + QString::number(xy.y());
 161 }
 162
 163 void ENCMap::draw(QPainter *painter, const QRectF &rect, Flags flags)
 164 {
 165         Q_UNUSED(flags);
 166         QPointF tl(floor(rect.left() / TILE_SIZE) * TILE_SIZE,
 167           floor(rect.top() / TILE_SIZE) * TILE_SIZE);
 168         QSizeF s(rect.right() - tl.x(), rect.bottom() - tl.y());
 169         int width = ceil(s.width() / TILE_SIZE);
 170         int height = ceil(s.height() / TILE_SIZE);
 171
 172         QList<RasterTile> tiles;
 173
 174         for (int i = 0; i < width; i++) {
 175                 for (int j = 0; j < height; j++) {
 176                         QPoint ttl(tl.x() + i * TILE_SIZE, tl.y() + j * TILE_SIZE);
 177                         if (isRunning(_zoom, ttl))
 178                                 continue;
 179
 180                         QPixmap pm;
 181                         if (QPixmapCache::find(key(_zoom, ttl), &pm))
 182                                 painter->drawPixmap(ttl, pm);
 183                         else {
 184                                 QList<MapData::Poly*> polygons;
 185                                 QList<MapData::Line*> lines;
 186                                 QList<MapData::Point*> points;
 187
 188                                 QRectF polyRect(ttl, QPointF(ttl.x() + TILE_SIZE,
 189                                   ttl.y() + TILE_SIZE));
 190                                 polyRect &= _bounds;
 191                                 RectD polyRectD(_transform.img2proj(polyRect.topLeft()),
 192                                   _transform.img2proj(polyRect.bottomRight()));
 193                                 RectC polyRectC(polyRectD.toRectC(_projection, 20));
 194                                 _data.lines(polyRectC, &lines);
 195                                 _data.polygons(polyRectC, &polygons);
 196
 197                                 QRectF pointRect(QPointF(ttl.x() - TEXT_EXTENT,
 198                                   ttl.y() - TEXT_EXTENT), QPointF(ttl.x() + TILE_SIZE
 199                                   + TEXT_EXTENT, ttl.y() + TILE_SIZE + TEXT_EXTENT));
 200                                 pointRect &= _bounds;
 201                                 RectD pointRectD(_transform.img2proj(pointRect.topLeft()),
 202                                   _transform.img2proj(pointRect.bottomRight()));
 203                                 _data.points(pointRectD.toRectC(_projection, 20), &points);
 204
 205                                 tiles.append(RasterTile(_projection, _transform, _data.zooms(),
 206                                   _zoom, QRect(ttl, QSize(TILE_SIZE, TILE_SIZE)), _tileRatio,
 207                                   lines, polygons, points));
 208                         }
 209                 }
 210         }
 211
 212         if (!tiles.isEmpty()) {
 213                 if (flags & Map::Block) {
 214                         QFuture<void> future = QtConcurrent::map(tiles, &RasterTile::render);
 215                         future.waitForFinished();
 216
 217                         for (int i = 0; i < tiles.size(); i++) {
 218                                 const RasterTile &mt = tiles.at(i);
 219                                 const QPixmap &pm = mt.pixmap();
 220                                 painter->drawPixmap(mt.xy(), pm);
 221                                 QPixmapCache::insert(key(mt.zoom(), mt.xy()), pm);
 222                         }
 223                 } else
 224                         runJob(new ENCMapJob(tiles));
 225         }
 226 }
 227
 228 Map *ENCMap::create(const QString &path, bool *isMap)
 229 {
 230         if (isMap)
 231                 *isMap = false;
 232
 233         return new ENCMap(path);
 234 }