QGeoTileSpec QGeoTileCache::filenameToTileSpec(const QString &filename)
{
QGeoTileSpec emptySpec;
QStringList parts = filename.split('.');
if (parts.length() != 2)
return emptySpec;
QString name = parts.at(0);
QStringList fields = name.split('-');
if (fields.length() != 5)
return emptySpec;
QList<int> numbers;
bool ok = false;
for (int i = 1; i < 5; ++i) {
ok = false;
int value = fields.at(i).toInt(&ok);
if (!ok)
return emptySpec;
numbers.append(value);
}
return QGeoTileSpec(fields.at(0),
numbers.at(0),
numbers.at(1),
numbers.at(2),
numbers.at(3));
}
void QGeoCameraTilesPrivate::updateMetadata()
{
typedef QSet<QGeoTileSpec>::const_iterator iter;
QSet<QGeoTileSpec> newTiles;
iter i = tiles_.constBegin();
iter end = tiles_.constEnd();
for (; i != end; ++i) {
QGeoTileSpec tile = *i;
newTiles.insert(QGeoTileSpec(pluginString_, mapType_.mapId(), tile.zoom(), tile.x(), tile.y(), mapVersion_));
}
tiles_ = newTiles;
}
QGeoTileSpec QGeoTileCache::filenameToTileSpec(const QString &filename)
{
QGeoTileSpec emptySpec;
QStringList parts = filename.split('.');
if (parts.length() != 2)
return emptySpec;
QString name = parts.at(0);
QStringList fields = name.split('-');
int length = fields.length();
if (length != 5 && length != 6)
return emptySpec;
QList<int> numbers;
bool ok = false;
for (int i = 1; i < length; ++i) {
ok = false;
int value = fields.at(i).toInt(&ok);
if (!ok)
return emptySpec;
numbers.append(value);
}
//File name without version, append default
if (numbers.length() < 5)
numbers.append(-1);
return QGeoTileSpec(fields.at(0),
numbers.at(0),
numbers.at(1),
numbers.at(2),
numbers.at(3),
numbers.at(4));
}
QSet<QGeoTileSpec> QGeoCameraTilesPrivate::tilesFromPolygon(const Polygon &polygon) const
{
int numPoints = polygon.size();
if (numPoints == 0)
return QSet<QGeoTileSpec>();
QVector<int> tilesX(polygon.size());
QVector<int> tilesY(polygon.size());
// grab tiles at the corners of the polygon
for (int i = 0; i < numPoints; ++i) {
QDoubleVector2D p = polygon.at(i).toVector2D();
int x = 0;
int y = 0;
if (qFuzzyCompare(p.x(), sideLength_ * 1.0))
x = sideLength_ - 1;
else {
x = static_cast<int>(p.x()) % sideLength_;
if ( !qFuzzyCompare(p.x(), 1.0 * x) && qFuzzyCompare(p.x(), 1.0 * (x + 1)) )
x++;
}
if (qFuzzyCompare(p.y(), sideLength_ * 1.0))
y = sideLength_ - 1;
else {
y = static_cast<int>(p.y()) % sideLength_;
if ( !qFuzzyCompare(p.y(), 1.0 * y) && qFuzzyCompare(p.y(), 1.0 * (y + 1)) )
y++;
}
tilesX[i] = x;
tilesY[i] = y;
}
QGeoCameraTilesPrivate::TileMap map;
// walk along the edges of the polygon and add all tiles covered by them
for (int i1 = 0; i1 < numPoints; ++i1) {
int i2 = (i1 + 1) % numPoints;
double x1 = polygon.at(i1).get(0);
double x2 = polygon.at(i2).get(0);
bool xFixed = qFuzzyCompare(x1, x2);
bool xIntegral = qFuzzyCompare(x1, std::floor(x1)) || qFuzzyCompare(x1 + 1.0, std::floor(x1 + 1.0));
QList<QPair<double, int> > xIntersects
= tileIntersections(x1,
tilesX.at(i1),
x2,
tilesX.at(i2));
double y1 = polygon.at(i1).get(1);
double y2 = polygon.at(i2).get(1);
bool yFixed = qFuzzyCompare(y1, y2);
bool yIntegral = qFuzzyCompare(y1, std::floor(y1)) || qFuzzyCompare(y1 + 1.0, std::floor(y1 + 1.0));
QList<QPair<double, int> > yIntersects
= tileIntersections(y1,
tilesY.at(i1),
y2,
tilesY.at(i2));
int x = xIntersects.takeFirst().second;
int y = yIntersects.takeFirst().second;
/*
If the polygon coincides with the tile edges we must be
inclusive and grab all tiles on both sides. We also need
to handle tiles with corners coindent with the
corners of the polygon.
e.g. all tiles marked with 'x' will be added
"+" - tile boundaries
"O" - polygon boundary
+ + + + + + + + + + + + + + + + + + + + +
+ + + + + +
+ + x + x + x + +
+ + + + + +
+ + + + + + + + O O O O O + + + + + + + +
+ + O 0 + +
+ + x O x 0 x + +
+ + O 0 + +
+ + + + + + + + O 0 0 0 0 + + + + + + + +
+ + + + + +
+ + x + x + x + +
+ + + + + +
+ + + + + + + + + + + + + + + + + + + + +
*/
int xOther = x;
int yOther = y;
if (xFixed && xIntegral) {
if (y2 < y1) {
xOther = qMax(0, x - 1);
}
}
if (yFixed && yIntegral) {
if (x1 < x2) {
yOther = qMax(0, y - 1);
}
}
if (xIntegral) {
map.add(xOther, y);
if (yIntegral)
map.add(xOther, yOther);
}
if (yIntegral)
map.add(x, yOther);
map.add(x,y);
// top left corner
int iPrev = (i1 + numPoints - 1) % numPoints;
double xPrevious = polygon.at(iPrev).get(0);
double yPrevious = polygon.at(iPrev).get(1);
bool xPreviousFixed = qFuzzyCompare(xPrevious, x1);
if (xIntegral && xPreviousFixed && yIntegral && yFixed) {
if ((x2 > x1) && (yPrevious > y1)) {
if ((x - 1) > 0 && (y - 1) > 0)
map.add(x - 1, y - 1);
} else if ((x2 < x1) && (yPrevious < y1)) {
// what?
}
}
// for the simple case where intersections do not coincide with
// the boundaries, we move along the edge and add tiles until
// the x and y intersection lists are exhausted
while (!xIntersects.isEmpty() && !yIntersects.isEmpty()) {
QPair<double, int> nextX = xIntersects.first();
QPair<double, int> nextY = yIntersects.first();
if (nextX.first < nextY.first) {
x = nextX.second;
map.add(x, y);
xIntersects.removeFirst();
} else if (nextX.first > nextY.first) {
y = nextY.second;
map.add(x, y);
yIntersects.removeFirst();
} else {
map.add(x, nextY.second);
map.add(nextX.second, y);
x = nextX.second;
y = nextY.second;
map.add(x, y);
xIntersects.removeFirst();
yIntersects.removeFirst();
}
}
while (!xIntersects.isEmpty()) {
x = xIntersects.takeFirst().second;
map.add(x, y);
if (yIntegral && yFixed)
map.add(x, yOther);
}
while (!yIntersects.isEmpty()) {
y = yIntersects.takeFirst().second;
map.add(x, y);
if (xIntegral && xFixed)
map.add(xOther, y);
}
}
QSet<QGeoTileSpec> results;
int z = intZoomLevel_;
typedef QMap<int, QPair<int, int> >::const_iterator iter;
iter i = map.data.constBegin();
iter end = map.data.constEnd();
for (; i != end; ++i) {
int y = i.key();
int minX = i->first;
int maxX = i->second;
for (int x = minX; x <= maxX; ++x) {
results.insert(QGeoTileSpec(pluginString_, mapType_.mapId(), z, x, y, mapVersion_));
}
}
return results;
}
