void tst_MapType::constructorTest()
{
QGeoMapType *testObjPtr = new QGeoMapType(QGeoMapType::StreetMap, QStringLiteral("street map"),
QStringLiteral("map description"), true, true, 1);
QVERIFY(testObjPtr);
QCOMPARE(testObjPtr->style(), QGeoMapType::StreetMap);
QCOMPARE(testObjPtr->name(), QStringLiteral("street map"));
QCOMPARE(testObjPtr->description(), QStringLiteral("map description"));
QVERIFY(testObjPtr->mobile());
QVERIFY(testObjPtr->night());
QCOMPARE(testObjPtr->mapId(), 1);
delete testObjPtr;
testObjPtr = new QGeoMapType();
QCOMPARE(testObjPtr->style(), QGeoMapType::NoMap);
QVERIFY2(testObjPtr->name().isEmpty(), "Wrong default value");
QVERIFY2(testObjPtr->description().isEmpty(), "Wrong default value");
QVERIFY2(!testObjPtr->mobile(), "Wrong default value");
QVERIFY2(!testObjPtr->night(), "Wrong default value");
QCOMPARE(testObjPtr->mapId(), 0);
delete testObjPtr;
}
void tst_MapType::constructorTest()
{
QGeoMapType *testObjPtr = new QGeoMapType(QGeoMapType::StreetMap, "street name", "street desc", false, 0);
QVERIFY(testObjPtr);
delete testObjPtr;
testObjPtr = new QGeoMapType();
QVERIFY2(testObjPtr->style() == QGeoMapType::NoMap, "Wrong default value");
QVERIFY2(testObjPtr->name() == "", "Wrong default value");
QVERIFY2(testObjPtr->description() == "", "Wrong default value");
QVERIFY2(testObjPtr->mobile() == false, "Wrong default value");
QVERIFY2(testObjPtr->mapId() == 0, "Wrong default value");
delete testObjPtr;
}
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;
}
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;
}
void tst_MapType::mapIdTest()
{
QGeoMapType testObj = QGeoMapType(QGeoMapType::StreetMap, "mobile street name", "mobile street desc", true, 42);
QVERIFY2(testObj.mapId() == 42, "Wrong value returned");
}