def createTemporaryRenderContext():
layerModel = iface.layerTreeView().layerTreeModel()
mupp, dpi, scale = layerModel.legendMapViewData()
if qgsDoubleNear(mupp, 0.0) or dpi == 0 or qgsDoubleNear(scale, 0.0):
return None
render_context = QgsRenderContext()
render_context.setScaleFactor(dpi / 25.4)
render_context.setRendererScale(scale)
render_context.setMapToPixel(QgsMapToPixel(mupp))
return render_context
def qgis_render_context(painter, width, height):
mtp = QgsMapToPixel()
# the default viewport if centered on 0, 0
mtp.setParameters( 1, # map units per pixel
width/2, # map center in geographical units
height/2, # map center in geographical units
width, # output width in pixels
height, # output height in pixels
0.0 # rotation in degrees
)
context = QgsRenderContext()
context.setMapToPixel(mtp)
context.setPainter(painter)
return context
def isFeatureRendered(canvas, layer, feature):
renderer = layer.rendererV2()
renderContext = QgsRenderContext()
renderContext.setExtent(canvas.mapRenderer().rendererContext().extent())
renderContext.setMapToPixel(canvas.mapRenderer().rendererContext().mapToPixel())
renderContext.setRendererScale(canvas.mapRenderer().scale())
if QGis.QGIS_VERSION_INT >= 20300:
renderer.startRender(renderContext, layer.pendingFields())
else:
renderer.startRender(renderContext, layer)
ans = renderer.willRenderFeature(feature)
renderer.stopRender(renderContext)
return ans
def isFeatureRendered(canvas, layer, feature):
renderer = layer.rendererV2()
renderContext = QgsRenderContext()
renderContext.setExtent(canvas.mapRenderer().rendererContext().extent())
renderContext.setMapToPixel(
canvas.mapRenderer().rendererContext().mapToPixel())
renderContext.setRendererScale(canvas.mapRenderer().scale())
if QGis.QGIS_VERSION_INT >= 20300:
renderer.startRender(renderContext, layer.pendingFields())
else:
renderer.startRender(renderContext, layer)
ans = renderer.willRenderFeature(feature)
renderer.stopRender(renderContext)
return ans
def testPainterClipPath(self):
region = QgsMapClippingRegion(QgsGeometry.fromWkt('Polygon((0 0, 1 0, 1 1, 0 1, 0 0))'))
region.setFeatureClip(QgsMapClippingRegion.FeatureClippingType.ClipPainterOnly)
region2 = QgsMapClippingRegion(QgsGeometry.fromWkt('Polygon((0 0, 0.1 0, 0.1 2, 0 2, 0 0))'))
region2.setFeatureClip(QgsMapClippingRegion.FeatureClippingType.NoClipping)
region3 = QgsMapClippingRegion(QgsGeometry.fromWkt('Polygon((0 0, 0.1 0, 0.1 2, 0 2, 0 0))'))
region3.setFeatureClip(QgsMapClippingRegion.FeatureClippingType.ClipPainterOnly)
rc = QgsRenderContext()
for t in [QgsMapLayerType.VectorLayer, QgsMapLayerType.RasterLayer, QgsMapLayerType.MeshLayer, QgsMapLayerType.VectorTileLayer]:
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion([], rc, t)
self.assertFalse(should_clip)
self.assertEqual(path.elementCount(), 0)
for t in [QgsMapLayerType.VectorLayer, QgsMapLayerType.RasterLayer, QgsMapLayerType.MeshLayer, QgsMapLayerType.VectorTileLayer]:
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion([region], rc, t)
self.assertTrue(should_clip)
self.assertEqual(QgsGeometry.fromQPolygonF(path.toFillPolygon()).asWkt(1), 'Polygon ((0 1, 1 1, 1 0, 0 0, 0 1))')
# region2 is a Intersects type clipping region, should not apply for vector layers
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion([region2], rc, QgsMapLayerType.VectorLayer)
self.assertFalse(should_clip)
self.assertEqual(path.elementCount(), 0)
for t in [QgsMapLayerType.RasterLayer, QgsMapLayerType.MeshLayer, QgsMapLayerType.VectorTileLayer]:
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion([region2], rc, t)
self.assertTrue(should_clip)
self.assertEqual(QgsGeometry.fromQPolygonF(path.toFillPolygon()).asWkt(1), 'Polygon ((0 1, 0.1 1, 0.1 -1, 0 -1, 0 1))')
for t in [QgsMapLayerType.VectorLayer, QgsMapLayerType.RasterLayer, QgsMapLayerType.MeshLayer, QgsMapLayerType.VectorTileLayer]:
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion([region, region2, region3], rc, t)
self.assertTrue(should_clip)
geom = QgsGeometry.fromQPolygonF(path.toFillPolygon())
geom.normalize()
self.assertEqual(geom.asWkt(1), 'Polygon ((0 0, 0 1, 0.1 1, 0.1 0, 0 0))')
rc.setMapToPixel(QgsMapToPixel(5, 10, 11, 200, 150, 0))
for t in [QgsMapLayerType.VectorLayer, QgsMapLayerType.RasterLayer, QgsMapLayerType.MeshLayer, QgsMapLayerType.VectorTileLayer]:
path, should_clip = QgsMapClippingUtils.calculatePainterClipRegion([region, region3], rc, t)
self.assertTrue(should_clip)
self.assertEqual(QgsGeometry.fromQPolygonF(path.toFillPolygon()).asWkt(0), 'Polygon ((98 77, 98 77, 98 77, 98 77, 98 77))')
def identify(self, params):
self.check_required_params(params)
feature_collections = []
with change_directory(self.project_root):
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(params.get('srs'))
search_box = self._calcSearchBox(
params.get('bbox'), params.get('image_size')[0],
params.get('image_size')[1],
params.get('click_point')[0], params.get('click_point')[1]
)
# initialize mapRenderer and a rendering context in order to be
# to check if a feature will actually be rendered
# we don't want to return features that are not visible
img = QImage(QSize(
settings.SUNLUMO_GFI_BUFFER*2, settings.SUNLUMO_GFI_BUFFER*2),
QImage.Format_ARGB32_Premultiplied
)
dpm = 1 / 0.00028
img.setDotsPerMeterX(dpm)
img.setDotsPerMeterY(dpm)
mapRenderer = QgsMapRenderer()
mapRenderer.clearLayerCoordinateTransforms()
mapRenderer.setOutputSize(QSize(
settings.SUNLUMO_GFI_BUFFER*2, settings.SUNLUMO_GFI_BUFFER*2),
img.logicalDpiX()
)
mapRenderer.setDestinationCrs(crs)
mapRenderer.setProjectionsEnabled(True)
mapUnits = crs.mapUnits()
mapRenderer.setMapUnits(mapUnits)
mapExtent = QgsRectangle(*search_box)
mapRenderer.setExtent(mapExtent)
renderContext = QgsRenderContext()
renderContext.setExtent(mapRenderer.extent())
renderContext.setRasterScaleFactor(1.0)
renderContext.setMapToPixel(mapRenderer.coordinateTransform())
renderContext.setRendererScale(mapRenderer.scale())
renderContext.setScaleFactor(mapRenderer.outputDpi() / 25.4)
renderContext.setPainter(None)
qfr = QgsFeatureRequest()
search_rectangle = QgsRectangle(*search_box)
qfr.setFilterRect(search_rectangle)
for q_layer in params.get('query_layers'):
layer = self.layerRegistry.mapLayer(q_layer)
if layer.type() == QgsMapLayer.RasterLayer:
# skip raster layer processing
continue
# update layer fields (expressions, calculated, joined)
layer.updateFields()
scaleCalc = QgsScaleCalculator(
(img.logicalDpiX() + img.logicalDpiY()) / 2,
mapRenderer.destinationCrs().mapUnits()
)
scaleDenom = scaleCalc.calculate(mapExtent, img.width())
# skip the layer if it's not visible at the current map scale
if layer.hasScaleBasedVisibility():
if not(layer.minimumScale()
< scaleDenom < layer.maximumScale()):
continue
# check if features actually intersect search rectangle
intersected_features = self._intersectedFeatures(
layer.getFeatures(qfr), search_rectangle
)
# visible features generator
visible_features = self._visibleFeatures(
layer, renderContext, intersected_features
)
layer_features = [featureToGeoJSON(
feature.id(), feature.geometry(),
self._collectAttributes(layer, feature)
) for feature in visible_features
]
feature_collections.append(layer_features)
return writeGeoJSON(chain(*feature_collections))
