[GIS] Error writing memory layer to shapefile in QGIS

memory-layerpyqgispythonqgis-plugins

I have created a memory polygon layer in my QGIS plugin. Then I added a buffer based on a point. I can see the ploygon memory layer in the map canvas and I can save it to a shapefile from the main GUI. But when I try to save it with the following code, it doesn't work. What am I doing wrong?

(please forgive my beginner-style coding)

uri = "Polygon?field=id:integer&index=yes&crs=27700"
self.polyLayer = QgsVectorLayer(uri, "Study area", "memory")
self.provider = self.polyLayer.dataProvider()
QgsMapLayerRegistry.instance().addMapLayer(self.polyLayer)

# create buffer feature
featurepoly = QgsFeature()
featurepoly.setGeometry(QgsGeometry.fromPoint(QgsPoint(self.point.x(),self.point.y())).buffer(200,1000, 1, 1, 1.0))
self.polyLayer.startEditing()
self.polyLayer.addFeature(featurepoly, True)
self.polyLayer.commitChanges()

# getting the new buffered memory layer
poly = self.iface.activeLayer()

prov = poly.dataProvider()
fields = prov.fields()

dir_poly = self.plugin_dir + '/data/poly_temp.shp'
writer = QgsVectorFileWriter(dir_poly, "CP1250", fields, prov.geometryType(),
                                     prov.crs(), "ESRI shapefile")
if writer.hasError() != QgsVectorFileWriter.NoError:
            self.iface.messageBar().pushMessage("Error when creating shapefile: ", str(writer.hasError()))

geometry = poly.geometry()
feature = QgsFeature()
feature.setGeometry(geometry)
writer.addFeature(feature)
del writer

Best Answer

You may need to have this at the top of your code:

from PyQt4.QtCore import *

Or it might be the path you are giving it:

http://docs.qgis.org/testing/en/docs/pyqgis_developer_cookbook/vector.html

that documentation just has a file name, you could give it a path instead and then it works.

Related Solutions

[GIS] Creating new empty memory layer with fields scheme from other layer in QGIS

Here's some quick-and-dirty Python code that works on a simple shapefile layer:

# Get the currently selected layer
inLayer = iface.activeLayer()

# Get its list of fields
inFields = inLayer.dataProvider().fields()

# Convert its geometry type enum to a string we can pass to
# QgsVectorLayer's constructor
inLayerGeometryType = ['Point','Line','Polygon'][inLayer.geometryType()]

# Convert its CRS to a string we can pass to QgsVectorLayer's constructor
inLayerCRS = inLayer.crs().authid()

# Make the output layer
outLayer = QgsVectorLayer(inLayerGeometryType + '?crs='+inLayerCRS, \
    inLayer.name() + u'_copy', \
    'memory')

# Copy the fields from the old layer into the new layer
outLayer.startEditing()
outLayer.dataProvider().addAttributes(inFields.toList())
outLayer.commitChanges()

# Add it to the map
QgsMapLayerRegistry.instance().addMapLayer(outLayer)

I load up a simple shape file, select that layer in the Layers box, paste the above code into the Python console, and a new layer appears with the same attributes.

The key parts here (I'm guessing from your question) are the lines that get the list of fields from the input layer (inLayer.dataProvider().fields(), documented here) and add those same fields to the output layer (outLayer.dataProvider().addAttributes(inFields.toList()), documented here)

qgis – Using Memory Layer for Processing Algorithms in QGIS 3

As Germán noted, you should use "memory:" as the output string. But you'll also need to store the algorithm results, or the memory layer will be garbage collected by python!

results = processing.run('grass7:v.net',
            {"input":inputLayer,
             ...
            "output": 'memory:'})
result_layer = results['output']

But more generally - it's a bit inefficient to use a memory layer here. Because you're calling a grass algorithm (not a native QGIS one), all the outputs and inputs are being converted to disk based formats for use by grass, and all outputs from grass are also disk-based (behind the scenes these are shapefiles in a temporary directory). So when you ask for a memory layer output, QGIS has to read over the shapefile created by grass and convert that to a QGIS memory layer. So in this case, it's actually more efficient to just give the algorithm a path to save the shapefile and then read that directly.

Related Question