1	/****************************************************************************
2	**
3	** Copyright (C) 2016 The Qt Company Ltd.
4	** Contact: https://www.qt.io/licensing/
5	**
6	** This file is part of the test suite of the Qt Toolkit.
7	**
8	** $QT_BEGIN_LICENSE:GPL-EXCEPT$
9	** Commercial License Usage
10	** Licensees holding valid commercial Qt licenses may use this file in
11	** accordance with the commercial license agreement provided with the
12	** Software or, alternatively, in accordance with the terms contained in
13	** a written agreement between you and The Qt Company. For licensing terms
14	** and conditions see https://www.qt.io/terms-conditions. For further
15	** information use the contact form at https://www.qt.io/contact-us.
16	**
17	** GNU General Public License Usage
18	** Alternatively, this file may be used under the terms of the GNU
19	** General Public License version 3 as published by the Free Software
20	** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
21	** included in the packaging of this file. Please review the following
22	** information to ensure the GNU General Public License requirements will
23	** be met: https://www.gnu.org/licenses/gpl-3.0.html.
24	**
25	** $QT_END_LICENSE$
26	**
27	****************************************************************************/
28
29	//TESTED_COMPONENT=src/location/maps
30
31	#include <QtLocation/private/qgeotilespec_p.h>
32	#include <QtLocation/private/qgeocameratiles_p.h>
33	#include <QtLocation/private/qgeocameradata_p.h>
34	#include <QtLocation/private/qgeomaptype_p.h>
35
36	#include <QtPositioning/private/qwebmercator_p.h>
37	#include <QtPositioning/private/qdoublevector2d_p.h>
38	#include <QtTest/QtTest>
39	#include <QtCore/QList>
40	#include <QtCore/QPair>
41	#include <QtCore/qmath.h>
42
43	QT_USE_NAMESPACE
44
45	struct PositionTestInfo {
46	QString xyString;
47	QString zoomString;
48	QString wString;
49	QString hString;
50	double x;
51	double y;
52	double zoom;
53	double w;
54	double h;
55	};
56
57	class tst_QGeoCameraTiles : public QObject
58	{
59	Q_OBJECT
60
61	private:
62
63	void row(const PositionTestInfo &pti, int xOffset, int yOffset, int tileX, int tileY, int tileW, int tileH);
64	void test_group(const PositionTestInfo &pti, QList<int> &xVals, QList<int> &wVals, QList<int> &yVals, QList<int> &hVals);
65
66	private slots:
67
68	void tilesPlugin();
69	void tilesMapType();
70	void tilesPositions();
71	void tilesPositions_data();
72	void test_tilted_frustum();
73	};
74
75	void tst_QGeoCameraTiles::row(const PositionTestInfo &pti, int xOffset, int yOffset, int tileX, int tileY, int tileW, int tileH)
76	{
77	double step = 1 / (qPow(x: 2.0, y: 4.0) * 4);
78
79	QString row = pti.xyString;
80	row += QStringLiteral(" - ");
81	row += pti.zoomString;
82	row += QStringLiteral(" - (");
83	row += QString::number(xOffset);
84	row += QStringLiteral(",");
85	row += QString::number(yOffset);
86	row += QStringLiteral(") - ");
87	row += pti.wString;
88	row += QStringLiteral(" x ");
89	row += pti.hString;
90
91	QList<int> xRow;
92	QList<int> yRow;
93
94	for (int y = 0; y < tileH; ++y) {
95	for (int x = 0; x < tileW; ++x) {
96	if (tileX + x < 16)
97	xRow << tileX + x;
98	else
99	xRow << tileX + x - 16;
100	yRow << tileY + y;
101	}
102	}
103
104	QTest::newRow(qPrintable(row))
105	<< pti.x + step * xOffset << pti.y + step * yOffset
106	<< pti.zoom << pti.w << pti.h
107	<< xRow
108	<< yRow;
109	}
110
111	void tst_QGeoCameraTiles::test_group(const PositionTestInfo &pti, QList<int> &xVals, QList<int> &wVals, QList<int> &yVals, QList<int> &hVals)
112	{
113	for (int x = 0; x < 5; ++x) {
114	for (int y = 0; y < 5; ++y) {
115	row(pti, xOffset: x, yOffset: y, tileX: xVals.at(i: x), tileY: yVals.at(i: y), tileW: wVals.at(i: x), tileH: hVals.at(i: y));
116	}
117	}
118	}
119
120	void tst_QGeoCameraTiles::test_tilted_frustum()
121	{
122	// ctFull : Full map in the view, all 16 zl2 tiles visible. Using this as control.
123	QGeoCameraData cameraFull;
124	cameraFull.setZoomLevel(2);
125	cameraFull.setCenter(QGeoCoordinate(0,0));
126	QGeoCameraTiles ctFull;
127	ctFull.setTileSize(64);
128	ctFull.setCameraData(cameraFull);
129	ctFull.setScreenSize(QSize(256, 256));
130
131	QGeoCameraData camera;
132	camera.setZoomLevel(2.322);
133	camera.setTilt(30);
134	camera.setCenter(QWebMercator::mercatorToCoord(mercator: QDoubleVector2D(0.75, 0.5)));
135	QGeoCameraTiles ct;
136	ct.setTileSize(64);
137	ct.setScreenSize(QSize(320, 180));
138	ct.setCameraData(camera);
139
140	QCOMPARE(ct.createTiles(), ctFull.createTiles());
141	}
142
143	void tst_QGeoCameraTiles::tilesPlugin()
144	{
145	QGeoCameraData camera;
146	camera.setZoomLevel(4.0);
147	camera.setCenter(QGeoCoordinate(0.0, 0.0));
148
149	QGeoCameraTiles ct;
150	ct.setTileSize(16);
151	ct.setCameraData(camera);
152	ct.setScreenSize(QSize(32, 32));
153	ct.setMapType(QGeoMapType(QGeoMapType::StreetMap, "street map", "street map", false, false, 1, QByteArrayLiteral(""), QGeoCameraCapabilities()));
154
155	QSet<QGeoTileSpec> tiles1 = ct.createTiles();
156
157	ct.setPluginString("pluginA");
158
159	QSet<QGeoTileSpec> tiles2 = ct.createTiles();
160
161	typedef QSet<QGeoTileSpec>::const_iterator iter;
162	iter i1 = tiles1.constBegin();
163	iter end1 = tiles1.constEnd();
164
165	QSet<QGeoTileSpec> tiles2_check;
166
167	for (; i1 != end1; ++i1) {
168	QGeoTileSpec tile = *i1;
169	tiles2_check.insert(value: QGeoTileSpec("pluginA", tile.mapId(), tile.zoom(), tile.x(), tile.y()));
170	}
171
172	QCOMPARE(tiles2, tiles2_check);
173
174	ct.setPluginString("pluginB");
175
176	QSet<QGeoTileSpec> tiles3 = ct.createTiles();
177
178	iter i2 = tiles2.constBegin();
179	iter end2 = tiles2.constEnd();
180
181	QSet<QGeoTileSpec> tiles3_check;
182
183	for (; i2 != end2; ++i2) {
184	QGeoTileSpec tile = *i2;
185	tiles3_check.insert(value: QGeoTileSpec("pluginB", tile.mapId(), tile.zoom(), tile.x(), tile.y()));
186	}
187
188	QCOMPARE(tiles3, tiles3_check);
189	}
190
191	void tst_QGeoCameraTiles::tilesMapType()
192	{
193	QGeoCameraData camera;
194	camera.setZoomLevel(4.0);
195	camera.setCenter(QGeoCoordinate(0.0, 0.0));
196
197	QGeoCameraTiles ct;
198	ct.setTileSize(16);
199	ct.setCameraData(camera);
200	ct.setScreenSize(QSize(32, 32));
201	ct.setPluginString("pluginA");
202
203	QSet<QGeoTileSpec> tiles1 = ct.createTiles();
204
205	QGeoMapType mapType1 = QGeoMapType(QGeoMapType::StreetMap, "street map", "street map", false, false, 1, QByteArrayLiteral(""), QGeoCameraCapabilities());
206	ct.setMapType(mapType1);
207
208	QSet<QGeoTileSpec> tiles2 = ct.createTiles();
209
210	typedef QSet<QGeoTileSpec>::const_iterator iter;
211	iter i1 = tiles1.constBegin();
212	iter end1 = tiles1.constEnd();
213
214	QSet<QGeoTileSpec> tiles2_check;
215
216	for (; i1 != end1; ++i1) {
217	QGeoTileSpec tile = *i1;
218	tiles2_check.insert(value: QGeoTileSpec(tile.plugin(), mapType1.mapId(), tile.zoom(), tile.x(), tile.y()));
219	}
220
221	QCOMPARE(tiles2, tiles2_check);
222
223	QGeoMapType mapType2 = QGeoMapType(QGeoMapType::StreetMap, "satellite map", "satellite map", false, false, 2, QByteArrayLiteral(""), QGeoCameraCapabilities());
224	ct.setMapType(mapType2);
225
226	QSet<QGeoTileSpec> tiles3 = ct.createTiles();
227
228	iter i2 = tiles2.constBegin();
229	iter end2 = tiles2.constEnd();
230
231	QSet<QGeoTileSpec> tiles3_check;
232
233	for (; i2 != end2; ++i2) {
234	QGeoTileSpec tile = *i2;
235	tiles3_check.insert(value: QGeoTileSpec(tile.plugin(), mapType2.mapId(), tile.zoom(), tile.x(), tile.y()));
236	}
237
238	QCOMPARE(tiles3, tiles3_check);
239	}
240
241	void tst_QGeoCameraTiles::tilesPositions()
242	{
243	QFETCH(double, mercatorX);
244	QFETCH(double, mercatorY);
245	QFETCH(double, zoom);
246	QFETCH(double, width);
247	QFETCH(double, height);
248	QFETCH(QList<int> , tilesX);
249	QFETCH(QList<int> , tilesY);
250
251	QGeoCameraData camera;
252	camera.setZoomLevel(zoom);
253	camera.setCenter(QWebMercator::mercatorToCoord(mercator: QDoubleVector2D(mercatorX, mercatorY)));
254
255	QGeoCameraTiles ct;
256	ct.setTileSize(16);
257	ct.setCameraData(camera);
258	ct.setScreenSize(QSize(qCeil(v: width), qCeil(v: height)));
259
260	QSet<QGeoTileSpec> tiles;
261
262	QVERIFY2(tilesX.size() == tilesY.size(), "tilesX and tilesY have different size");
263
264	for (int i = 0; i < tilesX.size(); ++i)
265	tiles.insert(value: QGeoTileSpec("", 0, static_cast<int>(qFloor(v: zoom)), tilesX.at(i), tilesY.at(i)));
266
267	QCOMPARE(ct.createTiles(), tiles);
268	}
269
270	void tst_QGeoCameraTiles::tilesPositions_data()
271	{
272	QTest::addColumn<double>(name: "mercatorX");
273	QTest::addColumn<double>(name: "mercatorY");
274	QTest::addColumn<double>(name: "zoom");
275	QTest::addColumn<double>(name: "width");
276	QTest::addColumn<double>(name: "height");
277	QTest::addColumn<QList<int> >(name: "tilesX");
278	QTest::addColumn<QList<int> >(name: "tilesY");
279
280	int t = 16;
281
282	PositionTestInfo pti;
283
284	/*
285	This test sets up various viewports onto a 16x16 map,
286	and checks which tiles are visible against those that
287	are expected to be visible.
288
289	The tests are run in 5 groups, corresponding to where
290	the viewport is centered on the map.
291
292	The groups are named as follows, with the tile in
293	which the viewport is centered listed in parenthesis:
294	- mid (8, 8)
295	- top (8, 0)
296	- bottom (8, 15)
297	- left (0, 8)
298	- right (15, 8)
299
300	For each of these groups a number of tests are run,
301	which involve modifying various parameters.
302
303	If "t" is the width of a tile, the width and height
304	of the viewport take on values including:
305	- (t - 1)
306	- t
307	- (t + 1)
308	- (2t - 1)
309	- 2t
310	- (2t + 1)
311
312	The viewport is also offset by fractions of a tile
313	in both the x and y directions. The offsets are in
314	quarters of a tile.
315
316	The diagrams below present a justification for our
317	test expectations.
318
319	The diagrams show variations in viewport width and
320	x offset into the target tile , although can easily
321	be taken to be the variations in viewport height and
322	y offset into the target tile.
323
324	The symbols have the following meanings:
325	"+" - tile boundaries
326	"*" - viewport boundary
327	"T" - boundary of tile the viewport is centered on
328	"O" - same as "T" but coincident with the viewport boundary
329
330	Whenever the viewport boundary is coincident with a tile boundary,
331	the tiles on both sides of the boundary are expected to be fetched.
332
333	Those tiles are needed in case we perform bilinear antialiasing,
334	provide us with at least a pixel width of tolerance for errors in
335	other parts of the code or the system. There is a decent chance
336	that some or all of those extra tiles will need to be fetched before
337	long, so getting them into the cache sooner rather than later is
338	likely to be beneficial on average.
339
340	The tests are carried out per viewport height / width.
341
342	Lists are created of the first tile along an axis that is expected to
343	be in the viewport and for the number of tiles along an axis that
344	are expected to be in the viewport.
345
346	These lists are used for both the x and y axes, although alternative
347	lists are created for the x axis when the viewport spans the dateline
348	and for the y axis when the viewport is clipped by the top or bottom of
349	the map.
350
351	These 5 areas are checked at an integral zoom level to see that the
352	expected visible tiles match the actual visible tiles generated by
353	the code under test.
354
355	After that a fractional zoom level is set and the width and height of
356	the viewport are scaled such that the same tiles should be visible,
357	and the tests are repeated.
358	*/
359
360	// TODO
361	// nail down semantics, modify tests and code to suite
362	// add corners of the map
363
364	/*
365	width = t - 1
366	*/
367
368	QList<int> mid_tm1x;
369	QList<int> mid_tm1w;
370	QList<int> top_tm1x;
371	QList<int> top_tm1w;
372	QList<int> bottom_tm1x;
373	QList<int> bottom_tm1w;
374	QList<int> left_tm1x;
375	QList<int> left_tm1w;
376	QList<int> right_tm1x;
377	QList<int> right_tm1w;
378
379	pti.w = t - 1;
380	pti.h = t - 1;
381	pti.wString = QStringLiteral("(1T - 1)");
382	pti.hString = QStringLiteral("(1T - 1)");
383
384	/*
385
386	offset = 0
387	+ + + + + + + + + + + + + + + + + + + + +
388	+ + + + + +
389	+ + * *+* * + + +
390	+ + * + * + + +
391	+ + + + + + +*+ T T*T T T + + + + + + + +
392	+ + * T * T + +
393	+ + * *T* * T + +
394	+ + T T + +
395	+ + + + + + + + T T T T T + + + + + + + +
396
397	Starts at: T - 1
398	Covers: 2 tiles
399	*/
400
401	mid_tm1x << 7;
402	mid_tm1w << 2;
403
404	top_tm1x << 0;
405	top_tm1w << 1;
406
407	bottom_tm1x << 14;
408	bottom_tm1w << 2;
409
410	left_tm1x << 15;
411	left_tm1w << 2;
412
413	right_tm1x << 14;
414	right_tm1w << 2;
415
416	/*
417	offset = 1
418	+ + + + + + + + + + + + + + + + + + + + +
419	+ + + + + +
420	+ + *+* * * + + +
421	+ + *+ * + + +
422	+ + + + + + + +*T T T*T T + + + + + + + +
423	+ + *T * T + +
424	+ + *T* * * T + +
425	+ + T T + +
426	+ + + + + + + + T T T T T + + + + + + + +
427
428	Starts at: T - 1
429	Covers: 2 tiles
430	*/
431
432	mid_tm1x << 7;
433	mid_tm1w << 2;
434
435	top_tm1x << 0;
436	top_tm1w << 1;
437
438	bottom_tm1x << 14;
439	bottom_tm1w << 2;
440
441	left_tm1x << 15;
442	left_tm1w << 2;
443
444	right_tm1x << 14;
445	right_tm1w << 2;
446
447	/*
448	offset = 2
449	+ + + + + + + + + + + + + + + + + + + + +
450	+ + + + + +
451	+ + +* * * *+ + +
452	+ + +* *+ + +
453	+ + + + + + + + T*T T T*T + + + + + + + +
454	+ + T* *T + +
455	+ + T* * * *T + +
456	+ + T T + +
457	+ + + + + + + + T T T T T + + + + + + + +
458
459	Starts at: T
460	Covers: 1 tile
461	*/
462
463	mid_tm1x << 8;
464	mid_tm1w << 1;
465
466	top_tm1x << 0;
467	top_tm1w << 1;
468
469	bottom_tm1x << 15;
470	bottom_tm1w << 1;
471
472	left_tm1x << 0;
473	left_tm1w << 1;
474
475	right_tm1x << 15;
476	right_tm1w << 1;
477
478	/*
479	offset = 3
480	+ + + + + + + + + + + + + + + + + + + + +
481	+ + + + + +
482	+ + + * * *+* + +
483	+ + + * +* + +
484	+ + + + + + + + T T*T T T*+ + + + + + + +
485	+ + T * T* + +
486	+ + T * * *T* + +
487	+ + T T + +
488	+ + + + + + + + T T T T T + + + + + + + +
489
490	Starts at: T
491	Covers: 2 tiles
492	*/
493
494	mid_tm1x << 8;
495	mid_tm1w << 2;
496
497	top_tm1x << 0;
498	top_tm1w << 2;
499
500	bottom_tm1x << 15;
501	bottom_tm1w << 1;
502
503	left_tm1x << 0;
504	left_tm1w << 2;
505
506	right_tm1x << 15;
507	right_tm1w << 2;
508
509	/*
510	offset = 4
511	+ + + + + + + + + + + + + + + + + + + + +
512	+ + + + + +
513	+ + + * *+* * + +
514	+ + + * + * + +
515	+ + + + + + + + T T T*T T +*+ + + + + + +
516	+ + T * T * + +
517	+ + T * *T* * + +
518	+ + T T + +
519	+ + + + + + + + T T T T T + + + + + + + +
520
521	Starts at: T
522	Covers: 2 tiles
523	*/
524
525	mid_tm1x << 8;
526	mid_tm1w << 2;
527
528	top_tm1x << 0;
529	top_tm1w << 2;
530
531	bottom_tm1x << 15;
532	bottom_tm1w << 1;
533
534	left_tm1x << 0;
535	left_tm1w << 2;
536
537	right_tm1x << 15;
538	right_tm1w << 2;
539
540	pti.zoom = 4.0;
541	pti.zoomString = QStringLiteral("int zoom");
542
543	pti.x = 0.5;
544	pti.y = 0.5;
545	pti.xyString = QStringLiteral("middle");
546
547	test_group(pti, xVals&: mid_tm1x, wVals&: mid_tm1w, yVals&: mid_tm1x, hVals&: mid_tm1w);
548
549	pti.x = 0.5;
550	pti.y = 0.0;
551	pti.xyString = QStringLiteral("top");
552
553	test_group(pti, xVals&: mid_tm1x, wVals&: mid_tm1w, yVals&: top_tm1x, hVals&: top_tm1w);
554
555	pti.x = 0.5;
556	pti.y = 15.0 / 16.0;
557	pti.xyString = QStringLiteral("bottom");
558
559	test_group(pti, xVals&: mid_tm1x, wVals&: mid_tm1w, yVals&: bottom_tm1x, hVals&: bottom_tm1w);
560
561	pti.x = 0.0;
562	pti.y = 0.5;
563	pti.xyString = QStringLiteral("left");
564
565	test_group(pti, xVals&: left_tm1x, wVals&: left_tm1w, yVals&: mid_tm1x, hVals&: mid_tm1w);
566
567	pti.x = 15.0 / 16.0;
568	pti.y = 0.5;
569	pti.xyString = QStringLiteral("right");
570
571	test_group(pti, xVals&: right_tm1x, wVals&: right_tm1w, yVals&: mid_tm1x, hVals&: mid_tm1w);
572
573	pti.zoom = 4.5;
574	pti.zoomString = QStringLiteral("frac zoom");
575	pti.w = pti.w * qPow(x: 2.0, y: 0.5);
576	pti.h = pti.h * qPow(x: 2.0, y: 0.5);
577
578	pti.x = 0.5;
579	pti.y = 0.5;
580	pti.xyString = QStringLiteral("middle");
581
582	test_group(pti, xVals&: mid_tm1x, wVals&: mid_tm1w, yVals&: mid_tm1x, hVals&: mid_tm1w);
583
584	pti.x = 0.5;
585	pti.y = 0.0;
586	pti.xyString = QStringLiteral("top");
587
588	test_group(pti, xVals&: mid_tm1x, wVals&: mid_tm1w, yVals&: top_tm1x, hVals&: top_tm1w);
589
590	pti.x = 0.5;
591	pti.y = 15.0 / 16.0;
592	pti.xyString = QStringLiteral("bottom");
593
594	test_group(pti, xVals&: mid_tm1x, wVals&: mid_tm1w, yVals&: bottom_tm1x, hVals&: bottom_tm1w);
595
596	pti.x = 0.0;
597	pti.y = 0.5;
598	pti.xyString = QStringLiteral("left");
599
600	test_group(pti, xVals&: left_tm1x, wVals&: left_tm1w, yVals&: mid_tm1x, hVals&: mid_tm1w);
601
602	pti.x = 15.0 / 16.0;
603	pti.y = 0.5;
604	pti.xyString = QStringLiteral("right");
605
606	test_group(pti, xVals&: right_tm1x, wVals&: right_tm1w, yVals&: mid_tm1x, hVals&: mid_tm1w);
607
608	/*
609	width = t
610	*/
611
612	QList<int> mid_tx;
613	QList<int> mid_tw;
614	QList<int> top_tx;
615	QList<int> top_tw;
616	QList<int> bottom_tx;
617	QList<int> bottom_tw;
618	QList<int> left_tx;
619	QList<int> left_tw;
620	QList<int> right_tx;
621	QList<int> right_tw;
622
623	pti.w = t;
624	pti.h = t;
625	pti.wString = QStringLiteral("1T");
626	pti.hString = QStringLiteral("1T");
627
628	/*
629
630	offset = 0
631	+ + + + + + + + + + + + + + + + + + + + +
632	+ + + + + +
633	+ + * * * * * + + +
634	+ + * + * + + +
635	+ + + + + + * + T T O T T + + + + + + + +
636	+ + * T * T + +
637	+ + * * O * * T + +
638	+ + T T + +
639	+ + + + + + + + T T T T T + + + + + + + +
640
641	Starts at: T - 1
642	Covers: 2 tiles
643	*/
644
645	mid_tx << 7;
646	mid_tw << 2;
647
648	top_tx << 0;
649	top_tw << 1;
650
651	bottom_tx << 14;
652	bottom_tw << 2;
653
654	left_tx << 15;
655	left_tw << 2;
656
657	right_tx << 14;
658	right_tw << 2;
659
660	/*
661	offset = 1
662	+ + + + + + + + + + + + + + + + + + + + +
663	+ + + + + +
664	+ + * * * * * + + +
665	+ + * + * + + +
666	+ + + + + + + * T T T O T + + + + + + + +
667	+ + * T * T + +
668	+ + * O * * * T + +
669	+ + T T + +
670	+ + + + + + + + T T T T T + + + + + + + +
671
672	Starts at: T - 1
673	Covers: 2 tiles
674	*/
675
676	mid_tx << 7;
677	mid_tw << 2;
678
679	top_tx << 0;
680	top_tw << 1;
681
682	bottom_tx << 14;
683	bottom_tw << 2;
684
685	left_tx << 15;
686	left_tw << 2;
687
688	right_tx << 14;
689	right_tw << 2;
690
691	/*
692	offset = 2
693	+ + + + + + + + + + + + + + + + + + + + +
694	+ + + + + +
695	+ + * * * * * + +
696	+ + * * + +
697	+ + + + + + + + O T T T O + + + + + + + +
698	+ + O O + +
699	+ + O * * * O + +
700	+ + T T + +
701	+ + + + + + + + T T T T T + + + + + + + +
702
703	Starts at: T - 1
704	Covers: 3 tiles
705	*/
706
707	mid_tx << 7;
708	mid_tw << 3;
709
710	top_tx << 0;
711	top_tw << 2;
712
713	bottom_tx << 14;
714	bottom_tw << 2;
715
716	left_tx << 15;
717	left_tw << 3;
718
719	right_tx << 14;
720	right_tw << 3;
721
722	/*
723	offset = 3
724	+ + + + + + + + + + + + + + + + + + + + +
725	+ + + + + +
726	+ + + * * * * * + +
727	+ + + * * + +
728	+ + + + + + + + T O T T T * + + + + + + +
729	+ + T * T * + +
730	+ + T * * * O * + +
731	+ + T T + +
732	+ + + + + + + + T T T T T + + + + + + + +
733
734	Starts at: T
735	Covers: 2 tiles
736	*/
737
738	mid_tx << 8;
739	mid_tw << 2;
740
741	top_tx << 0;
742	top_tw << 2;
743
744	bottom_tx << 15;
745	bottom_tw << 1;
746
747	left_tx << 0;
748	left_tw << 2;
749
750	right_tx << 15;
751	right_tw << 2;
752
753	/*
754	offset = 4
755	+ + + + + + + + + + + + + + + + + + + + +
756	+ + + + + +
757	+ + + * * * * * + +
758	+ + + * + * + +
759	+ + + + + + + + T T O T T + * + + + + + +
760	+ + T * T * + +
761	+ + T * * O * * + +
762	+ + T T + +
763	+ + + + + + + + T T T T T + + + + + + + +
764
765	Starts at: T
766	Covers: 2 tiles
767	*/
768
769	mid_tx << 8;
770	mid_tw << 2;
771
772	top_tx << 0;
773	top_tw << 2;
774
775	bottom_tx << 15;
776	bottom_tw << 1;
777
778	left_tx << 0;
779	left_tw << 2;
780
781	right_tx << 15;
782	right_tw << 2;
783
784	pti.zoom = 4.0;
785	pti.zoomString = QStringLiteral("int zoom");
786
787	pti.x = 0.5;
788	pti.y = 0.5;
789	pti.xyString = QStringLiteral("middle");
790
791	test_group(pti, xVals&: mid_tx, wVals&: mid_tw, yVals&: mid_tx, hVals&: mid_tw);
792
793	pti.x = 0.5;
794	pti.y = 0.0;
795	pti.xyString = QStringLiteral("top");
796
797	test_group(pti, xVals&: mid_tx, wVals&: mid_tw, yVals&: top_tx, hVals&: top_tw);
798
799	pti.x = 0.5;
800	pti.y = 15.0 / 16.0;
801	pti.xyString = QStringLiteral("bottom");
802
803	test_group(pti, xVals&: mid_tx, wVals&: mid_tw, yVals&: bottom_tx, hVals&: bottom_tw);
804
805	pti.x = 0.0;
806	pti.y = 0.5;
807	pti.xyString = QStringLiteral("left");
808
809	test_group(pti, xVals&: left_tx, wVals&: left_tw, yVals&: mid_tx, hVals&: mid_tw);
810
811	pti.x = 15.0 / 16.0;
812	pti.y = 0.5;
813	pti.xyString = QStringLiteral("right");
814
815	test_group(pti, xVals&: right_tx, wVals&: right_tw, yVals&: mid_tx, hVals&: mid_tw);
816
817	pti.zoom = 4.5;
818	pti.zoomString = QStringLiteral("frac zoom");
819	pti.w = pti.w * qPow(x: 2.0, y: 0.5);
820	pti.h = pti.h * qPow(x: 2.0, y: 0.5);
821
822	pti.x = 0.5;
823	pti.y = 0.5;
824	pti.xyString = QStringLiteral("middle");
825
826	test_group(pti, xVals&: mid_tx, wVals&: mid_tw, yVals&: mid_tx, hVals&: mid_tw);
827
828	pti.x = 0.5;
829	pti.y = 0.0;
830	pti.xyString = QStringLiteral("top");
831
832	test_group(pti, xVals&: mid_tx, wVals&: mid_tw, yVals&: top_tx, hVals&: top_tw);
833
834	pti.x = 0.5;
835	pti.y = 15.0 / 16.0;
836	pti.xyString = QStringLiteral("bottom");
837
838	test_group(pti, xVals&: mid_tx, wVals&: mid_tw, yVals&: bottom_tx, hVals&: bottom_tw);
839
840	pti.x = 0.0;
841	pti.y = 0.5;
842	pti.xyString = QStringLiteral("left");
843
844	test_group(pti, xVals&: left_tx, wVals&: left_tw, yVals&: mid_tx, hVals&: mid_tw);
845
846	pti.x = 15.0 / 16.0;
847	pti.y = 0.5;
848	pti.xyString = QStringLiteral("right");
849
850	test_group(pti, xVals&: right_tx, wVals&: right_tw, yVals&: mid_tx, hVals&: mid_tw);
851
852	/*
853	width = t + 1
854	*/
855
856	QList<int> mid_tp1x;
857	QList<int> mid_tp1w;
858	QList<int> top_tp1x;
859	QList<int> top_tp1w;
860	QList<int> bottom_tp1x;
861	QList<int> bottom_tp1w;
862	QList<int> left_tp1x;
863	QList<int> left_tp1w;
864	QList<int> right_tp1x;
865	QList<int> right_tp1w;
866
867	pti.w = t + 1;
868	pti.h = t + 1;
869	pti.wString = QStringLiteral("(1T + 1)");
870	pti.hString = QStringLiteral("(1T + 1)");
871
872	/*
873
874	offset = 0
875	+ + + + + + + + + + + + + + + + + + + + +
876	+ + + + + +
877	+ + * * *+* * * + + +
878	+ + * + * + + +
879	+ + + + + +*+ + T T T*T T + + + + + + + +
880	+ + * T * T + +
881	+ + * * *T* * * T + +
882	+ + T T + +
883	+ + + + + + + + T T T T T + + + + + + + +
884
885	Starts at: T - 1
886	Covers: 2 tiles
887	*/
888
889	mid_tp1x << 7;
890	mid_tp1w << 2;
891
892	top_tp1x << 0;
893	top_tp1w << 1;
894
895	bottom_tp1x << 14;
896	bottom_tp1w << 2;
897
898	left_tp1x << 15;
899	left_tp1w << 2;
900
901	right_tp1x << 14;
902	right_tp1w << 2;
903
904	/*
905	offset = 1
906	+ + + + + + + + + + + + + + + + + + + + +
907	+ + + + + +
908	+ + * *+* * * *+ + +
909	+ + * + *+ + +
910	+ + + + + + +*+ T T T T*T + + + + + + + +
911	+ + * T *T + +
912	+ + * *T* * * *T + +
913	+ + T T + +
914	+ + + + + + + + T T T T T + + + + + + + +
915
916	Starts at: T - 1
917	Covers: 2 tiles
918	*/
919
920	mid_tp1x << 7;
921	mid_tp1w << 2;
922
923	top_tp1x << 0;
924	top_tp1w << 1;
925
926	bottom_tp1x << 14;
927	bottom_tp1w << 2;
928
929	left_tp1x << 15;
930	left_tp1w << 2;
931
932	right_tp1x << 14;
933	right_tp1w << 2;
934
935	/*
936	offset = 2
937	+ + + + + + + + + + + + + + + + + + + + +
938	+ + + + + +
939	+ + *+* * * *+* + +
940	+ + *+ +* + +
941	+ + + + + + + +*T T T T T*+ + + + + + + +
942	+ + *T T* + +
943	+ + *T* * * *T* + +
944	+ + T T + +
945	+ + + + + + + + T T T T T + + + + + + + +
946
947	Starts at: T - 1
948	Covers: 3 tiles
949	*/
950
951	mid_tp1x << 7;
952	mid_tp1w << 3;
953
954	top_tp1x << 0;
955	top_tp1w << 2;
956
957	bottom_tp1x << 14;
958	bottom_tp1w << 2;
959
960	left_tp1x << 15;
961	left_tp1w << 3;
962
963	right_tp1x << 14;
964	right_tp1w << 3;
965
966	/*
967	offset = 3
968	+ + + + + + + + + + + + + + + + + + + + +
969	+ + + + + +
970	+ + +* * * *+* * + +
971	+ + +* + * + +
972	+ + + + + + + + T*T T T T +*+ + + + + + +
973	+ + T* T * + +
974	+ + T* * * *T* * + +
975	+ + T T + +
976	+ + + + + + + + T T T T T + + + + + + + +
977
978	Starts at: T
979	Covers: 2 tiles
980	*/
981
982	mid_tp1x << 8;
983	mid_tp1w << 2;
984
985	top_tp1x << 0;
986	top_tp1w << 2;
987
988	bottom_tp1x << 15;
989	bottom_tp1w << 1;
990
991	left_tp1x << 0;
992	left_tp1w << 2;
993
994	right_tp1x << 15;
995	right_tp1w << 2;
996
997	/*
998	offset = 4
999	+ + + + + + + + + + + + + + + + + + + + +
1000	+ + + + + +
1001	+ + + * * *+* * * + +
1002	+ + + * + * + +
1003	+ + + + + + + + T T*T T T + +*+ + + + + +
1004	+ + T * T * + +
1005	+ + T * * *T* * * + +
1006	+ + T T + +
1007	+ + + + + + + + T T T T T + + + + + + + +
1008
1009	Starts at: T
1010	Covers: 2 tiles
1011	*/
1012
1013	mid_tp1x << 8;
1014	mid_tp1w << 2;
1015
1016	top_tp1x << 0;
1017	top_tp1w << 2;
1018
1019	bottom_tp1x << 15;
1020	bottom_tp1w << 1;
1021
1022	left_tp1x << 0;
1023	left_tp1w << 2;
1024
1025	right_tp1x << 15;
1026	right_tp1w << 2;
1027
1028	pti.zoom = 4.0;
1029	pti.zoomString = QStringLiteral("int zoom");
1030
1031	pti.x = 0.5;
1032	pti.y = 0.5;
1033	pti.xyString = QStringLiteral("middle");
1034
1035	test_group(pti, xVals&: mid_tp1x, wVals&: mid_tp1w, yVals&: mid_tp1x, hVals&: mid_tp1w);
1036
1037	pti.x = 0.5;
1038	pti.y = 0.0;
1039	pti.xyString = QStringLiteral("top");
1040
1041	test_group(pti, xVals&: mid_tp1x, wVals&: mid_tp1w, yVals&: top_tp1x, hVals&: top_tp1w);
1042
1043	pti.x = 0.5;
1044	pti.y = 15.0 / 16.0;
1045	pti.xyString = QStringLiteral("bottom");
1046
1047	test_group(pti, xVals&: mid_tp1x, wVals&: mid_tp1w, yVals&: bottom_tp1x, hVals&: bottom_tp1w);
1048
1049	pti.x = 0.0;
1050	pti.y = 0.5;
1051	pti.xyString = QStringLiteral("left");
1052
1053	test_group(pti, xVals&: left_tp1x, wVals&: left_tp1w, yVals&: mid_tp1x, hVals&: mid_tp1w);
1054
1055	pti.x = 15.0 / 16.0;
1056	pti.y = 0.5;
1057	pti.xyString = QStringLiteral("right");
1058
1059	test_group(pti, xVals&: right_tp1x, wVals&: right_tp1w, yVals&: mid_tp1x, hVals&: mid_tp1w);
1060
1061	pti.zoom = 4.5;
1062	pti.zoomString = QStringLiteral("frac zoom");
1063	pti.w = pti.w * qPow(x: 2.0, y: 0.5);
1064	pti.h = pti.h * qPow(x: 2.0, y: 0.5);
1065
1066	pti.x = 0.5;
1067	pti.y = 0.5;
1068	pti.xyString = QStringLiteral("middle");
1069
1070	test_group(pti, xVals&: mid_tp1x, wVals&: mid_tp1w, yVals&: mid_tp1x, hVals&: mid_tp1w);
1071
1072	pti.x = 0.5;
1073	pti.y = 0.0;
1074	pti.xyString = QStringLiteral("top");
1075
1076	test_group(pti, xVals&: mid_tp1x, wVals&: mid_tp1w, yVals&: top_tp1x, hVals&: top_tp1w);
1077
1078	pti.x = 0.5;
1079	pti.y = 15.0 / 16.0;
1080	pti.xyString = QStringLiteral("bottom");
1081
1082	test_group(pti, xVals&: mid_tp1x, wVals&: mid_tp1w, yVals&: bottom_tp1x, hVals&: bottom_tp1w);
1083
1084	pti.x = 0.0;
1085	pti.y = 0.5;
1086	pti.xyString = QStringLiteral("left");
1087
1088	test_group(pti, xVals&: left_tp1x, wVals&: left_tp1w, yVals&: mid_tp1x, hVals&: mid_tp1w);
1089
1090	pti.x = 15.0 / 16.0;
1091	pti.y = 0.5;
1092	pti.xyString = QStringLiteral("right");
1093
1094	test_group(pti, xVals&: right_tp1x, wVals&: right_tp1w, yVals&: mid_tp1x, hVals&: mid_tp1w);
1095
1096	/*
1097	width = 2t - 1
1098	*/
1099
1100	QList<int> mid_t2m1x;
1101	QList<int> mid_t2m1w;
1102	QList<int> top_t2m1x;
1103	QList<int> top_t2m1w;
1104	QList<int> bottom_t2m1x;
1105	QList<int> bottom_t2m1w;
1106	QList<int> left_t2m1x;
1107	QList<int> left_t2m1w;
1108	QList<int> right_t2m1x;
1109	QList<int> right_t2m1w;
1110
1111	pti.w = 2 * t - 1;
1112	pti.h = 2 * t - 1;
1113	pti.wString = QStringLiteral("(2T - 1)");
1114	pti.hString = QStringLiteral("(2T - 1)");
1115
1116	/*
1117	offset = 0
1118	+ + + + + + + + + + + + + + + + + + + + +
1119	+ + + + + +
1120	+ +* * * *+* * * *+ + +
1121	+ +* + *+ + +
1122	+ + + + +*+ + + T T T T*T + + + + + + + +
1123	+ +* T *T + +
1124	+ +* * * *T* * * *T + +
1125	+ + T T + +
1126	+ + + + + + + + T T T T T + + + + + + + +
1127
1128	Starts at: T - 1
1129	Covers: 2 tiles
1130	*/
1131
1132	mid_t2m1x << 7;
1133	mid_t2m1w << 2;
1134
1135	top_t2m1x << 0;
1136	top_t2m1w << 1;
1137
1138	bottom_t2m1x << 14;
1139	bottom_t2m1w << 2;
1140
1141	left_t2m1x << 15;
1142	left_t2m1w << 2;
1143
1144	right_t2m1x << 14;
1145	right_t2m1w << 2;
1146
1147	/*
1148	offset = 1
1149	+ + + + + + + + + + + + + + + + + + + + +
1150	+ + + + + +
1151	+ + * * *+* * * *+* + +
1152	+ + * + +* + +
1153	+ + + + + +*+ + T T T T T*+ + + + + + + +
1154	+ + * T T* + +
1155	+ + * * *T* * * *T* + +
1156	+ + T T + +
1157	+ + + + + + + + T T T T T + + + + + + + +
1158
1159	Starts at: T - 1
1160	Covers: 3 tiles
1161	*/
1162
1163	mid_t2m1x << 7;
1164	mid_t2m1w << 3;
1165
1166	top_t2m1x << 0;
1167	top_t2m1w << 2;
1168
1169	bottom_t2m1x << 14;
1170	bottom_t2m1w << 2;
1171
1172	left_t2m1x << 15;
1173	left_t2m1w << 3;
1174
1175	right_t2m1x << 14;
1176	right_t2m1w << 3;
1177
1178	/*
1179	offset = 2
1180	+ + + + + + + + + + + + + + + + + + + + +
1181	+ + + + + +
1182	+ + * *+* * * *+* * + +
1183	+ + * + + * + +
1184	+ + + + + + +*+ T T T T T +*+ + + + + + +
1185	+ + * T T * + +
1186	+ + * *T* * * *T* * + +
1187	+ + T T + +
1188	+ + + + + + + + T T T T T + + + + + + + +
1189
1190	Starts at: T - 1
1191	Covers: 3 tiles
1192	*/
1193
1194	mid_t2m1x << 7;
1195	mid_t2m1w << 3;
1196
1197	top_t2m1x << 0;
1198	top_t2m1w << 2;
1199
1200	bottom_t2m1x << 14;
1201	bottom_t2m1w << 2;
1202
1203	left_t2m1x << 15;
1204	left_t2m1w << 3;
1205
1206	right_t2m1x << 14;
1207	right_t2m1w << 3;
1208
1209	/*
1210	offset = 3
1211	+ + + + + + + + + + + + + + + + + + + + +
1212	+ + + + + +
1213	+ + *+* * * *+* * * + +
1214	+ + *+ + * + +
1215	+ + + + + + + +*T T T T T + +*+ + + + + +
1216	+ + *T T * + +
1217	+ + *T* * * *T* * * + +
1218	+ + T T + +
1219	+ + + + + + + + T T T T T + + + + + + + +
1220
1221	Starts at: T - 1
1222	Covers: 3 tiles
1223	*/
1224
1225	mid_t2m1x << 7;
1226	mid_t2m1w << 3;
1227
1228	top_t2m1x << 0;
1229	top_t2m1w << 2;
1230
1231	bottom_t2m1x << 14;
1232	bottom_t2m1w << 2;
1233
1234	left_t2m1x << 15;
1235	left_t2m1w << 3;
1236
1237	right_t2m1x << 14;
1238	right_t2m1w << 3;
1239
1240	/*
1241	offset = 4
1242	+ + + + + + + + + + + + + + + + + + + + +
1243	+ + + + + +
1244	+ + +* * * *+* * * *+ +
1245	+ + +* + *+ +
1246	+ + + + + + + + T*T T T T + + +*+ + + + +
1247	+ + T* T *+ +
1248	+ + T* * * *T* * * *+ +
1249	+ + T T + +
1250	+ + + + + + + + T T T T T + + + + + + + +
1251
1252	Starts at: T
1253	Covers: 2 tiles
1254	*/
1255
1256	mid_t2m1x << 8;
1257	mid_t2m1w << 2;
1258
1259	top_t2m1x << 0;
1260	top_t2m1w << 2;
1261
1262	bottom_t2m1x << 15;
1263	bottom_t2m1w << 1;
1264
1265	left_t2m1x << 0;
1266	left_t2m1w << 2;
1267
1268	right_t2m1x << 15;
1269	right_t2m1w << 2;
1270
1271	pti.zoom = 4.0;
1272	pti.zoomString = QStringLiteral("int zoom");
1273
1274	pti.x = 0.5;
1275	pti.y = 0.5;
1276	pti.xyString = QStringLiteral("middle");
1277
1278	test_group(pti, xVals&: mid_t2m1x, wVals&: mid_t2m1w, yVals&: mid_t2m1x, hVals&: mid_t2m1w);
1279
1280	pti.x = 0.5;
1281	pti.y = 0.0;
1282	pti.xyString = QStringLiteral("top");
1283
1284	test_group(pti, xVals&: mid_t2m1x, wVals&: mid_t2m1w, yVals&: top_t2m1x, hVals&: top_t2m1w);
1285
1286	pti.x = 0.5;
1287	pti.y = 15.0 / 16.0;
1288	pti.xyString = QStringLiteral("bottom");
1289
1290	test_group(pti, xVals&: mid_t2m1x, wVals&: mid_t2m1w, yVals&: bottom_t2m1x, hVals&: bottom_t2m1w);
1291
1292	pti.x = 0.0;
1293	pti.y = 0.5;
1294	pti.xyString = QStringLiteral("left");
1295
1296	test_group(pti, xVals&: left_t2m1x, wVals&: left_t2m1w, yVals&: mid_t2m1x, hVals&: mid_t2m1w);
1297
1298	pti.x = 15.0 / 16.0;
1299	pti.y = 0.5;
1300	pti.xyString = QStringLiteral("right");
1301
1302	test_group(pti, xVals&: right_t2m1x, wVals&: right_t2m1w, yVals&: mid_t2m1x, hVals&: mid_t2m1w);
1303
1304	pti.zoom = 4.5;
1305	pti.zoomString = QStringLiteral("frac zoom");
1306	pti.w = pti.w * qPow(x: 2.0, y: 0.5);
1307	pti.h = pti.h * qPow(x: 2.0, y: 0.5);
1308
1309	pti.x = 0.5;
1310	pti.y = 0.5;
1311	pti.xyString = QStringLiteral("middle");
1312
1313	test_group(pti, xVals&: mid_t2m1x, wVals&: mid_t2m1w, yVals&: mid_t2m1x, hVals&: mid_t2m1w);
1314
1315	pti.x = 0.5;
1316	pti.y = 0.0;
1317	pti.xyString = QStringLiteral("top");
1318
1319	test_group(pti, xVals&: mid_t2m1x, wVals&: mid_t2m1w, yVals&: top_t2m1x, hVals&: top_t2m1w);
1320
1321	pti.x = 0.5;
1322	pti.y = 15.0 / 16.0;
1323	pti.xyString = QStringLiteral("bottom");
1324
1325	test_group(pti, xVals&: mid_t2m1x, wVals&: mid_t2m1w, yVals&: bottom_t2m1x, hVals&: bottom_t2m1w);
1326
1327	pti.x = 0.0;
1328	pti.y = 0.5;
1329	pti.xyString = QStringLiteral("left");
1330
1331	test_group(pti, xVals&: left_t2m1x, wVals&: left_t2m1w, yVals&: mid_t2m1x, hVals&: mid_t2m1w);
1332
1333	pti.x = 15.0 / 16.0;
1334	pti.y = 0.5;
1335	pti.xyString = QStringLiteral("right");
1336
1337	test_group(pti, xVals&: right_t2m1x, wVals&: right_t2m1w, yVals&: mid_t2m1x, hVals&: mid_t2m1w);
1338
1339	/*
1340	width = 2t
1341	*/
1342
1343
1344	QList<int> mid_t2x;
1345	QList<int> mid_t2w;
1346	QList<int> top_t2x;
1347	QList<int> top_t2w;
1348	QList<int> bottom_t2x;
1349	QList<int> bottom_t2w;
1350	QList<int> left_t2x;
1351	QList<int> left_t2w;
1352	QList<int> right_t2x;
1353	QList<int> right_t2w;
1354
1355	pti.w = 2 * t;
1356	pti.h = 2 * t;
1357	pti.wString = QStringLiteral("2T");
1358	pti.hString = QStringLiteral("2T");
1359
1360	/*
1361
1362	offset = 0
1363	+ + + + + + + + + + + + + + + + + + + + +
1364	+ + + + + +
1365	+ * * * * * * * * * + +
1366	+ * + * + +
1367	+ + + + * + + + T T T T O + + + + + + + +
1368	+ * T O + +
1369	+ * * * * O * * * O + +
1370	+ + T T + +
1371	+ + + + + + + + T T T T T + + + + + + + +
1372
1373	Starts at: T - 2
1374	Covers: 4 tiles
1375	*/
1376
1377	mid_t2x << 6;
1378	mid_t2w << 4;
1379
1380	top_t2x << 0;
1381	top_t2w << 2;
1382
1383	bottom_t2x << 13;
1384	bottom_t2w << 3;
1385
1386	left_t2x << 14;
1387	left_t2w << 4;
1388
1389	right_t2x << 13;
1390	right_t2w << 4;
1391
1392	/*
1393	offset = 1
1394	+ + + + + + + + + + + + + + + + + + + + +
1395	+ + + + + +
1396	+ + * * * * * * * * * + +
1397	+ + * + * + +
1398	+ + + + + * + + T T T T T * + + + + + + +
1399	+ + * T T * + +
1400	+ + * * * O * * * O * + +
1401	+ + T T + +
1402	+ + + + + + + + T T T T T + + + + + + + +
1403
1404	Starts at: T - 1
1405	Covers: 3 tiles
1406	*/
1407
1408	mid_t2x << 7;
1409	mid_t2w << 3;
1410
1411	top_t2x << 0;
1412	top_t2w << 2;
1413
1414	bottom_t2x << 14;
1415	bottom_t2w << 2;
1416
1417	left_t2x << 15;
1418	left_t2w << 3;
1419
1420	right_t2x << 14;
1421	right_t2w << 3;
1422
1423	/*
1424	offset = 2
1425	+ + + + + + + + + + + + + + + + + + + + +
1426	+ + + + + +
1427	+ + * * * * * * * * * + +
1428	+ + * + * + +
1429	+ + + + + + * + T T T T T + * + + + + + +
1430	+ + * T T * + +
1431	+ + * * O * * * O * * + +
1432	+ + T T + +
1433	+ + + + + + + + T T T T T + + + + + + + +
1434
1435	Starts at: T - 1
1436	Covers: 3 tiles
1437	*/
1438
1439	mid_t2x << 7;
1440	mid_t2w << 3;
1441
1442	top_t2x << 0;
1443	top_t2w << 2;
1444
1445	bottom_t2x << 14;
1446	bottom_t2w << 2;
1447
1448	left_t2x << 15;
1449	left_t2w << 3;
1450
1451	right_t2x << 14;
1452	right_t2w << 3;
1453
1454	/*
1455	offset = 3
1456	+ + + + + + + + + + + + + + + + + + + + +
1457	+ + + + + +
1458	+ + * * * * * * * * * + +
1459	+ + * + * + +
1460	+ + + + + + + * T T T T T + + * + + + + +
1461	+ + * T T * + +
1462	+ + * O * * * O * * * + +
1463	+ + T T + +
1464	+ + + + + + + + T T T T T + + + + + + + +
1465
1466	Starts at: T - 1
1467	Covers: 3 tiles
1468	*/
1469
1470	mid_t2x << 7;
1471	mid_t2w << 3;
1472
1473	top_t2x << 0;
1474	top_t2w << 2;
1475
1476	bottom_t2x << 14;
1477	bottom_t2w << 2;
1478
1479	left_t2x << 15;
1480	left_t2w << 3;
1481
1482	right_t2x << 14;
1483	right_t2w << 3;
1484
1485	/*
1486	offset = 4
1487	+ + + + + + + + + + + + + + + + + + + + +
1488	+ + + + + +
1489	+ + * * * * * * * * * +
1490	+ + * * +
1491	+ + + + + + + + O T T T T + + + * + + + +
1492	+ + O T * +
1493	+ + O * * * O * * * * +
1494	+ + T T + +
1495	+ + + + + + + + T T T T T + + + + + + + +
1496
1497	Starts at: T - 1
1498	Covers: 4 tiles
1499	*/
1500
1501	mid_t2x << 7;
1502	mid_t2w << 4;
1503
1504	top_t2x << 0;
1505	top_t2w << 3;
1506
1507	bottom_t2x << 14;
1508	bottom_t2w << 2;
1509
1510	left_t2x << 15;
1511	left_t2w << 4;
1512
1513	right_t2x << 14;
1514	right_t2w << 4;
1515
1516	pti.zoom = 4.0;
1517	pti.zoomString = QStringLiteral("int zoom");
1518
1519	pti.x = 0.5;
1520	pti.y = 0.5;
1521	pti.xyString = QStringLiteral("middle");
1522
1523	test_group(pti, xVals&: mid_t2x, wVals&: mid_t2w, yVals&: mid_t2x, hVals&: mid_t2w);
1524
1525	pti.x = 0.5;
1526	pti.y = 0.0;
1527	pti.xyString = QStringLiteral("top");
1528
1529	test_group(pti, xVals&: mid_t2x, wVals&: mid_t2w, yVals&: top_t2x, hVals&: top_t2w);
1530
1531	pti.x = 0.5;
1532	pti.y = 15.0 / 16.0;
1533	pti.xyString = QStringLiteral("bottom");
1534
1535	test_group(pti, xVals&: mid_t2x, wVals&: mid_t2w, yVals&: bottom_t2x, hVals&: bottom_t2w);
1536
1537	pti.x = 0.0;
1538	pti.y = 0.5;
1539	pti.xyString = QStringLiteral("left");
1540
1541	test_group(pti, xVals&: left_t2x, wVals&: left_t2w, yVals&: mid_t2x, hVals&: mid_t2w);
1542
1543	pti.x = 15.0 / 16.0;
1544	pti.y = 0.5;
1545	pti.xyString = QStringLiteral("right");
1546
1547	test_group(pti, xVals&: right_t2x, wVals&: right_t2w, yVals&: mid_t2x, hVals&: mid_t2w);
1548
1549	pti.zoom = 4.5;
1550	pti.zoomString = QStringLiteral("frac zoom");
1551	pti.w = pti.w * qPow(x: 2.0, y: 0.5);
1552	pti.h = pti.h * qPow(x: 2.0, y: 0.5);
1553
1554	pti.x = 0.5;
1555	pti.y = 0.5;
1556	pti.xyString = QStringLiteral("middle");
1557
1558	test_group(pti, xVals&: mid_t2x, wVals&: mid_t2w, yVals&: mid_t2x, hVals&: mid_t2w);
1559
1560	pti.x = 0.5;
1561	pti.y = 0.0;
1562	pti.xyString = QStringLiteral("top");
1563
1564	test_group(pti, xVals&: mid_t2x, wVals&: mid_t2w, yVals&: top_t2x, hVals&: top_t2w);
1565
1566	pti.x = 0.5;
1567	pti.y = 15.0 / 16.0;
1568	pti.xyString = QStringLiteral("bottom");
1569
1570	test_group(pti, xVals&: mid_t2x, wVals&: mid_t2w, yVals&: bottom_t2x, hVals&: bottom_t2w);
1571
1572	pti.x = 0.0;
1573	pti.y = 0.5;
1574	pti.xyString = QStringLiteral("left");
1575
1576	test_group(pti, xVals&: left_t2x, wVals&: left_t2w, yVals&: mid_t2x, hVals&: mid_t2w);
1577
1578	pti.x = 15.0 / 16.0;
1579	pti.y = 0.5;
1580	pti.xyString = QStringLiteral("right");
1581
1582	test_group(pti, xVals&: right_t2x, wVals&: right_t2w, yVals&: mid_t2x, hVals&: mid_t2w);
1583
1584	/*
1585	width = 2t + 1
1586	*/
1587
1588	QList<int> mid_t2p1x;
1589	QList<int> mid_t2p1w;
1590	QList<int> top_t2p1x;
1591	QList<int> top_t2p1w;
1592	QList<int> bottom_t2p1x;
1593	QList<int> bottom_t2p1w;
1594	QList<int> left_t2p1x;
1595	QList<int> left_t2p1w;
1596	QList<int> right_t2p1x;
1597	QList<int> right_t2p1w;
1598
1599	pti.w = 2 * t + 1;
1600	pti.h = 2 * t + 1;
1601	pti.wString = QStringLiteral("(2T + 1)");
1602	pti.hString = QStringLiteral("(2T + 1)");
1603
1604	/*
1605
1606	offset = 0
1607	+ + + + + + + + + + + + + + + + + + + + +
1608	+ + + + + +
1609	+ *+* * * *+* * * *+* + +
1610	+ *+ + +* + +
1611	+ + + +*+ + + + T T T T T*+ + + + + + + +
1612	+ *+ T T* + +
1613	+ *+* * * *T* * * *T* + +
1614	+ + T T + +
1615	+ + + + + + + + T T T T T + + + + + + + +
1616
1617	Starts at: T - 2
1618	Covers: 4 tiles
1619	*/
1620
1621	mid_t2p1x << 6;
1622	mid_t2p1w << 4;
1623
1624	top_t2p1x << 0;
1625	top_t2p1w << 2;
1626
1627	bottom_t2p1x << 13;
1628	bottom_t2p1w << 3;
1629
1630	left_t2p1x << 14;
1631	left_t2p1w << 4;
1632
1633	right_t2p1x << 13;
1634	right_t2p1w << 4;
1635
1636	/*
1637	offset = 1
1638	+ + + + + + + + + + + + + + + + + + + + +
1639	+ + + + + +
1640	+ +* * * *+* * * *+* * + +
1641	+ +* + + * + +
1642	+ + + + +*+ + + T T T T T +*+ + + + + + +
1643	+ +* T T * + +
1644	+ +* * * *T* * * *T* * + +
1645	+ + T T + +
1646	+ + + + + + + + T T T T T + + + + + + + +
1647
1648	Starts at: T - 1
1649	Covers: 3 tiles
1650	*/
1651
1652	mid_t2p1x << 7;
1653	mid_t2p1w << 3;
1654
1655	top_t2p1x << 0;
1656	top_t2p1w << 2;
1657
1658	bottom_t2p1x << 14;
1659	bottom_t2p1w << 2;
1660
1661	left_t2p1x << 15;
1662	left_t2p1w << 3;
1663
1664	right_t2p1x << 14;
1665	right_t2p1w << 3;
1666
1667	/*
1668	offset = 2
1669	+ + + + + + + + + + + + + + + + + + + + +
1670	+ + + + + +
1671	+ + * * *+* * * *+* * * + +
1672	+ + * + + * + +
1673	+ + + + + +*+ + T T T T T + +*+ + + + + +
1674	+ + * T T * + +
1675	+ + * * *T* * * *T* * * + +
1676	+ + T T + +
1677	+ + + + + + + + T T T T T + + + + + + + +
1678
1679	Starts at: T - 1
1680	Covers: 3 tiles
1681	*/
1682
1683	mid_t2p1x << 7;
1684	mid_t2p1w << 3;
1685
1686	top_t2p1x << 0;
1687	top_t2p1w << 2;
1688
1689	bottom_t2p1x << 14;
1690	bottom_t2p1w << 2;
1691
1692	left_t2p1x << 15;
1693	left_t2p1w << 3;
1694
1695	right_t2p1x << 14;
1696	right_t2p1w << 3;
1697
1698	/*
1699	offset = 3
1700	+ + + + + + + + + + + + + + + + + + + + +
1701	+ + + + + +
1702	+ + * *+* * * *+* * * *+ +
1703	+ + * + + *+ +
1704	+ + + + + + +*+ T T T T T + + +*+ + + + +
1705	+ + * T T *+ +
1706	+ + * *T* * * *T* * * *+ +
1707	+ + T T + +
1708	+ + + + + + + + T T T T T + + + + + + + +
1709
1710	Starts at: T - 1
1711	Covers: 3 tiles
1712	*/
1713
1714	mid_t2p1x << 7;
1715	mid_t2p1w << 3;
1716
1717	top_t2p1x << 0;
1718	top_t2p1w << 2;
1719
1720	bottom_t2p1x << 14;
1721	bottom_t2p1w << 2;
1722
1723	left_t2p1x << 15;
1724	left_t2p1w << 3;
1725
1726	right_t2p1x << 14;
1727	right_t2p1w << 3;
1728
1729	/*
1730	offset = 4
1731	+ + + + + + + + + + + + + + + + + + + + +
1732	+ + + + + +
1733	+ + *+* * * *+* * * *+* +
1734	+ + *+ + +* +
1735	+ + + + + + + +*T T T T T + + + +*+ + + +
1736	+ + *T T +* +
1737	+ + *T* * * *T* * * *+* +
1738	+ + T T + +
1739	+ + + + + + + + T T T T T + + + + + + + +
1740
1741	Starts at: T - 1
1742	Covers: 4 tiles
1743	*/
1744
1745	mid_t2p1x << 7;
1746	mid_t2p1w << 4;
1747
1748	top_t2p1x << 0;
1749	top_t2p1w << 3;
1750
1751	bottom_t2p1x << 14;
1752	bottom_t2p1w << 2;
1753
1754	left_t2p1x << 15;
1755	left_t2p1w << 4;
1756
1757	right_t2p1x << 14;
1758	right_t2p1w << 4;
1759
1760	pti.zoom = 4.0;
1761	pti.zoomString = QStringLiteral("int zoom");
1762
1763	pti.x = 0.5;
1764	pti.y = 0.5;
1765	pti.xyString = QStringLiteral("middle");
1766
1767	test_group(pti, xVals&: mid_t2p1x, wVals&: mid_t2p1w, yVals&: mid_t2p1x, hVals&: mid_t2p1w);
1768
1769	pti.x = 0.5;
1770	pti.y = 0.0;
1771	pti.xyString = QStringLiteral("top");
1772
1773	test_group(pti, xVals&: mid_t2p1x, wVals&: mid_t2p1w, yVals&: top_t2p1x, hVals&: top_t2p1w);
1774
1775	pti.x = 0.5;
1776	pti.y = 15.0 / 16.0;
1777	pti.xyString = QStringLiteral("bottom");
1778
1779	test_group(pti, xVals&: mid_t2p1x, wVals&: mid_t2p1w, yVals&: bottom_t2p1x, hVals&: bottom_t2p1w);
1780
1781	pti.x = 0.0;
1782	pti.y = 0.5;
1783	pti.xyString = QStringLiteral("left");
1784
1785	test_group(pti, xVals&: left_t2p1x, wVals&: left_t2p1w, yVals&: mid_t2p1x, hVals&: mid_t2p1w);
1786
1787	pti.x = 15.0 / 16.0;
1788	pti.y = 0.5;
1789	pti.xyString = QStringLiteral("right");
1790
1791	test_group(pti, xVals&: right_t2p1x, wVals&: right_t2p1w, yVals&: mid_t2p1x, hVals&: mid_t2p1w);
1792
1793	pti.zoom = 4.5;
1794	pti.zoomString = QStringLiteral("frac zoom");
1795	pti.w = pti.w * qPow(x: 2.0, y: 0.5);
1796	pti.h = pti.h * qPow(x: 2.0, y: 0.5);
1797
1798	pti.x = 0.5;
1799	pti.y = 0.5;
1800	pti.xyString = QStringLiteral("middle");
1801
1802	test_group(pti, xVals&: mid_t2p1x, wVals&: mid_t2p1w, yVals&: mid_t2p1x, hVals&: mid_t2p1w);
1803
1804	pti.x = 0.5;
1805	pti.y = 0.0;
1806	pti.xyString = QStringLiteral("top");
1807
1808	test_group(pti, xVals&: mid_t2p1x, wVals&: mid_t2p1w, yVals&: top_t2p1x, hVals&: top_t2p1w);
1809
1810	pti.x = 0.5;
1811	pti.y = 15.0 / 16.0;
1812	pti.xyString = QStringLiteral("bottom");
1813
1814	test_group(pti, xVals&: mid_t2p1x, wVals&: mid_t2p1w, yVals&: bottom_t2p1x, hVals&: bottom_t2p1w);
1815
1816	pti.x = 0.0;
1817	pti.y = 0.5;
1818	pti.xyString = QStringLiteral("left");
1819
1820	test_group(pti, xVals&: left_t2p1x, wVals&: left_t2p1w, yVals&: mid_t2p1x, hVals&: mid_t2p1w);
1821
1822	pti.x = 15.0 / 16.0;
1823	pti.y = 0.5;
1824	pti.xyString = QStringLiteral("right");
1825
1826	test_group(pti, xVals&: right_t2p1x, wVals&: right_t2p1w, yVals&: mid_t2p1x, hVals&: mid_t2p1w);
1827	}
1828
1829	QTEST_GUILESS_MAIN(tst_QGeoCameraTiles)
1830	#include "tst_qgeocameratiles.moc"
1831