|
60 | 60 |
|
61 | 61 | class TestQgsPointDisplacementRenderer(unittest.TestCase):
|
62 | 62 |
|
63 |
| - def setUp(self): |
| 63 | + def _setUp(self): |
64 | 64 | myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp')
|
65 |
| - self.layer = QgsVectorLayer(myShpFile, 'Points', 'ogr') |
66 |
| - QgsProject.instance().addMapLayer(self.layer) |
| 65 | + layer = QgsVectorLayer(myShpFile, 'Points', 'ogr') |
| 66 | + QgsProject.instance().addMapLayer(layer) |
67 | 67 |
|
68 |
| - self.renderer = QgsPointDisplacementRenderer() |
| 68 | + renderer = QgsPointDisplacementRenderer() |
69 | 69 | sym1 = QgsMarkerSymbol.createSimple({'color': '#ff00ff', 'size': '3', 'outline_style': 'no'})
|
70 |
| - renderer = QgsSingleSymbolRenderer(sym1) |
71 |
| - self.renderer.setEmbeddedRenderer(renderer) |
72 |
| - self.renderer.setCircleRadiusAddition(2) |
73 |
| - self.renderer.setCircleWidth(1) |
74 |
| - self.renderer.setCircleColor(QColor(0, 0, 0)) |
75 |
| - self.renderer.setCenterSymbol(QgsMarkerSymbol.createSimple({'color': '#ffff00', 'size': '3', 'outline_style': 'no'})) |
76 |
| - self.layer.setRenderer(self.renderer) |
77 |
| - |
78 |
| - rendered_layers = [self.layer] |
79 |
| - self.mapsettings = QgsMapSettings() |
80 |
| - self.mapsettings.setOutputSize(QSize(400, 400)) |
81 |
| - self.mapsettings.setOutputDpi(96) |
82 |
| - self.mapsettings.setExtent(QgsRectangle(-123, 18, -70, 52)) |
83 |
| - self.mapsettings.setLayers(rendered_layers) |
84 |
| - |
85 |
| - def tearDown(self): |
86 |
| - QgsProject.instance().removeAllMapLayers() |
| 70 | + sym_renderer = QgsSingleSymbolRenderer(sym1) |
| 71 | + renderer.setEmbeddedRenderer(sym_renderer) |
| 72 | + renderer.setCircleRadiusAddition(2) |
| 73 | + renderer.setCircleWidth(1) |
| 74 | + renderer.setCircleColor(QColor(0, 0, 0)) |
| 75 | + renderer.setCenterSymbol(QgsMarkerSymbol.createSimple({'color': '#ffff00', 'size': '3', 'outline_style': 'no'})) |
| 76 | + layer.setRenderer(renderer) |
| 77 | + |
| 78 | + rendered_layers = [layer] |
| 79 | + mapsettings = QgsMapSettings() |
| 80 | + mapsettings.setOutputSize(QSize(400, 400)) |
| 81 | + mapsettings.setOutputDpi(96) |
| 82 | + mapsettings.setExtent(QgsRectangle(-123, 18, -70, 52)) |
| 83 | + mapsettings.setLayers(rendered_layers) |
| 84 | + return layer, renderer, mapsettings |
| 85 | + |
| 86 | + def _tearDown(self, layer): |
| 87 | + #QgsProject.instance().removeAllMapLayers() |
| 88 | + QgsProject.instance().removeMapLayer(layer) |
87 | 89 |
|
88 | 90 | def _setProperties(self, r):
|
89 | 91 | """ set properties for a renderer for testing with _checkProperties"""
|
@@ -125,15 +127,15 @@ def _checkProperties(self, r):
|
125 | 127 | self.assertEqual(r.embeddedRenderer().symbol().color().name(), '#fdbf6f')
|
126 | 128 | self.assertEqual(r.labelDistanceFactor(), 0.25)
|
127 | 129 |
|
128 |
| - def _set_categorized_renderer(self): |
129 |
| - renderer = QgsCategorizedSymbolRenderer(attrName='Class') |
| 130 | + def _create_categorized_renderer(self): |
| 131 | + cat_renderer = QgsCategorizedSymbolRenderer(attrName='Class') |
130 | 132 | sym1 = QgsMarkerSymbol.createSimple({'color': '#ff00ff', 'size': '6', 'outline_style': 'no'})
|
131 | 133 | cat1 = QgsRendererCategory('Biplane', sym1, 'Big')
|
132 |
| - renderer.addCategory(cat1) |
| 134 | + cat_renderer.addCategory(cat1) |
133 | 135 | sym2 = QgsMarkerSymbol.createSimple({'color': '#ff00ff', 'size': '3', 'outline_style': 'no'})
|
134 | 136 | cat2 = QgsRendererCategory(['B52', 'Jet'], sym2, 'Smaller')
|
135 |
| - renderer.addCategory(cat2) |
136 |
| - self.renderer.setEmbeddedRenderer(renderer) |
| 137 | + cat_renderer.addCategory(cat2) |
| 138 | + return cat_renderer |
137 | 139 |
|
138 | 140 | def testGettersSetters(self):
|
139 | 141 | """ test getters and setters """
|
@@ -187,160 +189,188 @@ def testConvert(self):
|
187 | 189 | self.assertEqual(d.embeddedRenderer().symbol().color().name(), '#fdbf6f')
|
188 | 190 |
|
189 | 191 | def testRenderNoCluster(self):
|
190 |
| - self.layer.renderer().setTolerance(1) |
| 192 | + layer, renderer, mapsettings = self._setUp() |
| 193 | + layer.renderer().setTolerance(1) |
191 | 194 | renderchecker = QgsMultiRenderChecker()
|
192 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 195 | + renderchecker.setMapSettings(mapsettings) |
193 | 196 | renderchecker.setControlPathPrefix('displacement_renderer')
|
194 | 197 | renderchecker.setControlName('expected_displacement_no_cluster')
|
195 | 198 | self.assertTrue(renderchecker.runTest('displacement_no_cluster'))
|
| 199 | + self._tearDown(layer) |
196 | 200 |
|
197 | 201 | def testRenderWithin(self):
|
198 |
| - self.layer.renderer().setTolerance(10) |
| 202 | + layer, renderer, mapsettings = self._setUp() |
| 203 | + layer.renderer().setTolerance(10) |
199 | 204 | renderchecker = QgsMultiRenderChecker()
|
200 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 205 | + renderchecker.setMapSettings(mapsettings) |
201 | 206 | renderchecker.setControlPathPrefix('displacement_renderer')
|
202 | 207 | renderchecker.setControlName('expected_displacement_cluster')
|
203 | 208 | self.assertTrue(renderchecker.runTest('expected_displacement_cluster'))
|
| 209 | + self._tearDown(layer) |
204 | 210 |
|
205 | 211 | def testRenderVariables(self):
|
206 | 212 | """ test rendering with expression variables in marker """
|
207 |
| - self.layer.renderer().setTolerance(10) |
| 213 | + layer, renderer, mapsettings = self._setUp() |
| 214 | + layer.renderer().setTolerance(10) |
208 | 215 |
|
209 |
| - old_marker = self.layer.renderer().centerSymbol().clone() |
| 216 | + old_marker = layer.renderer().centerSymbol().clone() |
210 | 217 |
|
211 | 218 | new_marker = QgsMarkerSymbol.createSimple({'color': '#ffff00', 'size': '3', 'outline_style': 'no'})
|
212 | 219 | new_marker.symbolLayer(0).setDataDefinedProperty(QgsSymbolLayer.PropertyFillColor, QgsProperty.fromExpression('@cluster_color'))
|
213 | 220 | new_marker.symbolLayer(0).setDataDefinedProperty(QgsSymbolLayer.PropertySize, QgsProperty.fromExpression('@cluster_size*2'))
|
214 |
| - self.layer.renderer().setCenterSymbol(new_marker) |
| 221 | + layer.renderer().setCenterSymbol(new_marker) |
215 | 222 | renderchecker = QgsMultiRenderChecker()
|
216 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 223 | + renderchecker.setMapSettings(mapsettings) |
217 | 224 | renderchecker.setControlPathPrefix('displacement_renderer')
|
218 | 225 | renderchecker.setControlName('expected_displacement_variables')
|
219 | 226 | result = renderchecker.runTest('expected_displacement_variables')
|
220 |
| - self.layer.renderer().setCenterSymbol(old_marker) |
| 227 | + layer.renderer().setCenterSymbol(old_marker) |
221 | 228 | self.assertTrue(result)
|
| 229 | + self._tearDown(layer) |
222 | 230 |
|
223 | 231 | def testRenderGrid(self):
|
224 |
| - self.layer.renderer().setTolerance(10) |
225 |
| - self.layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid) |
| 232 | + layer, renderer, mapsettings = self._setUp() |
| 233 | + layer.renderer().setTolerance(10) |
| 234 | + layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid) |
226 | 235 | renderchecker = QgsMultiRenderChecker()
|
227 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 236 | + renderchecker.setMapSettings(mapsettings) |
228 | 237 | renderchecker.setControlPathPrefix('displacement_renderer')
|
229 | 238 | renderchecker.setControlName('expected_displacement_grid')
|
230 | 239 | self.assertTrue(renderchecker.runTest('expected_displacement_grid'))
|
| 240 | + self._tearDown(layer) |
231 | 241 |
|
232 | 242 | def testRenderGridAdjust(self):
|
233 |
| - self.layer.renderer().setTolerance(10) |
234 |
| - self.layer.renderer().setCircleRadiusAddition(5) |
235 |
| - self.layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid) |
236 |
| - self.layer.renderer().setCircleColor(QColor()) |
| 243 | + layer, renderer, mapsettings = self._setUp() |
| 244 | + layer.renderer().setTolerance(10) |
| 245 | + layer.renderer().setCircleRadiusAddition(5) |
| 246 | + layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid) |
| 247 | + layer.renderer().setCircleColor(QColor()) |
237 | 248 | renderchecker = QgsMultiRenderChecker()
|
238 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 249 | + renderchecker.setMapSettings(mapsettings) |
239 | 250 | renderchecker.setControlPathPrefix('displacement_renderer')
|
240 | 251 | renderchecker.setControlName('expected_displacement_adjust_grid')
|
241 | 252 | self.assertTrue(renderchecker.runTest('expected_displacement_adjust_grid'))
|
| 253 | + self._tearDown(layer) |
242 | 254 |
|
243 | 255 | def testClusterRingLabels(self):
|
244 |
| - self.layer.renderer().setTolerance(10) |
245 |
| - self.layer.renderer().setLabelAttributeName('Class') |
246 |
| - self.layer.renderer().setLabelDistanceFactor(0.35) |
| 256 | + layer, renderer, mapsettings = self._setUp() |
| 257 | + layer.renderer().setTolerance(10) |
| 258 | + layer.renderer().setLabelAttributeName('Class') |
| 259 | + layer.renderer().setLabelDistanceFactor(0.35) |
247 | 260 | renderchecker = QgsMultiRenderChecker()
|
248 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 261 | + renderchecker.setMapSettings(mapsettings) |
249 | 262 | renderchecker.setControlPathPrefix('displacement_renderer')
|
250 | 263 | renderchecker.setControlName('expected_displacement_cluster_ring_labels')
|
251 | 264 | self.assertTrue(renderchecker.runTest('expected_displacement_cluster_ring_labels'))
|
252 |
| - |
253 |
| - def testClusterGridLabels(self): |
254 |
| - self.layer.renderer().setTolerance(10) |
255 |
| - self.layer.renderer().setLabelAttributeName('Class') |
256 |
| - self.layer.renderer().setLabelDistanceFactor(0.35) |
257 |
| - self.layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid) |
| 265 | + self._tearDown(layer) |
| 266 | + |
| 267 | + def _testClusterGridLabels(self): |
| 268 | + layer, renderer, mapsettings = self._setUp() |
| 269 | + layer.renderer().setTolerance(10) |
| 270 | + layer.renderer().setLabelAttributeName('Class') |
| 271 | + layer.renderer().setLabelDistanceFactor(0.35) |
| 272 | + layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid) |
258 | 273 | renderchecker = QgsMultiRenderChecker()
|
259 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 274 | + renderchecker.setMapSettings(mapsettings) |
260 | 275 | renderchecker.setControlPathPrefix('displacement_renderer')
|
261 | 276 | renderchecker.setControlName('expected_displacement_cluster_grid_labels')
|
262 | 277 | self.assertTrue(renderchecker.runTest('expected_displacement_cluster_grid_labels'))
|
263 |
| - |
264 |
| - def testClusterConcentricLabels(self): |
265 |
| - self.layer.renderer().setTolerance(10) |
266 |
| - self.layer.renderer().setLabelAttributeName('Class') |
267 |
| - self.layer.renderer().setLabelDistanceFactor(0.35) |
268 |
| - self.layer.renderer().setPlacement(QgsPointDisplacementRenderer.ConcentricRings) |
| 278 | + self._tearDown(layer) |
| 279 | + |
| 280 | + def _testClusterConcentricLabels(self): |
| 281 | + layer, renderer, mapsettings = self._setUp() |
| 282 | + layer.renderer().setTolerance(10) |
| 283 | + layer.renderer().setLabelAttributeName('Class') |
| 284 | + layer.renderer().setLabelDistanceFactor(0.35) |
| 285 | + layer.renderer().setPlacement(QgsPointDisplacementRenderer.ConcentricRings) |
269 | 286 | renderchecker = QgsMultiRenderChecker()
|
270 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 287 | + renderchecker.setMapSettings(mapsettings) |
271 | 288 | renderchecker.setControlPathPrefix('displacement_renderer')
|
272 | 289 | renderchecker.setControlName('expected_displacement_cluster_concentric_labels')
|
273 | 290 | self.assertTrue(renderchecker.runTest('expected_displacement_cluster_concentric_labels'))
|
274 |
| - |
275 |
| - def testClusterRingLabelsDifferentSizes(self): |
276 |
| - self._set_categorized_renderer() |
277 |
| - self.layer.renderer().setTolerance(10) |
278 |
| - self.layer.renderer().setLabelAttributeName('Class') |
279 |
| - self.layer.renderer().setLabelDistanceFactor(0.35) |
| 291 | + self._tearDown(layer) |
| 292 | + |
| 293 | + def _testClusterRingLabelsDifferentSizes(self): |
| 294 | + layer, renderer, mapsettings = self._setUp() |
| 295 | + renderer.setEmbeddedRenderer(self._create_categorized_renderer()) |
| 296 | + layer.renderer().setTolerance(10) |
| 297 | + layer.renderer().setLabelAttributeName('Class') |
| 298 | + layer.renderer().setLabelDistanceFactor(0.35) |
280 | 299 | renderchecker = QgsMultiRenderChecker()
|
281 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 300 | + renderchecker.setMapSettings(mapsettings) |
282 | 301 | renderchecker.setControlPathPrefix('displacement_renderer')
|
283 | 302 | renderchecker.setControlName('expected_displacement_cluster_ring_labels_diff_size')
|
284 | 303 | self.assertTrue(renderchecker.runTest('expected_displacement_cluster_ring_labels_diff_size'))
|
285 |
| - |
286 |
| - def testClusterGridLabelsDifferentSizes(self): |
287 |
| - self._set_categorized_renderer() |
288 |
| - self.layer.renderer().setTolerance(10) |
289 |
| - self.layer.renderer().setLabelAttributeName('Class') |
290 |
| - self.layer.renderer().setLabelDistanceFactor(0.35) |
291 |
| - self.layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid) |
| 304 | + self._tearDown(layer) |
| 305 | + |
| 306 | + def _testClusterGridLabelsDifferentSizes(self): |
| 307 | + layer, renderer, mapsettings = self._setUp() |
| 308 | + renderer.setEmbeddedRenderer(self._create_categorized_renderer()) |
| 309 | + layer.renderer().setTolerance(10) |
| 310 | + layer.renderer().setLabelAttributeName('Class') |
| 311 | + layer.renderer().setLabelDistanceFactor(0.35) |
| 312 | + layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid) |
292 | 313 | renderchecker = QgsMultiRenderChecker()
|
293 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 314 | + renderchecker.setMapSettings(mapsettings) |
294 | 315 | renderchecker.setControlPathPrefix('displacement_renderer')
|
295 | 316 | renderchecker.setControlName('expected_displacement_cluster_grid_labels_diff_size')
|
296 | 317 | self.assertTrue(renderchecker.runTest('expected_displacement_cluster_grid_labels_diff_size'))
|
297 |
| - |
298 |
| - def testClusterConcentricLabelsDifferentSizes(self): |
299 |
| - self._set_categorized_renderer() |
300 |
| - self.layer.renderer().setTolerance(10) |
301 |
| - self.layer.renderer().setLabelAttributeName('Class') |
302 |
| - self.layer.renderer().setLabelDistanceFactor(0.35) |
303 |
| - self.layer.renderer().setPlacement(QgsPointDisplacementRenderer.ConcentricRings) |
| 318 | + self._tearDown(layer) |
| 319 | + |
| 320 | + def _testClusterConcentricLabelsDifferentSizes(self): |
| 321 | + layer, renderer, mapsettings = self._setUp() |
| 322 | + renderer.setEmbeddedRenderer(self._create_categorized_renderer()) |
| 323 | + layer.renderer().setTolerance(10) |
| 324 | + layer.renderer().setLabelAttributeName('Class') |
| 325 | + layer.renderer().setLabelDistanceFactor(0.35) |
| 326 | + layer.renderer().setPlacement(QgsPointDisplacementRenderer.ConcentricRings) |
304 | 327 | renderchecker = QgsMultiRenderChecker()
|
305 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 328 | + renderchecker.setMapSettings(mapsettings) |
306 | 329 | renderchecker.setControlPathPrefix('displacement_renderer')
|
307 | 330 | renderchecker.setControlName('expected_displacement_cluster_concentric_labels_diff_size')
|
308 | 331 | self.assertTrue(renderchecker.runTest('expected_displacement_cluster_concentric_labels_diff_size'))
|
309 |
| - |
310 |
| - def testClusterRingLabelsDifferentSizesFarther(self): |
311 |
| - self._set_categorized_renderer() |
312 |
| - self.layer.renderer().setTolerance(10) |
313 |
| - self.layer.renderer().setLabelAttributeName('Class') |
314 |
| - self.layer.renderer().setLabelDistanceFactor(1) |
| 332 | + self._tearDown(layer) |
| 333 | + |
| 334 | + def _testClusterRingLabelsDifferentSizesFarther(self): |
| 335 | + layer, renderer, mapsettings = self._setUp() |
| 336 | + renderer.setEmbeddedRenderer(self._create_categorized_renderer()) |
| 337 | + layer.renderer().setTolerance(10) |
| 338 | + layer.renderer().setLabelAttributeName('Class') |
| 339 | + layer.renderer().setLabelDistanceFactor(1) |
315 | 340 | renderchecker = QgsMultiRenderChecker()
|
316 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 341 | + renderchecker.setMapSettings(mapsettings) |
317 | 342 | renderchecker.setControlPathPrefix('displacement_renderer')
|
318 | 343 | renderchecker.setControlName('expected_displacement_cluster_ring_labels_diff_size_farther')
|
319 | 344 | self.assertTrue(renderchecker.runTest('expected_displacement_cluster_ring_labels_diff_size_farther'))
|
320 |
| - |
321 |
| - def testClusterGridLabelsDifferentSizesFarther(self): |
322 |
| - self._set_categorized_renderer() |
323 |
| - self.layer.renderer().setTolerance(10) |
324 |
| - self.layer.renderer().setLabelAttributeName('Class') |
325 |
| - self.layer.renderer().setLabelDistanceFactor(1) |
326 |
| - self.layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid) |
| 345 | + self._tearDown(layer) |
| 346 | + |
| 347 | + def _testClusterGridLabelsDifferentSizesFarther(self): |
| 348 | + layer, renderer, mapsettings = self._setUp() |
| 349 | + renderer.setEmbeddedRenderer(self._create_categorized_renderer()) |
| 350 | + layer.renderer().setTolerance(10) |
| 351 | + layer.renderer().setLabelAttributeName('Class') |
| 352 | + layer.renderer().setLabelDistanceFactor(1) |
| 353 | + layer.renderer().setPlacement(QgsPointDisplacementRenderer.Grid) |
327 | 354 | renderchecker = QgsMultiRenderChecker()
|
328 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 355 | + renderchecker.setMapSettings(mapsettings) |
329 | 356 | renderchecker.setControlPathPrefix('displacement_renderer')
|
330 | 357 | renderchecker.setControlName('expected_displacement_cluster_grid_labels_diff_size_farther')
|
331 | 358 | self.assertTrue(renderchecker.runTest('expected_displacement_cluster_grid_labels_diff_size_farther'))
|
332 |
| - |
333 |
| - def testClusterConcentricLabelsDifferentSizesFarther(self): |
334 |
| - self._set_categorized_renderer() |
335 |
| - self.layer.renderer().setTolerance(10) |
336 |
| - self.layer.renderer().setLabelAttributeName('Class') |
337 |
| - self.layer.renderer().setLabelDistanceFactor(1) |
338 |
| - self.layer.renderer().setPlacement(QgsPointDisplacementRenderer.ConcentricRings) |
| 359 | + self._tearDown(layer) |
| 360 | + |
| 361 | + def _testClusterConcentricLabelsDifferentSizesFarther(self): |
| 362 | + layer, renderer, mapsettings = self._setUp() |
| 363 | + renderer.setEmbeddedRenderer(self._create_categorized_renderer()) |
| 364 | + layer.renderer().setTolerance(10) |
| 365 | + layer.renderer().setLabelAttributeName('Class') |
| 366 | + layer.renderer().setLabelDistanceFactor(1) |
| 367 | + layer.renderer().setPlacement(QgsPointDisplacementRenderer.ConcentricRings) |
339 | 368 | renderchecker = QgsMultiRenderChecker()
|
340 |
| - renderchecker.setMapSettings(self.mapsettings) |
| 369 | + renderchecker.setMapSettings(mapsettings) |
341 | 370 | renderchecker.setControlPathPrefix('displacement_renderer')
|
342 | 371 | renderchecker.setControlName('expected_displacement_cluster_concentric_labels_diff_size_farther')
|
343 | 372 | self.assertTrue(renderchecker.runTest('expected_displacement_cluster_concentric_labels_diff_size_farther'))
|
| 373 | + self._tearDown(layer) |
344 | 374 |
|
345 | 375 |
|
346 | 376 |
|
|
0 commit comments