def render_layers(layer_paths):
"""
:param layer_paths: A list of layer paths.
:return: Buffer containing output. Note caller is responsible for closing
the buffer with buffer.close()
:rtype: QBuffer
"""
layers = []
extent = None
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(3857)
for layer_path in layer_paths:
map_layer = QgsVectorLayer(layer_path, None, 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(map_layer)
transform = QgsCoordinateTransform(map_layer.crs(), crs)
print map_layer.extent().toString()
layer_extent = transform.transform(map_layer.extent())
if extent is None:
extent = layer_extent
else:
extent.combineExtentWith(layer_extent)
print extent.toString()
# set layer set
layers.append(map_layer.id()) # add ID of every layer
map_settings = QgsMapSettings()
map_settings.setDestinationCrs(crs)
map_settings.setCrsTransformEnabled(True)
map_settings.setExtent(extent)
map_settings.setOutputSize(QSize(1000, 1000))
map_settings.setLayers(layers)
# job = QgsMapRendererParallelJob(settings)
job = QgsMapRendererSequentialJob(map_settings)
job.start()
job.waitForFinished()
image = job.renderedImage()
# Save teh image to a buffer
map_buffer = QBuffer()
map_buffer.open(QIODevice.ReadWrite)
image.save(map_buffer, "PNG")
image.save('/tmp/test.png', 'png')
# clean up
QgsMapLayerRegistry.instance().removeAllMapLayers()
return map_buffer
def test_render_via_job_with_transform(self):
"""
Test rendering an annotation layer via a map render job
"""
layer = QgsAnnotationLayer('test', QgsAnnotationLayer.LayerOptions(QgsProject.instance().transformContext()))
self.assertTrue(layer.isValid())
item = QgsAnnotationPolygonItem(
QgsPolygon(QgsLineString([QgsPoint(11.5, 13), QgsPoint(12, 13), QgsPoint(12, 13.5), QgsPoint(11.5, 13)])))
item.setSymbol(
QgsFillSymbol.createSimple({'color': '200,100,100', 'outline_color': 'black', 'outline_width': '2'}))
item.setZIndex(1)
i1_id = layer.addItem(item)
item = QgsAnnotationLineItem(QgsLineString([QgsPoint(11, 13), QgsPoint(12, 13), QgsPoint(12, 15)]))
item.setSymbol(QgsLineSymbol.createSimple({'color': '#ffff00', 'line_width': '3'}))
item.setZIndex(2)
i2_id = layer.addItem(item)
item = QgsAnnotationMarkerItem(QgsPoint(12, 13))
item.setSymbol(QgsMarkerSymbol.createSimple({'color': '100,200,200', 'size': '6', 'outline_color': 'black'}))
item.setZIndex(3)
i3_id = layer.addItem(item)
layer.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
settings = QgsMapSettings()
settings.setDestinationCrs(QgsCoordinateReferenceSystem('EPSG:3857'))
settings.setExtent(QgsRectangle(1250958, 1386945, 1420709, 1532518))
settings.setOutputSize(QSize(200, 200))
settings.setLayers([layer])
job = QgsMapRendererSequentialJob(settings)
job.start()
job.waitForFinished()
# check rendered item results
item_results = job.takeRenderedItemResults()
item_details = item_results.renderedItems()
self.assertEqual(len(item_details), 3)
self.assertEqual([i.layerId() for i in item_details], [layer.id()] * 3)
self.assertCountEqual([i.itemId() for i in item_details], [i1_id, i2_id, i3_id])
# bounds should be in map crs
self.assertEqual(
[QgsGeometry.fromRect(i.boundingBox()).asWkt(0) for i in item_details if i.itemId() == i1_id][0],
'Polygon ((1280174 1459732, 1335834 1459732, 1335834 1516914, 1280174 1516914, 1280174 1459732))')
self.assertEqual(
[QgsGeometry.fromRect(i.boundingBox()).asWkt(0) for i in item_details if i.itemId() == i2_id][0],
'Polygon ((1224514 1459732, 1335834 1459732, 1335834 1689200, 1224514 1689200, 1224514 1459732))')
expected = 'Polygon ((1325786 1449684, 1345882 1449684, 1345882 1469780, 1325786 1469780, 1325786 1449684))'
result = [QgsGeometry.fromRect(i.boundingBox()).asWkt(0) for i in item_details if i.itemId() == i3_id][0]
self.assertTrue(compareWkt(result, expected, tol=1000), "mismatch Expected:\n{}\nGot:\n{}\n".format(expected,
result))
def saveTIFF(box, name, path):
options = QgsMapSettings()
layers = QgsProject.instance().mapLayers().values()
options.setLayers(layers)
options.setBackgroundColor(QColor(255, 255, 255))
options.setOutputSize(QSize(5000, 5000))
options.setExtent(box)
render = QgsMapRendererSequentialJob(options)
render.start()
render.waitForFinished()
img = render.renderedImage()
img.save(os.path.join(path, name + ".tif"), "tif")
def pngs(file):
image_name = pathlib.Path(file).name.split('.')[0]
#add vectorlayers
qgis_init()
project = QgsProject.instance()
# project_name = PATH+'/'+image_name+'.qgz'
# project.write(project_name)
rlayer = QgsRasterLayer(file, image_name)
# QgsProject.instance().addMapLayer(rlayer, False)
project.addMapLayer(rlayer, False)
# project.write(project_name)
layer = project.mapLayersByName(image_name)[0]
settings = QgsMapSettings()
settings.setLayers([layer])
settings.setBackgroundColor(QColor(255, 255, 255))
# max_height = vres
width = rlayer.width()
height = rlayer.height()
# if height < max_height:
# new_height=2048
# new_width = round(width*new_height/height)
# else:
new_height = vres
new_width = int(width * new_height / height)
# new_width = (layer.width()/res)
# new_height = int(layer.height()/res)
settings.setOutputSize(QSize(new_width, new_height))
settings.setExtent(layer.extent())
render = QgsMapRendererSequentialJob(settings)
def finished():
img = render.renderedImage()
# save the image; e.g. img.save("/Users/myuser/render.png","png")
name = PATH + '/PNGs/' + image_name + '_print.png'
img.save(name, "png")
render.finished.connect(finished)
render.start()
render.waitForFinished()
# print('rendering: ', image_name)
# print(QgsProject.instance().mapLayers())
project.clear()
def export_frames(self, width=1920, height=1080):
first_frame = self.dockwidget.horizontalSlider_frames.minimum()
last_frame = self.dockwidget.horizontalSlider_frames.maximum()
#print(u'Rendering frames: %s-%s' % (first_frame, last_frame))
frame_width = self.dockwidget.spinBox_frame_width.value()
frame_height = self.dockwidget.spinBox_frame_height.value()
settings = QgsMapSettings()
settings.setDestinationCrs(
QgsCoordinateReferenceSystem(
self.iface.mapCanvas().mapSettings().destinationCrs()))
settings.setOutputSize(QSize(frame_width, frame_height))
settings.setLayers(self.iface.mapCanvas().layers())
settings.setExtent(self.data_zoom_extent)
job = QgsMapRendererSequentialJob(settings)
progress = QProgressBar()
progress.setMaximum(last_frame)
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar = self.iface.messageBar().createMessage(
u'Rendering frames')
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar,
Qgis.Info,
duration=2)
self.clear_output_dir()
for frame_id in range(first_frame, last_frame + 1):
self.dockwidget.horizontalSlider_frames.setValue(frame_id)
self.update_slider()
job.start()
job.waitForFinished()
img = job.renderedImage()
try:
frame_code = self.frame_time.toString('yyyyMMdd_hhmm')
except:
frame_code = frame_id
base_name = u'frame_{0}.png'.format(frame_code)
filename = os.path.join(self.output_dir, base_name)
self.log(filename)
img.save(filename)
progress.setValue(frame_id)
def savePng(self, box, name, path, size=1024):
options = QgsMapSettings()
# layers = QgsProject.instance().mapLayers().values()
layers = [iface.activeLayer()]
options.setDestinationCrs(
QgsCoordinateReferenceSystem(self.export_epsg))
options.setLayers(layers)
options.setBackgroundColor(QColor(255, 255, 255))
options.setOutputSize(QSize(size, size))
options.setExtent(box)
# options.setFlag(options.Antialiasing, True)
render = QgsMapRendererSequentialJob(options)
render.start()
render.waitForFinished()
img = render.renderedImage()
img.save(path + "/" + name + ".png", "png")
def sampling(pLayer, rLayer):
nameFile = "mapsampel_" #nazwa rastra wynikowego
type = "png" #format pliku rastra wynikowego
where_ = folderoutput #ścieżka do folderu w którym mają się zapisać rastry
player = pLayer #warstwa wektorowa - punkty
rlayer = rLayer #warstwa rastrowa - input
registry = QgsProject.instance()
#Zablokowane / zakomentowane wyświetlanie warstw
'''
registry.addMapLayer(rlayer)
registry.addMapLayer(player)
'''
registry.mapLayers().keys()
#rozmiar obszaru
xs = rlayer.rasterUnitsPerPixelX() * size / 2
ys = rlayer.rasterUnitsPerPixelY() * size / 2
options = QgsMapSettings()
options.setLayers([rlayer])
options.setOutputSize(QSize(xs, ys))
points = player.getFeatures()
for i, point in enumerate(points):
pt = point.geometry().asPoint()
ext = QgsRectangle(pt[0] - xs, pt[1] - ys, pt[0] + xs,
pt[1] + ys)
options.setExtent(ext) #3
render = QgsMapRendererSequentialJob(options)
render.start()
render.waitForFinished()
name = "{}\{}_{}.{}".format(where_, nameFile, str(i), type)
img = render.renderedImage()
img.save(name, type)
