def testCreateLayerMultiPoint(self):
layer = QgsVectorLayer("MultiPoint?crs=epsg:3111&field=id:integer&field=fldtxt:string&field=fldint:integer",
"addfeat", "memory")
pr = layer.dataProvider()
f = QgsFeature()
f.setAttributes([1, "test", 1])
f.setGeometry(QgsGeometry.fromWkt('MultiPoint(1 2, 3 4)'))
f2 = QgsFeature()
f2.setAttributes([2, "test2", 3])
f3 = QgsFeature()
f3.setAttributes([3, "test2", NULL])
f3.setGeometry(QgsGeometry.fromWkt('MultiPoint(7 8)'))
pr.addFeatures([f, f2, f3])
uri = '{} table="qgis_test"."new_table_multipoint" sql='.format(self.dbconn)
error, message = QgsVectorLayerExporter.exportLayer(layer, uri, 'mssql', QgsCoordinateReferenceSystem('EPSG:3111'))
self.assertEqual(error, QgsVectorLayerExporter.NoError)
new_layer = QgsVectorLayer(uri, 'new', 'mssql')
self.assertTrue(new_layer.isValid())
self.assertEqual(new_layer.wkbType(), QgsWkbTypes.MultiPoint)
self.assertEqual(new_layer.crs().authid(), 'EPSG:3111')
self.assertEqual([f.name() for f in new_layer.fields()], ['qgs_fid', 'id', 'fldtxt', 'fldint'])
features = [f.attributes() for f in new_layer.getFeatures()]
self.assertEqual(features, [[1, 1, 'test', 1],
[2, 2, 'test2', 3],
[3, 3, 'test2', NULL]])
geom = [f.geometry().asWkt() for f in new_layer.getFeatures()]
self.assertEqual(geom, ['MultiPoint ((1 2),(3 4))', '', 'MultiPoint ((7 8))'])
def test_create_layer(self):
"""Test create layer work"""
# Lines
line_layer = QgsVectorLayer(
self.line_before + '.shp', 'test', 'ogr')
new_layer = create_layer(line_layer)
self.assertEquals(new_layer.geometryType(), line_layer.geometryType())
self.assertEquals(new_layer.crs(), line_layer.crs())
fields = line_layer.dataProvider().fields()
new_fields = new_layer.dataProvider().fields()
self.assertEquals(new_fields.toList(), fields.toList())
# Polygon
polygon_layer = QgsVectorLayer(
self.polygon_base + '.shp', 'test', 'ogr')
new_layer = create_layer(polygon_layer)
self.assertEquals(
new_layer.geometryType(),
polygon_layer.geometryType()
)
self.assertEquals(new_layer.crs(), polygon_layer.crs())
fields = polygon_layer.dataProvider().fields()
new_fields = new_layer.dataProvider().fields()
self.assertEquals(new_fields.toList(), fields.toList())
def testExportLayerToExistingDatabase(self):
fields = QgsFields()
fields.append(QgsField('f1', QVariant.Int))
tmpfile = os.path.join(self.basetestpath, 'testCreateNewGeopackage.gpkg')
options = {}
options['update'] = True
options['driverName'] = 'GPKG'
options['layerName'] = 'table1'
exporter = QgsVectorLayerExporter(tmpfile, "ogr", fields, QgsWkbTypes.Polygon, QgsCoordinateReferenceSystem(3111), False, options)
self.assertFalse(exporter.errorCode(),
'unexpected export error {}: {}'.format(exporter.errorCode(), exporter.errorMessage()))
options['layerName'] = 'table2'
exporter = QgsVectorLayerExporter(tmpfile, "ogr", fields, QgsWkbTypes.Point, QgsCoordinateReferenceSystem(3113), False, options)
self.assertFalse(exporter.errorCode(),
'unexpected export error {} : {}'.format(exporter.errorCode(), exporter.errorMessage()))
del exporter
# make sure layers exist
lyr = QgsVectorLayer('{}|layername=table1'.format(tmpfile), "lyr1", "ogr")
self.assertTrue(lyr.isValid())
self.assertEqual(lyr.crs().authid(), 'EPSG:3111')
self.assertEqual(lyr.wkbType(), QgsWkbTypes.Polygon)
lyr2 = QgsVectorLayer('{}|layername=table2'.format(tmpfile), "lyr2", "ogr")
self.assertTrue(lyr2.isValid())
self.assertEqual(lyr2.crs().authid(), 'EPSG:3113')
self.assertEqual(lyr2.wkbType(), QgsWkbTypes.Point)
def testSimulatedDBManagerImport(self):
uri = 'point?field=f1:int'
uri += '&field=f2:double(6,4)'
uri += '&field=f3:string(20)'
lyr = QgsVectorLayer(uri, "x", "memory")
self.assertTrue(lyr.isValid())
f = QgsFeature(lyr.fields())
f['f1'] = 1
f['f2'] = 123.456
f['f3'] = '12345678.90123456789'
f2 = QgsFeature(lyr.fields())
f2['f1'] = 2
lyr.dataProvider().addFeatures([f, f2])
tmpfile = os.path.join(self.basetestpath, 'testSimulatedDBManagerImport.gpkg')
ds = ogr.GetDriverByName('GPKG').CreateDataSource(tmpfile)
ds = None
options = {}
options['update'] = True
options['driverName'] = 'GPKG'
options['layerName'] = 'my_out_table'
err = QgsVectorLayerExporter.exportLayer(lyr, tmpfile, "ogr", lyr.crs(), False, options)
self.assertEqual(err[0], QgsVectorLayerExporter.NoError,
'unexpected import error {0}'.format(err))
lyr = QgsVectorLayer(tmpfile + "|layername=my_out_table", "y", "ogr")
self.assertTrue(lyr.isValid())
features = lyr.getFeatures()
f = next(features)
self.assertEqual(f['f1'], 1)
self.assertEqual(f['f2'], 123.456)
self.assertEqual(f['f3'], '12345678.90123456789')
f = next(features)
self.assertEqual(f['f1'], 2)
features = None
# Test overwriting without overwrite option
err = QgsVectorLayerExporter.exportLayer(lyr, tmpfile, "ogr", lyr.crs(), False, options)
self.assertEqual(err[0], QgsVectorLayerExporter.ErrCreateDataSource)
# Test overwriting
lyr = QgsVectorLayer(uri, "x", "memory")
self.assertTrue(lyr.isValid())
f = QgsFeature(lyr.fields())
f['f1'] = 3
lyr.dataProvider().addFeatures([f])
options['overwrite'] = True
err = QgsVectorLayerExporter.exportLayer(lyr, tmpfile, "ogr", lyr.crs(), False, options)
self.assertEqual(err[0], QgsVectorLayerExporter.NoError,
'unexpected import error {0}'.format(err))
lyr = QgsVectorLayer(tmpfile + "|layername=my_out_table", "y", "ogr")
self.assertTrue(lyr.isValid())
features = lyr.getFeatures()
f = next(features)
self.assertEqual(f['f1'], 3)
features = None
def create_grid(size):
"""Create a polygonal grid using Processing.
:param size: The cell size.
:type size: int
:return: The grid layer in memory.
:rtype: QgsVectorLayer
"""
output_filename = unique_filename(prefix='grid', suffix='.shp')
result = processing.runalg(
'qgis:vectorgrid',
'336199.970553,352338.397991,7636164.67975,7648562.41208',
size, # X spacing
size, # Y spacing
0, # Output as polygons
output_filename)
layer = QgsVectorLayer(output_filename, 'grid', 'ogr')
layer.setCrs(QgsCoordinateReferenceSystem(32740))
remove_fields(layer, ['xmin', 'xmax', 'ymin', 'ymax'])
# Make a copy in memory
memory = create_memory_layer(
'grid', layer.geometryType(), layer.crs(), layer.fields())
copy_layer(layer, memory)
print "NB cells : %s" % layer.featureCount()
return memory
def convert_geojson_to_shapefile(geojson_path):
"""Convert geojson file to shapefile.
It will create a necessary file next to the geojson file. It will not
affect another files (e.g. .xml, .qml, etc).
:param geojson_path: The path to geojson file.
:type geojson_path: basestring
:returns: True if shapefile layer created, False otherwise.
:rtype: bool
"""
layer = QgsVectorLayer(geojson_path, 'vector layer', 'ogr')
if not layer.isValid():
return False
# Construct shapefile path
shapefile_path = os.path.splitext(geojson_path)[0] + '.shp'
QgsVectorFileWriter.writeAsVectorFormat(
layer,
shapefile_path,
'utf-8',
layer.crs(),
'ESRI Shapefile')
if os.path.exists(shapefile_path):
return True
return False
def testWriteWithBinaryField(self):
"""
Test writing with a binary field
:return:
"""
basetestpath = tempfile.mkdtemp()
tmpfile = os.path.join(basetestpath, 'binaryfield.sqlite')
ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint, options=['FID=fid'])
lyr.CreateField(ogr.FieldDefn('strfield', ogr.OFTString))
lyr.CreateField(ogr.FieldDefn('intfield', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('binfield', ogr.OFTBinary))
lyr.CreateField(ogr.FieldDefn('binfield2', ogr.OFTBinary))
f = None
ds = None
vl = QgsVectorLayer(tmpfile)
self.assertTrue(vl.isValid())
# check that 1 of its fields is a bool
fields = vl.fields()
self.assertEqual(fields.at(fields.indexFromName('binfield')).type(), QVariant.ByteArray)
dp = vl.dataProvider()
f = QgsFeature(fields)
bin_1 = b'xxx'
bin_2 = b'yyy'
bin_val1 = QByteArray(bin_1)
bin_val2 = QByteArray(bin_2)
f.setAttributes([1, 'str', 100, bin_val1, bin_val2])
self.assertTrue(dp.addFeature(f))
# write a gpkg package with a binary field
filename = os.path.join(str(QDir.tempPath()), 'with_bin_field')
rc, errmsg = QgsVectorFileWriter.writeAsVectorFormat(vl,
filename,
'utf-8',
vl.crs(),
'GPKG')
self.assertEqual(rc, QgsVectorFileWriter.NoError)
# open the resulting geopackage
vl = QgsVectorLayer(filename + '.gpkg', '', 'ogr')
self.assertTrue(vl.isValid())
fields = vl.fields()
# test type of converted field
idx = fields.indexFromName('binfield')
self.assertEqual(fields.at(idx).type(), QVariant.ByteArray)
idx2 = fields.indexFromName('binfield2')
self.assertEqual(fields.at(idx2).type(), QVariant.ByteArray)
# test values
self.assertEqual(vl.getFeature(1).attributes()[idx], bin_val1)
self.assertEqual(vl.getFeature(1).attributes()[idx2], bin_val2)
del vl
os.unlink(filename + '.gpkg')
def processAlgorithm(self, feedback):
layers = self.getParameterValue(self.INPUT_DATASOURCES)
query = self.getParameterValue(self.INPUT_QUERY)
uid_field = self.getParameterValue(self.INPUT_UID_FIELD)
geometry_field = self.getParameterValue(self.INPUT_GEOMETRY_FIELD)
geometry_type = self.getParameterValue(self.INPUT_GEOMETRY_TYPE)
geometry_crs = self.getParameterValue(self.INPUT_GEOMETRY_CRS)
df = QgsVirtualLayerDefinition()
layerIdx = 1
if layers:
for layerSource in layers.split(';'):
layer = dataobjects.getObjectFromUri(layerSource)
if layer:
df.addSource('input{}'.format(layerIdx), layer.id())
layerIdx += 1
if query == '':
raise GeoAlgorithmExecutionException(
self.tr('Empty SQL. Please enter valid SQL expression and try again.'))
else:
df.setQuery(query)
if uid_field:
df.setUid(uid_field)
if geometry_type == 1: # no geometry
df.setGeometryWkbType(QgsWkbTypes.NullGeometry)
else:
if geometry_field:
df.setGeometryField(geometry_field)
if geometry_type > 1:
df.setGeometryWkbType(geometry_type - 1)
if geometry_crs:
crs = QgsCoordinateReferenceSystem(geometry_crs)
if crs.isValid():
df.setGeometrySrid(crs.postgisSrid())
vLayer = QgsVectorLayer(df.toString(), "temp_vlayer", "virtual")
if not vLayer.isValid():
raise GeoAlgorithmExecutionException(vLayer.dataProvider().error().message())
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
vLayer.fields().toList(),
# Create a point layer (without any points) if 'no geometry' is chosen
vLayer.wkbType() if geometry_type != 1 else 1,
vLayer.crs())
features = vector.features(vLayer)
total = 100.0 / len(features)
outFeat = QgsFeature()
for current, inFeat in enumerate(features):
outFeat.setAttributes(inFeat.attributes())
if geometry_type != 1:
outFeat.setGeometry(inFeat.geometry())
writer.addFeature(outFeat)
feedback.setProgress(int(current * total))
del writer
def load(fileName, name=None, crs=None, style=None):
"""Loads a layer/table into the current project, given its file.
"""
if fileName is None:
return
prjSetting = None
settings = QSettings()
if crs is not None:
prjSetting = settings.value('/Projections/defaultBehaviour')
settings.setValue('/Projections/defaultBehaviour', '')
if name is None:
name = os.path.split(fileName)[1]
qgslayer = QgsVectorLayer(fileName, name, 'ogr')
if qgslayer.isValid():
if crs is not None and qgslayer.crs() is None:
qgslayer.setCrs(crs, False)
if style is None:
if qgslayer.geometryType() == QGis.Point:
style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_POINT_STYLE)
elif qgslayer.geometryType() == QGis.Line:
style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_LINE_STYLE)
else:
style = ProcessingConfig.getSetting(ProcessingConfig.VECTOR_POLYGON_STYLE)
qgslayer.loadNamedStyle(style)
QgsMapLayerRegistry.instance().addMapLayers([qgslayer])
else:
qgslayer = QgsRasterLayer(fileName, name)
if qgslayer.isValid():
if crs is not None and qgslayer.crs() is None:
qgslayer.setCrs(crs, False)
if style is None:
style = ProcessingConfig.getSetting(ProcessingConfig.RASTER_STYLE)
qgslayer.loadNamedStyle(style)
QgsMapLayerRegistry.instance().addMapLayers([qgslayer])
iface.legendInterface().refreshLayerSymbology(qgslayer)
else:
if prjSetting:
settings.setValue('/Projections/defaultBehaviour', prjSetting)
raise RuntimeError('Could not load layer: ' + unicode(fileName)
+ '\nCheck the procesing framework log to look for errors')
if prjSetting:
settings.setValue('/Projections/defaultBehaviour', prjSetting)
return qgslayer
def testGeoPackage(self):
'''Test GeoPackage'''
layer = QgsVectorLayer(os.path.join(os.path.dirname(__file__), "data","airports.gpkg"),
"test", "ogr")
self.assertTrue(layer.isValid())
filepath = os.path.join(tempfile.mkdtemp(), str(time.time()) + ".gpkg")
QgsVectorFileWriter.writeAsVectorFormat(layer, filepath, 'utf-8', layer.crs(), 'GPKG')
layer = QgsVectorLayer(filepath, "test", "ogr")
self.assertTrue(layer.isValid())
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(table, schema=None):
self.execSQLCommand('DROP TABLE IF EXISTS %s CASCADE' % table)
uri = 'point?field=f1:int'
uri += '&field=F2:double(6,4)'
uri += '&field=f3:string(20)'
lyr = QgsVectorLayer(uri, "x", "memory")
self.assertTrue(lyr.isValid())
table = ("%s" % table) if schema is None else ("\"%s\".\"%s\"" % (schema, table))
dest_uri = "%s sslmode=disable table=%s (geom) sql" % (self.dbconn, table)
err = QgsVectorLayerExporter.exportLayer(lyr, dest_uri, "postgres", lyr.crs())
olyr = QgsVectorLayer(dest_uri, "y", "postgres")
self.assertTrue(olyr.isValid(), "Failed URI: %s" % dest_uri)
def test_raster_to_vector_and_line_intersection(self):
"""Test the core part of the analysis.
1. Test creation of spatial index of flood cells
2. Test intersection of flood cells with roads layer
"""
raster_name = standard_data_path(
'hazard',
'tsunami_wgs84.tif')
exposure_name = standard_data_path(
'exposure',
'roads_osm_4326.shp')
raster = QgsRasterLayer(raster_name, 'Flood')
exposure = QgsVectorLayer(exposure_name, 'Exposure', 'ogr')
ranges = OrderedDict()
ranges[0] = [0, 1]
ranges[1] = [1, 2]
ranges[2] = [2, 100]
index, flood_cells_map = _raster_to_vector_cells(
raster, ranges, exposure.crs())
self.assertEqual(len(flood_cells_map), 4198)
rect_with_all_cells = raster.extent()
rect_with_4_cells = QgsRectangle(106.824, -6.177, 106.825, -6.179)
rect_with_0_cells = QgsRectangle(106.818, -6.168, 106.828, -6.175)
self.assertEqual(len(index.intersects(rect_with_all_cells)), 4198)
self.assertEqual(len(index.intersects(rect_with_4_cells)), 43)
self.assertEqual(len(index.intersects(rect_with_0_cells)), 504)
layer = create_layer(exposure)
new_field = QgsField('flooded', QVariant.Int)
layer.dataProvider().addAttributes([new_field])
request = QgsFeatureRequest()
_intersect_lines_with_vector_cells(
exposure, request, index, flood_cells_map, layer, 'flooded')
feature_count = layer.featureCount()
self.assertEqual(feature_count, 388)
flooded = 0
iterator = layer.getFeatures()
for feature in iterator:
attributes = feature.attributes()
if attributes[3] == 1:
flooded += 1
self.assertEqual(flooded, 40)
def processAlgorithm(self, progress):
self.progress = progress
self.progress.setPercentage(0)
file_path = self.getParameterValue(self.FILE)
# Creating the dict for columns
white_list_values = {}
for layer in self.LAYERS:
value = self.getParameterValue(self.WHITE_LIST[layer])
# Delete space and tabs in OSM keys
# Processing return a 'None' value as unicode
value = re.sub('\s', '', value)
if value == '' or value == 'None':
value = None
if value:
if value != ',':
white_list_values[layer] = value.split(',')
else:
white_list_values[layer] = ','
else:
white_list_values[layer] = None
# Call the OSM Parser and connect signals
parser = OsmParser(file_path, self.LAYERS, white_list_values)
parser.signalText.connect(self.set_info)
parser.signalPercentage.connect(self.set_percentage)
# Start to parse
layers = parser.parse()
layers_outputs = {}
for key, values in layers.iteritems():
layer = QgsVectorLayer(values['geojsonFile'], "test", "ogr")
output_parameter = self.getOutputValue(self.OUTPUT_LAYERS[key])
layers_outputs[key] = QgsVectorFileWriter(
output_parameter,
'UTF-8',
layer.pendingFields(),
values['geomType'],
layer.crs())
for feature in layer.getFeatures():
layers_outputs[key].addFeature(feature)
def storyDescriptionLinkClicked(self, url):
url = url.toString()
if url == "search":
dlg = SearchDialog()
dlg.exec_()
if dlg.mapstory is not None:
story = Story.storyFromNumberId(dlg.mapstory)
if story is None:
QMessageBox.warning(iface.mainWindow(), "MapStory", "Cannot get MapStory data.\nCheck that the provided ID is correct.")
else:
self.updateCurrentStory(story)
elif url == "download":
outDir = QFileDialog.getExistingDirectory(self,
self.tr("Select output directory"),
"."
)
if not outDir:
return
QDir().mkpath(outDir)
settings = QSettings()
systemEncoding = settings.value('/UI/encoding', 'System')
startProgressBar(len(self.story.storyLayers()), "Download layers for off-line use:")
for i, layer in enumerate(self.story.storyLayers()):
filename = os.path.join(outDir, layer.name() + ".shp")
uri = "%s?srsname=%s&typename=geonode:%s&version=1.0.0&request=GetFeature&service=WFS" % (layer.wfsUrl(), layer.crs(), layer.name())
qgslayer = QgsVectorLayer(uri, layer.name(), "WFS")
writer = QgsVectorFileWriter(filename, systemEncoding,
qgslayer.pendingFields(),
qgslayer.dataProvider().geometryType(),
qgslayer.crs())
for feat in qgslayer.getFeatures():
writer.addFeature(feat)
del writer
fieldname = self._getTimeField(qgslayer)
if fieldname is not None:
filename = os.path.join(outDir, layer.name() + ".timefield")
with open(filename, "w") as f:
f.write(fieldname)
setProgress(i+1)
closeProgressBar()
iface.messageBar().pushMessage("MapStory", "Layers have been correctly saved as QGIS project.", level=QgsMessageBar.INFO, duration=3)
def __init__(self, uri='', providerOptions=QgsDataProvider.ProviderOptions()):
super().__init__(uri)
# Use the memory layer to parse the uri
mlayer = QgsVectorLayer(uri, 'ml', 'memory')
self.setNativeTypes(mlayer.dataProvider().nativeTypes())
self._uri = uri
self._fields = mlayer.fields()
self._wkbType = mlayer.wkbType()
self._features = {}
self._extent = QgsRectangle()
self._extent.setMinimal()
self._subset_string = ''
self._crs = mlayer.crs()
self._spatialindex = None
self._provider_options = providerOptions
if 'index=yes'in self._uri:
self.createSpatialIndex()
def test_datadefined_margin(self):
polygonLayer = QgsVectorLayer('Polygon?field=margin:int', 'test_polygon', 'memory')
poly = QgsFeature(polygonLayer.fields())
poly.setAttributes([0])
poly.setGeometry(QgsGeometry.fromWkt('Polygon((30 30, 40 30, 40 40, 30 40, 30 30))'))
polygonLayer.dataProvider().addFeatures([poly])
poly = QgsFeature(polygonLayer.fields())
poly.setAttributes([10])
poly.setGeometry(QgsGeometry.fromWkt('Polygon((10 10, 20 10, 20 20, 10 20, 10 10))'))
polygonLayer.dataProvider().addFeatures([poly])
poly = QgsFeature(polygonLayer.fields())
poly.setAttributes([20])
poly.setGeometry(QgsGeometry.fromWkt('Polygon((50 50, 60 50, 60 60, 50 60, 50 50))'))
polygonLayer.dataProvider().addFeatures([poly])
QgsProject.instance().addMapLayer(polygonLayer)
layout = QgsPrintLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
map.setCrs(polygonLayer.crs())
map.attemptSetSceneRect(QRectF(20, 20, 130, 130))
map.setFrameEnabled(True)
map.setLayers([polygonLayer])
map.setExtent(QgsRectangle(0, 0, 100, 50))
layout.addLayoutItem(map)
atlas = layout.atlas()
atlas.setCoverageLayer(polygonLayer)
atlas.setEnabled(True)
map.setAtlasDriven(True)
map.setAtlasScalingMode(QgsLayoutItemMap.Auto)
map.setAtlasMargin(77.0)
map.dataDefinedProperties().setProperty(QgsLayoutObject.MapAtlasMargin, QgsProperty.fromExpression('margin/2'))
atlas.beginRender()
atlas.first()
self.assertEqual(map.extent(), QgsRectangle(25, 30, 45, 40))
self.assertTrue(atlas.next())
self.assertEqual(map.extent(), QgsRectangle(4.5, 9.75, 25.5, 20.25))
self.assertTrue(atlas.next())
self.assertEqual(map.extent(), QgsRectangle(44, 49.5, 66, 60.5))
QgsProject.instance().removeMapLayer(polygonLayer)
def test_datadefined_margin(self):
polygonLayer = QgsVectorLayer('Polygon?field=margin:int', 'test_polygon', 'memory')
poly = QgsFeature(polygonLayer.fields())
poly.setAttributes([0])
poly.setGeometry(QgsGeometry.fromWkt('Polygon((30 30, 40 30, 40 40, 30 40, 30 30))'))
polygonLayer.dataProvider().addFeatures([poly])
poly = QgsFeature(polygonLayer.fields())
poly.setAttributes([10])
poly.setGeometry(QgsGeometry.fromWkt('Polygon((10 10, 20 10, 20 20, 10 20, 10 10))'))
polygonLayer.dataProvider().addFeatures([poly])
poly = QgsFeature(polygonLayer.fields())
poly.setAttributes([20])
poly.setGeometry(QgsGeometry.fromWkt('Polygon((50 50, 60 50, 60 60, 50 60, 50 50))'))
polygonLayer.dataProvider().addFeatures([poly])
QgsProject.instance().addMapLayer(polygonLayer)
layout = QgsPrintLayout(QgsProject.instance())
map = QgsLayoutItemMap(layout)
map.setCrs(polygonLayer.crs())
map.attemptSetSceneRect(QRectF(20, 20, 130, 130))
map.setFrameEnabled(True)
map.setLayers([polygonLayer])
map.setExtent(QgsRectangle(0, 0, 100, 50))
layout.addLayoutItem(map)
atlas = layout.atlas()
atlas.setCoverageLayer(polygonLayer)
atlas.setEnabled(True)
map.setAtlasDriven(True)
map.setAtlasScalingMode(QgsLayoutItemMap.Auto)
map.setAtlasMargin(77.0)
map.dataDefinedProperties().setProperty(QgsLayoutObject.MapAtlasMargin, QgsProperty.fromExpression('margin/2'))
atlas.beginRender()
atlas.first()
self.assertEqual(map.extent(), QgsRectangle(25, 30, 45, 40))
self.assertTrue(atlas.next())
self.assertEqual(map.extent(), QgsRectangle(4.5, 9.75, 25.5, 20.25))
self.assertTrue(atlas.next())
self.assertEqual(map.extent(), QgsRectangle(44, 49.5, 66, 60.5))
QgsProject.instance().removeMapLayer(polygonLayer)
def initialise_fdp(dxf_file):
""" Initialisation d'un fond de plan
:param dxf_file: Le fichier dxf
:type dxf_file: str
"""
create_dir(get_project_path(), 'FDP/SHP')
copy_file(dxf_file[0], join(get_project_path(), 'FDP'), None)
if get_group().findGroup(PROJECT_GROUP[1]) is None :
get_group().addGroup(PROJECT_GROUP[1])
shp_path = join(get_project_path(),'FDP/SHP',basename(dxf_file[0].replace('dxf', 'shp')))
dxf_info = "|layername=entities|geometrytype=LineString"
layer_name = basename(dxf_file[0]).split('.')[0]
dxf_vl = QgsVectorLayer(dxf_file[0]+dxf_info, layer_name, "ogr")
if save_as_shp(dxf_vl, shp_path, dxf_vl.crs()):
layer = QgsVectorLayer(shp_path, layer_name)
layer.setCrs(QgsProject.instance().crs())
add_layer_in_group(layer, get_group().findGroup(PROJECT_GROUP[1]), 0, None)
categorized_layer(layer, 'Layer')
def runScript(self):
if len(self.dlg.scriptList.selectedItems()) > 0:
scriptPath = self.dlg.scriptList.selectedItems()[0].scriptPath
else:
self.messageBar.pushMessage("Erreur",
unicode("Aucun script sélectionné: ",
"utf-8"),
level=QgsMessageBar.CRITICAL)
return
if scriptPath != '':
# p = subprocess.Popen([self.fmeExePath, scriptPath, "--stdout"], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
err = subprocess.call([self.fmeExePath, scriptPath],
stdin=None,
stdout=None,
stderr=None,
shell=False)
print err
# [out, err] = p.communicate()
if not err:
self.messageBar.pushMessage("OK",
unicode("Le script a bien fonctionné",
"utf-8"),
level=QgsMessageBar.INFO)
outputDir = self.dlg.scriptList.selectedItems()[0].outputDir
if outputDir:
i = 0
for f in os.listdir(outputDir):
extension = f[-4:]
if extension == '.shp':
out = outputDir + "/" + f
layer = QgsVectorLayer(out, "result_" + str(i), "ogr")
crs = layer.crs()
crs.createFromId(2056)
layer.setCrs(crs)
QgsMapLayerRegistry.instance().addMapLayer(layer)
else:
self.messageBar.pushMessage("Erreur",
str(err),
level=QgsMessageBar.CRITICAL)
def processAlgorithm(self, progress):
self.progress = progress
self.progress.setPercentage(0)
file_path = self.getParameterValue(self.FILE)
# Creating the dict for columns
white_list_values = {}
for layer in self.LAYERS:
value = self.getParameterValue(self.WHITE_LIST[layer])
# Delete space and tabs in OSM keys
# Processing return a 'None' value as unicode
value = re.sub('\s', '', value)
if value == '' or value == 'None':
value = None
if value:
if value != ',':
white_list_values[layer] = value.split(',')
else:
white_list_values[layer] = ','
else:
white_list_values[layer] = None
# Call the OSM Parser and connect signals
parser = OsmParser(file_path, self.LAYERS, white_list_values)
parser.signalText.connect(self.set_info)
parser.signalPercentage.connect(self.set_percentage)
# Start to parse
layers = parser.parse()
layers_outputs = {}
for key, values in layers.items():
layer = QgsVectorLayer(values['geojsonFile'], "test", "ogr")
output_parameter = self.getOutputFromName(self.OUTPUT_LAYERS[key])
layers_outputs[key] = output_parameter.getVectorWriter(
layer.fields(), values['geomType'], layer.crs())
for feature in layer.getFeatures():
layers_outputs[key].addFeature(feature)
def __init__(self,
uri='',
providerOptions=QgsDataProvider.ProviderOptions()):
super().__init__(uri)
# Use the memory layer to parse the uri
mlayer = QgsVectorLayer(uri, 'ml', 'memory')
self.setNativeTypes(mlayer.dataProvider().nativeTypes())
self._uri = uri
self._fields = mlayer.fields()
self._wkbType = mlayer.wkbType()
self._features = {}
self._extent = QgsRectangle()
self._extent.setMinimal()
self._subset_string = ''
self._crs = mlayer.crs()
self._spatialindex = None
self._provider_options = providerOptions
if 'index=yes' in self._uri:
self.createSpatialIndex()
def test_raster_to_vector_and_line_intersection(self):
"""Test the core part of the analysis.
1. Test creation of spatial index of flood cells
2. Test intersection of flood cells with roads layer
"""
raster_name = standard_data_path('hazard', 'jakarta_flood_design.tif')
exposure_name = standard_data_path('exposure', 'roads_osm_4326.shp')
raster = QgsRasterLayer(raster_name, 'Flood')
exposure = QgsVectorLayer(exposure_name, 'Exposure', 'ogr')
index, flood_cells_map = _raster_to_vector_cells(
raster, 0.1, 1e10, exposure.crs())
self.assertEqual(len(flood_cells_map), 221)
rect_with_all_cells = raster.extent()
rect_with_4_cells = QgsRectangle(106.824, -6.177, 106.825, -6.179)
rect_with_0_cells = QgsRectangle(106.818, -6.168, 106.828, -6.175)
self.assertEqual(len(index.intersects(rect_with_all_cells)), 221)
self.assertEqual(len(index.intersects(rect_with_4_cells)), 4)
self.assertEqual(len(index.intersects(rect_with_0_cells)), 0)
layer = create_layer(exposure)
new_field = QgsField('flooded', QVariant.Int)
layer.dataProvider().addAttributes([new_field])
request = QgsFeatureRequest()
_intersect_lines_with_vector_cells(exposure, request, index,
flood_cells_map, layer, 'flooded')
feature_count = layer.featureCount()
self.assertEqual(feature_count, 184)
flooded = 0
iterator = layer.getFeatures()
for feature in iterator:
attributes = feature.attributes()
if attributes[3] == 1:
flooded += 1
self.assertEqual(flooded, 25)
def testCurveGeometries(self):
geomtypes = ['CompoundCurveM', 'CurvePolygonM', 'CircularStringM', 'CompoundCurveZM', 'CurvePolygonZM', 'CircularStringZM', 'CompoundCurveZ', 'CurvePolygonZ', 'CircularStringZ', 'CompoundCurve', 'CurvePolygon', 'CircularString']
geoms = ['CompoundCurveM ((0 -23.43778 10, 0 23.43778 10),CircularStringM (0 23.43778 10, -45 33.43778 10, -90 23.43778 10),(-90 23.43778 10, -90 -23.43778 10),CircularStringM (-90 -23.43778 10, -45 -23.43778 10, 0 -23.43778 10))', 'CurvePolygonM (CompoundCurveM ((0 -23.43778 10, 0 -15.43778 10, 0 23.43778 10),CircularStringM (0 23.43778 10, -45 100 10, -90 23.43778 10),(-90 23.43778 10, -90 -23.43778 10),CircularStringM (-90 -23.43778 10, -45 -16.43778 10, 0 -23.43778 10)),CompoundCurveM (CircularStringM (-30 0 10, -48 -12 10, -60 0 10, -48 -6 10, -30 0 10)))', 'CircularStringM (0 0 10, 0.14644660940672 0.35355339059327 10, 0.5 0.5 10, 0.85355339059327 0.35355339059327 10, 1 0 10, 0.85355339059327 -0.35355339059327 10, 0.5 -0.5 10, 0.14644660940672 -0.35355339059327 10, 0 0 10)', 'CompoundCurveZM ((0 -23.43778 2 10, 0 23.43778 2 10),CircularStringZM (0 23.43778 2 10, -45 33.43778 2 10, -90 23.43778 2 10),(-90 23.43778 2 10, -90 -23.43778 2 10),CircularStringZM (-90 -23.43778 2 10, -45 -23.43778 2 10, 0 -23.43778 2 10))', 'CurvePolygonZM (CompoundCurveZM ((0 -23.43778 5 10, 0 -15.43778 8 10, 0 23.43778 6 10),CircularStringZM (0 23.43778 6 10, -45 100 6 10, -90 23.43778 6 10),(-90 23.43778 6 10, -90 -23.43778 5 10),CircularStringZM (-90 -23.43778 5 10, -45 -16.43778 5 10, 0 -23.43778 5 10)),CompoundCurveZM (CircularStringZM (-30 0 10 10, -48 -12 10 10, -60 0 10 10, -48 -6 10 10, -30 0 10 10)))', 'CircularStringZM (0 0 1 10, 0.14644660940672 0.35355339059327 1 10, 0.5 0.5 1 10, 0.85355339059327 0.35355339059327 1 10, 1 0 1 10, 0.85355339059327 -0.35355339059327 1 10, 0.5 -0.5 1 10, 0.14644660940672 -0.35355339059327 1 10, 0 0 1 10)', 'CompoundCurveZ ((0 -23.43778 2, 0 23.43778 2),CircularStringZ (0 23.43778 2, -45 33.43778 2, -90 23.43778 2),(-90 23.43778 2, -90 -23.43778 2),CircularStringZ (-90 -23.43778 2, -45 -23.43778 2, 0 -23.43778 2))', 'CurvePolygonZ (CompoundCurveZ ((0 -23.43778 5, 0 -15.43778 8, 0 23.43778 6),CircularStringZ (0 23.43778 6, -45 100 6, -90 23.43778 6),(-90 23.43778 6, -90 -23.43778 5),CircularStringZ (-90 -23.43778 5, -45 -16.43778 5, 0 -23.43778 5)),CompoundCurveZ (CircularStringZ (-30 0 10, -48 -12 10, -60 0 10, -48 -6 10, -30 0 10)))', 'CircularStringZ (0 0 1, 0.14644660940672 0.35355339059327 1, 0.5 0.5 1, 0.85355339059327 0.35355339059327 1, 1 0 1, 0.85355339059327 -0.35355339059327 1, 0.5 -0.5 1, 0.14644660940672 -0.35355339059327 1, 0 0 1)', 'CompoundCurve ((0 -23.43778, 0 23.43778),CircularString (0 23.43778, -45 33.43778, -90 23.43778),(-90 23.43778, -90 -23.43778),CircularString (-90 -23.43778, -45 -23.43778, 0 -23.43778))', 'CurvePolygon (CompoundCurve ((0 -23.43778, 0 -15.43778, 0 23.43778),CircularString (0 23.43778, -45 100, -90 23.43778),(-90 23.43778, -90 -23.43778),CircularString (-90 -23.43778, -45 -16.43778, 0 -23.43778)),CompoundCurve (CircularString (-30 0, -48 -12, -60 0, -48 -6, -30 0)))', 'CircularString (0 0, 0.14644660940672 0.35355339059327, 0.5 0.5, 0.85355339059327 0.35355339059327, 1 0, 0.85355339059327 -0.35355339059327, 0.5 -0.5, 0.14644660940672 -0.35355339059327, 0 0)']
for idx, t in enumerate(geoms):
f = QgsFeature()
g = QgsGeometry.fromWkt(t)
f.setGeometry(g)
layer = QgsVectorLayer(geomtypes[idx] + "?crs=epsg:4326", "addfeat", "memory")
pr = layer.dataProvider()
pr.addFeatures([f])
uri = self.dbconn + ' table="qgis_test"."new_table_curvegeom_' + str(idx) + '" sql='
error, message = QgsVectorLayerExporter.exportLayer(layer, uri, 'mssql', QgsCoordinateReferenceSystem('EPSG:4326'))
self.assertEqual(error, QgsVectorLayerExporter.NoError)
new_layer = QgsVectorLayer(uri, 'new', 'mssql')
self.assertTrue(new_layer.isValid())
self.assertEqual(new_layer.wkbType(), g.wkbType())
self.assertEqual(new_layer.crs().authid(), 'EPSG:4326')
result_geoms = [f.geometry().asWkt(14) for f in new_layer.getFeatures()]
self.assertEqual(result_geoms, [t])
self.execSQLCommand('DROP TABLE IF EXISTS [qgis_test].[new_table_curvegeom_{}]'.format(str(idx)))
def calculate(resolution_input, layer_input):
layer_path = layer_input.filePath()
splitext = path.splitext(layer_path)
layer_file_name = splitext[0]
layer_file_extension = splitext[1]
parent_dir = path.dirname(layer_file_name)
layer_file_name = path.basename(layer_file_name)
layer = QgsVectorLayer(layer_path, "original", "ogr")
result_path = path.join(
parent_dir,
layer_file_name + "_removed_small_polygons" + layer_file_extension)
QgsVectorFileWriter.writeAsVectorFormat(layer, result_path, "utf-8",
layer.crs(), "ESRI Shapefile")
new_layer = QgsVectorLayer(result_path, "removed small polygons", "ogr")
data_provider = new_layer.dataProvider()
data_provider.truncate()
source_crs = layer.sourceCrs()
dest_crs = QgsCoordinateReferenceSystem("EPSG:3857")
if not layer.isValid():
raise Exception("Layer failed to load!")
min_meters = 0.0000001225 # 0.35mm x 0.35mm on map
limit = min_meters * (float(resolution_input.text())**2)
features = layer.getFeatures()
# features_to_add = []
for feature in features:
geom = feature.geometry()
tr = QgsCoordinateTransform(source_crs, dest_crs,
QgsProject.instance())
geom.transform(tr)
area = geom.area()
# print(limit)
# print(area)
if area >= limit:
# features_to_add.append(feature)
added = data_provider.addFeature(feature)
# print(added)
# print(feature)
# new_layer.addFeatures(features_to_add)
return True
def getFeatureWithMultiGeomFromSpatialite(self, filmNumber, geomType,
source):
uri = QgsDataSourceUri()
uri.setDatabase(self.dbm.db.databaseName())
uri.setDataSource(
'', 'luftbild_{0}_cp'.format(
self.filmsDict[filmNumber]['orientation']), 'geometry')
sourceLayer = QgsVectorLayer(uri.uri(),
'kartierung {0} p'.format(filmNumber),
'spatialite')
sourceLayer.setSubsetString(u'"filmnummer" = "{0}"'.format(filmNumber))
sourceCrs = sourceLayer.crs()
targetCrs = QgsCoordinateReferenceSystem(
4326, QgsCoordinateReferenceSystem.EpsgCrsId)
coordinateTransform = QgsCoordinateTransform(sourceCrs, targetCrs,
QgsProject.instance())
if sourceLayer.hasFeatures():
targetMultiGeom = QgsGeometry()
sortedFeatures = sorted(sourceLayer.getFeatures(),
key=lambda f: f['bildnummer_nn'])
pointList = []
for feature in sortedFeatures:
sourceSingleGeom = feature.geometry()
sourceSingleGeom.transform(coordinateTransform)
point = sourceSingleGeom.asPoint()
pointList.append(point)
targetMultiGeom.addPointsXY([point], geomType)
if geomType == QgsWkbTypes.geometryType(
QgsWkbTypes.MultiLineString):
targetMultiGeom = QgsGeometry.fromPolylineXY(pointList)
feature = QgsFeature()
feature.setGeometry(targetMultiGeom)
feature.setAttributes([filmNumber, source] +
self.getAttributesForFilm(filmNumber))
return feature
else:
return None
def _aggregate(self, myImpactLayer, myExpectedResults):
myAggregationLayer = QgsVectorLayer(
os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'),
'test aggregation',
'ogr')
# create a copy of aggregation layer
myGeoExtent = extent_to_geo_array(
myAggregationLayer.extent(),
myAggregationLayer.crs())
myAggrAttribute = self.keywordIO.read_keywords(
myAggregationLayer, self.defaults['AGGR_ATTR_KEY'])
# noinspection PyArgumentEqualDefault
myAggregationLayer = clip_layer(
layer=myAggregationLayer,
extent=myGeoExtent,
explode_flag=True,
explode_attribute=myAggrAttribute)
myAggregator = Aggregator(None, myAggregationLayer)
# setting up
myAggregator.isValid = True
myAggregator.layer = myAggregationLayer
myAggregator.safeLayer = safe_read_layer(
str(myAggregator.layer.source()))
myAggregator.aoiMode = False
myAggregator.aggregate(myImpactLayer)
myProvider = myAggregator.layer.dataProvider()
myProvider.select(myProvider.attributeIndexes())
myFeature = QgsFeature()
myResults = []
while myProvider.nextFeature(myFeature):
myFeatureResults = {}
myAtMap = myFeature.attributeMap()
for (k, attr) in myAtMap.iteritems():
myFeatureResults[k] = str(attr.toString())
myResults.append(myFeatureResults)
self.assertEqual(myExpectedResults, myResults)
def testNumericPrecision(self):
uri = "point?field=f1:int"
uri += "&field=f2:double(6,4)"
uri += "&field=f3:string(20)"
lyr = QgsVectorLayer(uri, "x", "memory")
self.assertTrue(lyr.isValid())
f = QgsFeature(lyr.fields())
f["f1"] = 1
f["f2"] = 123.456
f["f3"] = "12345678.90123456789"
lyr.dataProvider().addFeatures([f])
uri = '%s table="qgis_test"."b18155" (g) key=\'f1\'' % (self.dbconn)
self.execSQLCommand("DROP TABLE IF EXISTS qgis_test.b18155")
err = QgsVectorLayerImport.importLayer(lyr, uri, "postgres", lyr.crs())
self.assertEqual(err[0], QgsVectorLayerImport.NoError, "unexpected import error {0}".format(err))
lyr = QgsVectorLayer(uri, "y", "postgres")
self.assertTrue(lyr.isValid())
f = next(lyr.getFeatures())
self.assertEqual(f["f1"], 1)
self.assertEqual(f["f2"], 123.456)
self.assertEqual(f["f3"], "12345678.90123456789")
def get_bbox(table: Table) -> Tuple[Point, Point]:
'''
get the minimal bounding box covering all features in table
Parameters
----------
table : Table
table with features to be in bounding box
Returns
----------
tuple
upper left and lower right Points spanning the bounding box
'''
layer = QgsVectorLayer(f'{table.workspace.path}|layername={table.name}')
layer.dataProvider().updateExtents()
ex = layer.extent()
epsg = layer.crs().postgisSrid()
bbox = (Point(ex.xMinimum(), ex.yMinimum(),
epsg=epsg), Point(ex.xMaximum(), ex.yMaximum(), epsg=epsg))
return bbox
def layerFilterExpression(
self, layer: QgsVectorLayer) -> str: # noqa: ignore=N802
""" Returns an additional expression filter """
LOG.debug("layerFilterExpression %s %s", layer.name(),
layer.dataProvider().storageType())
if self.ogcserver is None:
parameters = self.serverInterface().requestHandler().parameterMap()
LOG.warning(
"Call on uninitialized plugin, map: %s",
os.environ.get("QGIS_PROJECT_FILE", parameters.get("MAP")),
)
return "FALSE"
try:
if layer.dataProvider().storageType() in self.SUBSETSTRING_TYPE:
LOG.debug("layerFilterExpression not in type")
return None
session = self.DBSession()
try:
access, area = self.get_area(layer, session)
finally:
session.close()
if access is Access.FULL:
LOG.debug("layerFilterExpression no area")
return None
if access is Access.NO:
LOG.debug("layerFilterExpression not allowed")
return "0"
result = "intersects($geometry, transform(geom_from_wkt('{}'), 'EPSG:{}', '{}'))".format(
area.wkt, self.srid,
layer.crs().authid())
LOG.debug("layerFilterExpression filter: %s", result)
return result
except Exception:
LOG.error("Cannot run layerFilterExpression", exc_info=True)
raise
def sample_layer(self):
source_layer = QgsVectorLayer(
os.path.join(self.plugin_dir, "data", "Austria_PopulationByNUTS2.gml"),
""
)
# (empty) memory layer
sample_layer = QgsVectorLayer(
QgsWkbTypes.geometryDisplayString(source_layer.geometryType())
+ "?crs=" + source_layer.crs().authid()
+ "&index=yes",
"Austria_Population_NUTS2_20170101",
"memory"
)
sample_layer_data_provider = sample_layer.dataProvider()
sample_layer_data_provider.addAttributes(source_layer.fields().toList())
sample_layer.updateFields()
sample_layer_data_provider.addFeatures(list(source_layer.getFeatures()))
sample_layer.loadNamedStyle(
os.path.join(self.plugin_dir, "data", "Austria_PopulationByNUTS2.qml")
)
sample_layer.setTitle("Austria: Population by NUTS2 regions, 1 Jan 2017")
sample_layer.setShortName("Austria_Population_NUTS2_20170101")
sample_layer.setAbstract(
"Austria’s population by NUTS2 region, as of 1 Jan 2017 \n"
+ "\n"
+ "Data sources: \n"
+ " http://ec.europa.eu/eurostat/web/gisco/geodata/"
+ "reference-data/administrative-units-statistical-units/"
+ "nuts#nuts13 \n"
+ " http://www.statistik.at/web_de/statistiken/"
+ "menschen_und_gesellschaft/bevoelkerung/"
+ "bevoelkerungsstand_und_veraenderung/"
+ "bevoelkerung_zu_jahres-_quartalsanfang/index.html"
)
return sample_layer
def testNumericPrecision(self):
uri = 'point?field=f1:int'
uri += '&field=f2:double(6,4)'
uri += '&field=f3:string(20)'
lyr = QgsVectorLayer(uri, "x", "memory")
self.assertTrue(lyr.isValid())
f = QgsFeature(lyr.fields())
f['f1'] = 1
f['f2'] = 123.456
f['f3'] = '12345678.90123456789'
lyr.dataProvider().addFeatures([f])
uri = '%s table="qgis_test"."b18155" (g) key=\'f1\'' % (self.dbconn)
self.execSQLCommand('DROP TABLE IF EXISTS qgis_test.b18155')
err = QgsVectorLayerImport.importLayer(lyr, uri, "postgres", lyr.crs())
self.assertEqual(err[0], QgsVectorLayerImport.NoError,
'unexpected import error {0}'.format(err))
lyr = QgsVectorLayer(uri, "y", "postgres")
self.assertTrue(lyr.isValid())
f = next(lyr.getFeatures())
self.assertEqual(f['f1'], 1)
self.assertEqual(f['f2'], 123.456)
self.assertEqual(f['f3'], '12345678.90123456789')
def testNumericPrecision(self):
uri = 'point?field=f1:int'
uri += '&field=f2:double(6,4)'
uri += '&field=f3:string(20)'
lyr = QgsVectorLayer(uri, "x", "memory")
self.assertTrue(lyr.isValid())
f = QgsFeature(lyr.fields())
f['f1'] = 1
f['f2'] = 123.456
f['f3'] = '12345678.90123456789'
lyr.dataProvider().addFeatures([f])
uri = '%s table="qgis_test"."b18155" (g) key=\'f1\'' % (self.dbconn)
self.execSQLCommand('DROP TABLE IF EXISTS qgis_test.b18155')
err = QgsVectorLayerExporter.exportLayer(lyr, uri, "postgres", lyr.crs())
self.assertEqual(err[0], QgsVectorLayerExporter.NoError,
'unexpected import error {0}'.format(err))
lyr = QgsVectorLayer(uri, "y", "postgres")
self.assertTrue(lyr.isValid())
f = next(lyr.getFeatures())
self.assertEqual(f['f1'], 1)
self.assertEqual(f['f2'], 123.456)
self.assertEqual(f['f3'], '12345678.90123456789')
def convert_geojson_to_shapefile(geojson_path):
"""Convert geojson file to shapefile.
It will create a necessary file next to the geojson file. It will not
affect another files (e.g. .xml, .qml, etc).
:param geojson_path: The path to geojson file.
:type geojson_path: basestring
:returns: True if shapefile layer created, False otherwise.
:rtype: bool
"""
layer = QgsVectorLayer(geojson_path, 'vector layer', 'ogr')
if not layer.isValid():
return False
# Construct shapefile path
shapefile_path = os.path.splitext(geojson_path)[0] + '.shp'
QgsVectorFileWriter.writeAsVectorFormat(layer, shapefile_path, 'utf-8',
layer.crs(), 'ESRI Shapefile')
if os.path.exists(shapefile_path):
return True
return False
def testWriteWithStringListField(self):
"""
Test writing with a string list field
:return:
"""
tmpfile = os.path.join(self.basetestpath, 'newstringlistfield.gml')
ds = ogr.GetDriverByName('GML').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint)
lyr.CreateField(ogr.FieldDefn('strfield', ogr.OFTString))
lyr.CreateField(ogr.FieldDefn('intfield', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('strlistfield', ogr.OFTStringList))
ds = None
vl = QgsVectorLayer(tmpfile)
self.assertTrue(vl.isValid())
# write a gml dataset with a string list field
filename = os.path.join(str(QDir.tempPath()), 'with_stringlist_field.gml')
rc, errmsg = QgsVectorFileWriter.writeAsVectorFormat(vl,
filename,
'utf-8',
vl.crs(),
'GML')
self.assertEqual(rc, QgsVectorFileWriter.NoError)
# open the resulting gml
vl = QgsVectorLayer(filename, '', 'ogr')
self.assertTrue(vl.isValid())
fields = vl.fields()
# test type of converted field
idx = fields.indexFromName('strlistfield')
self.assertEqual(fields.at(idx).type(), QVariant.List)
self.assertEqual(fields.at(idx).subType(), QVariant.String)
del vl
os.unlink(filename)
def testWriteWithStringListField(self):
"""
Test writing with a string list field
:return:
"""
tmpfile = os.path.join(self.basetestpath, 'newstringlistfield.gml')
ds = ogr.GetDriverByName('GML').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint)
lyr.CreateField(ogr.FieldDefn('strfield', ogr.OFTString))
lyr.CreateField(ogr.FieldDefn('intfield', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('strlistfield', ogr.OFTStringList))
ds = None
vl = QgsVectorLayer(tmpfile)
self.assertTrue(vl.isValid())
# write a gml dataset with a string list field
filename = os.path.join(str(QDir.tempPath()), 'with_stringlist_field.gml')
rc, errmsg = QgsVectorFileWriter.writeAsVectorFormat(vl,
filename,
'utf-8',
vl.crs(),
'GML')
self.assertEqual(rc, QgsVectorFileWriter.NoError)
# open the resulting gml
vl = QgsVectorLayer(filename, '', 'ogr')
self.assertTrue(vl.isValid())
fields = vl.fields()
# test type of converted field
idx = fields.indexFromName('strlistfield')
self.assertEqual(fields.at(idx).type(), QVariant.List)
self.assertEqual(fields.at(idx).subType(), QVariant.String)
del vl
os.unlink(filename)
def testSingleLines(self):
source = QgsVectorLayer(os.path.join(TEST_DATA_DIR, 'lines_touching.shp'))
self.assertTrue(source.isValid())
map_settings = QgsMapSettings()
map_settings.setExtent(source.extent().buffered(2))
map_settings.setDestinationCrs(source.crs())
map_settings.setLayers([source])
layer = QgsSimpleLineSymbolLayer()
layer.setColor(QColor(0, 0, 0))
layer.setWidth(1)
symbol = QgsLineSymbol([layer])
layer2 = QgsMarkerLineSymbolLayer()
layer2.setPlacement(QgsTemplatedLineSymbolLayerBase.FirstVertex)
marker = QgsMarkerSymbol.createSimple({'size': '4', 'color': '255,0,0', 'outline_style': 'no'})
layer2.setSubSymbol(marker)
symbol.appendSymbolLayer(layer2)
sub_renderer = QgsSingleSymbolRenderer(symbol)
source.setRenderer(QgsMergedFeatureRenderer(sub_renderer))
self.assertTrue(self.imageCheck('lines_single_subrenderer', 'lines_single_subrenderer', map_settings))
def drawPoints(self):
try:
self.defineParams()
except:
self.iface.messageBar().pushMessage(
self.name,
self.tr(u'Unknown error occurred'),
level=Qgis.Critical)
outlayer = QgsVectorLayer('Point?crs=EPSG:4326', 'tempGeocoderLayer',
'memory')
if self.dlg.saveChkb.isChecked():
dialog = QFileDialog()
saveFile = dialog.getSaveFileName(
None, self.tr('Save to...')) #returns tuple (path, extension)
fileName = '{}{}'.format(saveFile[0].split('.')[0], '.shp')
layerName = os.path.basename(fileName)[:-4]
QgsVectorFileWriter.writeAsVectorFormat(outlayer, fileName,
"utf-8", outlayer.crs(),
"ESRI Shapefile")
outlayer = QgsVectorLayer(fileName, layerName, 'ogr')
self.dlg.progressBar.setValue(0)
geocode = self.geocoder.geocode(outlayer)
def vector_to_gdf(cls,
qgis_vector_lyr: QgsVectorLayer) -> gpd.GeoDataFrame:
def _catch_null(attribute):
try:
if attribute.isNull():
return None
except AttributeError:
return attribute
feature_list = [[_catch_null(attr) for attr in feature.attributes()] +
[feature.geometry().asWkt()]
for feature in qgis_vector_lyr.getFeatures()]
columns = [field.name() for field in qgis_vector_lyr.fields()]
columns.append('geometry')
df = pd.DataFrame(feature_list, columns=columns)
df['geometry'] = df['geometry'].apply(wkt.loads)
if qgis_vector_lyr.wkbType() == 6: # if geometry is MultiPolygon
df['geometry'] = df['geometry'].apply(lambda x: x[0]
if len(x) == 1 else x)
return gpd.GeoDataFrame(df,
crs=qgis_vector_lyr.crs().toWkt(),
geometry='geometry')
def addTROlayers(self,jsonfile,epsg,layername,troformat):
lcheck = True
path_to_tro_layer = jsonfile
maplayerName = layername
uriLine = path_to_tro_layer + "|geometrytype=LineString"
uriPoint = path_to_tro_layer + "|geometrytype=Point"
uriPolygon = path_to_tro_layer + "|geometrytype=Polygon"
vlayer = QgsVectorLayer(path_to_tro_layer , maplayerName, "ogr")
vlayerPoint = QgsVectorLayer(uriPoint , maplayerName, "ogr")
vlayerLine = QgsVectorLayer(uriLine, maplayerName, "ogr")
vlayerPolygon = QgsVectorLayer(uriPolygon, maplayerName, "ogr")
point_style_file = os.path.join(self.plugin_dir,"style","{}_POINT.qml".format(troformat))
line_style_file = os.path.join(self.plugin_dir,"style","{}_LINESTRING.qml".format(troformat))
polygon_style_file = os.path.join(self.plugin_dir,"style","{}_POLYGON.qml".format(troformat))
vlayerPoint.loadNamedStyle(point_style_file)
vlayerLine.loadNamedStyle(line_style_file)
vlayerPolygon.loadNamedStyle(polygon_style_file)
if not vlayer.isValid():
print("Layer failed to load!")
lcheck = False
else:
#Add Layers to map
QgsProject.instance().addMapLayer(vlayerPoint)
QgsProject.instance().addMapLayer(vlayerLine)
QgsProject.instance().addMapLayer(vlayerPolygon)
crs = vlayer.crs()
crs.createFromId(int(epsg))
#Set projection of file from dialog
vlayerPoint.setCrs(crs)
vlayerLine.setCrs(crs)
vlayerPolygon.setCrs(crs)
return lcheck
def testWriterWithExtentAndReprojection(self):
"""Check writing using extent filter with reprojection."""
source_file = os.path.join(TEST_DATA_DIR, 'points.shp')
source_layer = QgsVectorLayer(source_file, 'Points', 'ogr')
self.assertTrue(source_layer.isValid())
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'ESRI Shapefile'
options.filterExtent = QgsRectangle(-12511460, 3045157, -10646621, 4683497)
options.ct = QgsCoordinateTransform(source_layer.crs(), QgsCoordinateReferenceSystem.fromEpsgId(3785), QgsProject.instance())
dest_file_name = os.path.join(str(QDir.tempPath()), 'extent_transform.shp')
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
source_layer,
dest_file_name,
options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message)
# Open result and check
created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name), 'test', 'ogr')
features = [f for f in created_layer.getFeatures()]
self.assertEqual(len(features), 5)
for f in features:
self.assertTrue(f.geometry().intersects(options.filterExtent))
def testWriterWithExtentAndReprojection(self):
"""Check writing using extent filter with reprojection."""
source_file = os.path.join(TEST_DATA_DIR, 'points.shp')
source_layer = QgsVectorLayer(source_file, 'Points', 'ogr')
self.assertTrue(source_layer.isValid())
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'ESRI Shapefile'
options.filterExtent = QgsRectangle(-12511460, 3045157, -10646621, 4683497)
options.ct = QgsCoordinateTransform(source_layer.crs(), QgsCoordinateReferenceSystem.fromEpsgId(3785), QgsProject.instance())
dest_file_name = os.path.join(str(QDir.tempPath()), 'extent_transform.shp')
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
source_layer,
dest_file_name,
options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message)
# Open result and check
created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name), 'test', 'ogr')
features = [f for f in created_layer.getFeatures()]
self.assertEqual(len(features), 5)
for f in features:
self.assertTrue(f.geometry().intersects(options.filterExtent))
def action_grid(self):
"""Perform whatever action the grid tab specified"""
# Find out if we need to create a new layer, or we're editing
# an existing one
if self.rbTemplate.isChecked():
# Find out if it's a vector layer, ignore type of geometry
layer_template = QgsVectorLayer(self.leTemplate.text(), 'Template',
'ogr')
if not layer_template.isValid():
QMessageBox.critical(self, "Error", "Couldn't load layer!")
return
# Read field map
fields = layer_template.fields()
# Creat a new memory layer with same crs.
layerOut = QgsVectorLayer(
"Point?crs={}".format(layer_template.crs().authid()),
"Inventory points", "memory")
pr = layerOut.dataProvider()
# Set fields
pr.addAttributes(fields)
# Tell the vector layer to fetch changes from the provider
layerOut.updateFields()
elif self.rbExisting.isChecked():
# Check if it's a point vector layer
# Is it already opened in QGIS?
QMessageBox.information(self, "Info", "Not implemented")
return
idName = self.findNameField(fields)
dateName = self.findDateField(fields)
# # # Find the feature we're putting a point in
# First, the layer
stand_layer_idx = self.cbLayer.currentIndex()
stand_layer_id = self.cbLayer.itemData(stand_layer_idx)
stand_layer = QgsMapLayerRegistry.instance().mapLayer(stand_layer_id)
# Then, the stand and geometry.
stand_layer_geometries = [
f.geometry() for f in stand_layer.selectedFeaturesIterator()
]
# Check for projections
geom_crs = stand_layer.crs()
if geom_crs.geographicFlag():
# This is not a projected layer. If layerOut
# isn't either, we will abort. Need a projected
# crs for calculating points etc.
if layerOut.crs().geographicFlag():
# Oops. Tell the customer
QMessageBox.critical(
self, "Error", "Neither input our output\
layer are projected. Change either layer crs to a projected\
crs")
return
# OK, stand_layer is geographic, but layerout is projected
# Transform all the geometries to layerOut
geom_crs = layerOut.crs()
xform = QgsCoordinateTransform(stand_layer.crs(), geom_crs)
# Modify in-place.
for i, g in enumerate(stand_layer_geometries):
g.transform(xform)
stand_layer_geometries[i] = g
if not len(stand_layer_geometries):
QMessageBox.critical(self, "Error!", "No stand selected!")
return
stand_layer_geom = stand_layer_geometries[0]
# Find out how many points we want to add
MIN_AREA = 10000
MAX_AREA = 50000
da = QgsDistanceArea()
da.setSourceCrs(geom_crs)
sqr_meters = da.measureArea(stand_layer_geom)
nr_of_points = self.interpolate_points_sqrt(
sqr_meters, MIN_AREA, int(self.sbMinPoint.value()), MAX_AREA,
int(self.sbMaxPoint.value()))
# print "Points:", nr_of_points
# Add a buffer to avoid the border. Use half of the minimum distance.
min_distance = 25
stand_layer_geom = stand_layer_geom.buffer(-min_distance / 2, 12)
# Distribute points
bb = stand_layer_geom.boundingBox()
nr_of_iter = nr_of_points * 200
points = []
for i in range(0, nr_of_iter):
p_x = random.uniform(bb.xMinimum(), bb.xMaximum())
p_y = random.uniform(bb.yMinimum(), bb.yMaximum())
p = QgsGeometry.fromPoint(QgsPoint(p_x, p_y))
if (stand_layer_geom.contains(p)
and self.checkDistance(points, p, min_distance)):
points.append(p)
nr_of_points = nr_of_points - 1
if not nr_of_points:
break
# Check if we managed to place enough points
if nr_of_points:
QMessageBox.information(
self, "Warning", "Couldn't add requested number of points. " +
"Please adjust number of points or minimum spacing, " +
"if more points are needed")
# Set feature xform
xform = QgsCoordinateTransform(geom_crs, layerOut.crs())
# Add points to layer and display layer
layerOut.startEditing()
layerOut.beginEditCommand("Adding points")
n = 0
for p in points:
# Transform to output layer crs
p.transform(xform)
fet = QgsFeature(fields)
fet.setGeometry(p)
if idName != '':
fet.setAttribute(idName, 'p{}'.format(n))
if dateName != '':
fet.setAttribute(dateName, datetime.date.today().isoformat())
if not layerOut.addFeatures([fet]):
QMessageBox.critical(self, "Error", "addFeatures()")
n = n + 1
layerOut.endEditCommand()
QgsMapLayerRegistry.instance().addMapLayer(layerOut)
def main():
tileStartX = -178 # lon min +1 (W,E) left
tileEndX = 178 # lon max +1 (W,E) right
tileStartY = 84 # lat max +1 (N,S) top
tileEndY = 53 # lat min +1 (N,S) bottom
targetBaseFolder = "/mnt/data/ArcticDEM"
rasterLayer = "/mnt/intel240/arcticdemv2.tif"
stepX = 1
stepY = 1
width = 360
height = 180
iterationsX = int(width / stepX)
iterationsY = int(height / stepY)
print("iterationsY " + str(iterationsY))
print("iterationsX " + str(iterationsX))
bufferX = 0.000416
bufferY = 0.000416
j = 0
i = 0
lat_str = "N"
lon_str = "E"
lat = 0
lon = 0
####### MAIN #######
for j in range(0, iterationsY):
for i in range(0, iterationsX):
y = str(-(j - tileStartY))
x = str(i + tileStartX)
if int(x) > tileEndX:
break
if int(y) < tileEndY:
break
if int(y) > 0:
lat_str = "N"
lat = str(int(y) - 1)
elif int(y) <= 0:
lat_str = "S"
lat = str(abs(int(y) - 1))
if int(x) >= 0:
lon_str = "E"
lon = x
elif int(x) < 0:
lon_str = "W"
lon = str(abs(int(x)))
if int(lat) < 10:
lat = "0" + lat
if int(lon) < 100 and int(lon) >= 10:
lon = "0" + lon
elif int(lon) < 10:
lon = "00" + lon
tileId = lat_str + lat + lon_str + lon
minX = (tileStartX + i * stepX) - bufferX
maxY = (tileStartY - j * stepY) + bufferY
maxX = (minX + stepX) + 2 * bufferX
minY = (maxY - stepY) - 2 * bufferY
print("Processing tile " + tileId)
# print(str(x) + " " + str(tileEndX))
# print(str(y) + " " + str(tileEndY))
time.sleep(0.1)
wkt = "POLYGON ((" + str(minX) + " " + str(maxY) + ", " + str(
maxX) + " " + str(maxY) + ", " + str(maxX) + " " + str(
minY) + ", " + str(minX) + " " + str(minY) + ", " + str(
minX) + " " + str(maxY) + "))"
tileLayer = QgsVectorLayer("Polygon?crs=epsg:4326", "tile",
"memory")
provider = tileLayer.dataProvider()
tileFeature = QgsFeature()
tileFeature.setGeometry(QgsGeometry.fromWkt(wkt))
provider.addFeatures([tileFeature])
QgsVectorFileWriter.writeAsVectorFormat(tileLayer,
targetBaseFolder +
"/tile.geojson",
"UTF-8",
tileLayer.crs(),
driverName="GeoJSON")
# crs = rasterLayer.crs()
# print (crs.toProj4())
#-ts 3602 3602
warpArgs = "-ot Int16 -q -multi -co COMPRESS=LZW -co PREDICTOR=2 -co ZLEVEL=6 -co NUM_THREADS=3 -t_srs 'EPSG:4326' -r cubicspline -crop_to_cutline -cutline " + targetBaseFolder + "/tile.geojson " + rasterLayer + " " + targetBaseFolder + "/tiles/" + tileId + ".tif"
if (not os.path.exists(targetBaseFolder + "/tiles/" + tileId +
".tif")):
os.environ["CPL_DEBUG"] = "OFF"
os.system("gdalwarp" + " " + warpArgs)
#remove the temporary tile
QgsProject.instance().removeMapLayers([tileLayer.id()])
def run(self):
self.mutex.lock()
self.stopMe = 0
self.mutex.unlock()
interrupted = False
# create attribute list with uniquie fields
# from all selected layers
mergedFields = []
self.emit(SIGNAL("rangeChanged( PyQt_PyObject )"), len(self.shapes))
self.emit(SIGNAL("checkStarted()"))
shapeIndex = 0
fieldMap = {}
for fileName in self.shapes:
layerPath = QFileInfo(self.baseDir + "/" + fileName).absoluteFilePath()
newLayer = QgsVectorLayer(layerPath, QFileInfo(layerPath).baseName(), "ogr")
if not newLayer.isValid():
continue
newLayer.setProviderEncoding(self.inputEncoding)
vprovider = newLayer.dataProvider()
fieldMap[shapeIndex] = {}
fieldIndex = 0
for layerField in vprovider.fields():
fieldFound = False
for mergedFieldIndex, mergedField in enumerate(mergedFields):
if mergedField.name() == layerField.name() and mergedField.type() == layerField.type():
fieldFound = True
fieldMap[shapeIndex][fieldIndex] = mergedFieldIndex
if mergedField.length() < layerField.length():
# suit the field size to the field of this layer
mergedField.setLength(layerField.length())
break
if not fieldFound:
fieldMap[shapeIndex][fieldIndex] = len(mergedFields)
mergedFields.append(layerField)
fieldIndex += 1
shapeIndex += 1
self.emit(SIGNAL("featureProcessed()"))
self.emit(SIGNAL("checkFinished()"))
# get information about shapefiles
layerPath = QFileInfo(self.baseDir + "/" + self.shapes[0]).absoluteFilePath()
newLayer = QgsVectorLayer(layerPath, QFileInfo(layerPath).baseName(), "ogr")
self.crs = newLayer.crs()
self.geom = newLayer.wkbType()
vprovider = newLayer.dataProvider()
fields = QgsFields()
for f in mergedFields:
fields.append(f)
writer = QgsVectorFileWriter(
self.outputFileName, self.outputEncoding,
fields, self.geom, self.crs)
shapeIndex = 0
for fileName in self.shapes:
layerPath = QFileInfo(self.baseDir + "/" + fileName).absoluteFilePath()
newLayer = QgsVectorLayer(layerPath, QFileInfo(layerPath).baseName(), "ogr")
if not newLayer.isValid():
continue
newLayer.setProviderEncoding(self.inputEncoding)
vprovider = newLayer.dataProvider()
nFeat = vprovider.featureCount()
self.emit(SIGNAL("rangeChanged( PyQt_PyObject )"), nFeat)
self.emit(SIGNAL("fileNameChanged( PyQt_PyObject )"), fileName)
inFeat = QgsFeature()
outFeat = QgsFeature()
inGeom = QgsGeometry()
fit = vprovider.getFeatures()
while fit.nextFeature(inFeat):
mergedAttrs = [""] * len(mergedFields)
# fill available attributes with values
fieldIndex = 0
for v in inFeat.attributes():
if shapeIndex in fieldMap and fieldIndex in fieldMap[shapeIndex]:
mergedAttrs[fieldMap[shapeIndex][fieldIndex]] = v
fieldIndex += 1
if inFeat.geometry() is not None:
inGeom = QgsGeometry(inFeat.geometry())
outFeat.setGeometry(inGeom)
outFeat.setAttributes(mergedAttrs)
writer.addFeature(outFeat)
self.emit(SIGNAL("featureProcessed()"))
self.emit(SIGNAL("shapeProcessed()"))
self.mutex.lock()
s = self.stopMe
self.mutex.unlock()
if s == 1:
interrupted = True
break
shapeIndex += 1
del writer
if not interrupted:
self.emit(SIGNAL("processingFinished()"))
else:
self.emit(SIGNAL("processingInterrupted()"))
def processAlgorithm(self, parameters, context, model_feedback):
"""
Here is where the processing itself takes place.
"""
results = {}
csvfile = self.parameterAsFile(parameters, self.INPUT, context)
if csvfile is None:
raise QgsProcessingException(self.tr('csv file error'))
#df = QgsVirtualLayerDefinition()
enc = self.parameterAsInt(parameters, 'ENCODING', context)
meshLayer = self.parameterAsVectorLayer(parameters, "meshlayer",
context)
if meshLayer is None:
raise QgsProcessingException(self.tr('mesh layer missed'))
meshidfields = self.parameterAsFields(parameters, 'meshid', context)
limit_sample = self.parameterAsInt(parameters, 'limit_sample', context)
maxdivide = self.parameterAsInt(parameters, 'maxdivide', context)
uneven_div = self.parameterAsInt(parameters, 'uneven_div', context)
popmeshLayer = self.parameterAsVectorLayer(parameters, "popmeshlayer",
context)
if popmeshLayer is None:
raise QgsProcessingException(self.tr('popmes layer missed'))
popmeshidfields = self.parameterAsFields(parameters, 'popmeshid',
context)
popmeshpopfields = self.parameterAsFields(parameters, 'popmeshpop',
context)
feedback = QgsProcessingMultiStepFeedback(9 + maxdivide,
model_feedback)
feedback.setCurrentStep(1)
if feedback.isCanceled():
return {}
# 住所別集計
alg_params = {
'addresslayer': parameters['addresslayer'],
'addressfield': parameters['addressfield'],
'INPUT': csvfile,
'ENCODING': enc,
'CRS': None,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT
}
#Stat_CSVAddressPolygon
outputs_statv = processing.run('QGIS_stat:Stat_CSVAddressPolygon',
alg_params,
context=context,
feedback=feedback,
is_child_algorithm=True)
if feedback.isCanceled():
return {}
statv = outputs_statv["OUTPUT"]
meshid = meshidfields[0]
# 人口メッシュと行政界メッシュのUnion作成する
new_popfield = 'pv'
param_uni = {
'addresslayer': statv,
'addressfield': parameters['addressfield'][0],
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT,
'popmeshlayer': popmeshLayer,
'popmeshid': popmeshidfields[0],
'popmeshpop': popmeshpopfields[0],
'POPCOLUMN': new_popfield
}
feedback.setCurrentStep(2)
res_uni = processing.run('QGIS_stat:UnionAdmAndPopMeshAlgorithm',
param_uni,
context=context,
feedback=feedback,
is_child_algorithm=True)
if feedback.isCanceled():
return {}
feedback.pushConsoleInfo("csvs 1 union ok ")
# union pop polygon res_unit["OUTPUT"]
# population pv
# address parameters['addressfield'][0]
# 行政界別人口の算出
feedback.setCurrentStep(3)
param_pop = {
'inputlayer': res_uni['OUTPUT'],
'agfield': parameters['addressfield'],
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT,
# 'OUTPUT':parameters['OUTPUT'],
'cfield': new_popfield
}
res_adpop = processing.run('QGIS_stat:AggreagteValueAlgorithm',
param_pop,
context=context,
feedback=feedback,
is_child_algorithm=True)
if feedback.isCanceled():
return {}
feedback.pushConsoleInfo("csvs 1 caliculate pop adm ok ")
# UNION mesh と 行政界別 人口の結合
feedback.setCurrentStep(4)
param_join = {
'DISCARD_NONMATCHING': False,
'FIELD': parameters['addressfield'],
'FIELDS_TO_COPY': [],
'FIELD_2': parameters['addressfield'],
'INPUT': res_uni['OUTPUT'],
'INPUT_2': res_adpop['OUTPUT'],
'METHOD': 1,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT,
#'OUTPUT':parameters['OUTPUT'],
'PREFIX': 'op'
}
res_join = processing.run('qgis:joinattributestable',
param_join,
context=context,
feedback=feedback,
is_child_algorithm=True)
if feedback.isCanceled():
return {}
feedback.pushConsoleInfo("csvs 1 join union mesh and popof adm ok ")
# UNION MESH 人口 と行政界人口の比率算出
feedback.setCurrentStep(5)
param_ratio = {
'FIELD_LENGTH': 12,
'FIELD_NAME': 'pvratio',
'FIELD_PRECISION': 6,
'FIELD_TYPE': 0,
'FORMULA': ' \"pv\" / \"oppv\" ',
'INPUT': res_join["OUTPUT"],
#'OUTPUT':parameters['OUTPUT']
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT,
}
res_ratio = processing.run('qgis:fieldcalculator',
param_ratio,
context=context,
feedback=feedback,
is_child_algorithm=True)
if feedback.isCanceled():
return {}
feedback.pushConsoleInfo(
"csvs 1 calc ratio of adm pop and union polygon population ok ")
# Union mesh の想定集計値を算出する 住所別集計値 × ( UNION MESH 人口 と行政界人口の比率算出)
feedback.setCurrentStep(6)
param_ratio2 = {
'FIELD_LENGTH': 12,
'FIELD_NAME': 'pvsum',
'FIELD_PRECISION': 6,
'FIELD_TYPE': 0,
'FORMULA': ' \"snum\" * \"pvratio\" ',
'INPUT': res_ratio["OUTPUT"],
#'OUTPUT':parameters['OUTPUT']
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT
}
res_ratio2 = processing.run('qgis:fieldcalculator',
param_ratio2,
context=context,
feedback=feedback,
is_child_algorithm=True)
if feedback.isCanceled():
return {}
feedback.pushConsoleInfo("csvs 1 calc ratio of research sample ok ")
#results["OUTPUT"] = res_ratio2["OUTPUT"]
#return results
# 入力メッシュとUnionメッシュのUnion
feedback.setCurrentStep(7)
#results["OUTPUT"] = res_ratio['OUTPUT']
#return results
# 入力UNIONメッシュの保存
# レイヤをGeoPackage化
cnv_paramsg = {
'LAYERS': res_ratio2["OUTPUT"],
'OVERWRITE': True,
'SAVE_STYLES': False,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT
#'OUTPUT':parameters['OUTPUT']
}
input_c = processing.run('native:package',
cnv_paramsg,
context=context,
feedback=feedback,
is_child_algorithm=True)
feedback.pushConsoleInfo("csvs 1 cahnge to geopackage ok ")
#results["OUTPUT"] = input_c["OUTPUT"]
#return results
# 集計用 人口+行政界 UNION
input_union = input_c["OUTPUT"]
feedback.setCurrentStep(8)
# create union poplation mesh and input mesh
param1 = {
'INPUT': input_union,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT,
'pareafield': 'div_area',
'polsmpl': 'pvsum',
'meshid': meshid,
'meshlayer': meshLayer
}
#parameters['OUTPUT']
#
res1 = processing.run('QGIS_stat:AggregatePopMeshbyMeshAlgorithm',
param1,
context=context,
feedback=feedback,
is_child_algorithm=True)
if feedback.isCanceled():
return {}
feedback.pushConsoleInfo(
"csvs 1 AggregatePopMeshbyMeshAlgorithm ok ")
numberof_under_limit = 0
#numberof_under_limit = res1["LIMITPOL"]
# レイヤをGeoPackage化
alg_paramsg = {
'LAYERS': res1["OUTPUT"],
'OVERWRITE': True,
'SAVE_STYLES': False,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT
}
retg1 = processing.run('native:package',
alg_paramsg,
context=context,
feedback=feedback,
is_child_algorithm=True)
last_output = retg1["OUTPUT"]
new_mesh = retg1["OUTPUT"]
mesh_layb = retg1["OUTPUT"]
if type(mesh_layb) is str:
mesh_layb = QgsVectorLayer(mesh_layb, "mesh", "ogr")
numberof_under_limit = 0
# 作業用レイヤの作成
crs_str = mesh_layb.crs()
layerURI = "Polygon?crs=" + crs_str.authid()
#feedback.pushConsoleInfo( "work layer " + layerURI )
resLayer = QgsVectorLayer(layerURI, "mesh_result", "memory")
appended = {}
adfields = []
for field in mesh_layb.fields():
#print(field.name(), field.typeName())
adfields.append(field)
#resLayer.addField(field)
resLayer.dataProvider().addAttributes(adfields)
resLayer.updateFields()
lower_ids = []
value_column = "snum"
# limit 値より小さい値のポリゴン数算出
for f in mesh_layb.getFeatures():
# feedback.pushConsoleInfo( "value " +str( f["value"]) )
if not f[value_column] is None:
if f[value_column] > 0 and f[value_column] < limit_sample:
numberof_under_limit += 1
lower_ids.append(f[meshid])
next_output = None
stepi = 9
# 集計結果が最小サンプルより小さいものがある場合
if numberof_under_limit > 0:
# 初回の場合は終了
feedback.pushConsoleInfo("最初の集計で指定値以下の集計値がありましたので集計を中止しました")
results["OUTPUT"] = None
return results
if uneven_div:
rmid = []
for tgid in (lower_ids):
feedback.pushConsoleInfo("lower id " + str(tgid))
# next_output code の下3桁 削除 C27210-02 -> C27210 が last_output の code 番号
# next_output では last_output が同じ番号の最大4メッシュを削除する
# リミットより小さいレコードは旧レコードを退避
# リミットにひっかかるレコードを再処理用リストから削除（同一親メッシュのものも削除）
# 不均等分割でリミット以下のデータがある場合は last_output -> 分割不能抽出 next_output 分割不能削除 next_output -> last_output 代入
parent_code = tgid[0:-3]
rmid.append(parent_code)
addfeatures = []
alg_paramsg_n = {
'LAYERS': last_output,
'OVERWRITE': False,
'SAVE_STYLES': False,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT
}
lmesh = processing.run('native:package',
alg_paramsg_n,
context=context,
feedback=feedback,
is_child_algorithm=True)
last_output = lmesh["OUTPUT"]
if type(last_output) is str:
last_output = QgsVectorLayer(last_output, "mesh", "ogr")
last_output.selectAll()
for lf in last_output.getFeatures():
for pcode in (rmid):
# feedback.pushConsoleInfo( "pcode " + pcode+ " meshid =" + lf[meshid] )
if lf[meshid] == pcode:
lf["fid"] = None
if not lf[value_column]:
lf[value_column] = 0.0
if lf[meshid] not in appended:
addfeatures.append(lf)
appended[lf[meshid]] = lf
# feedback.pushConsoleInfo( "add feature " + pcode )
resLayer.dataProvider().addFeatures(addfeatures)
deleteFeatures = []
if type(next_output) is str:
next_output = QgsVectorLayer(next_output, "mesh", "ogr")
# add check 20210310
if next_output is None:
feedback.pushConsoleInfo("no next array")
else:
for nf in next_output.getFeatures():
for pcode in (rmid):
if nf[meshid][0:-3] == pcode:
deleteFeatures.append(nf.id())
feedback.pushConsoleInfo("delete id " +
str(pcode))
next_output.dataProvider().deleteFeatures(deleteFeatures)
last_output = next_output
# 分割回数ループ
for divide_c in range(1, maxdivide):
feedback.setCurrentStep(stepi)
stepi = stepi + 1
if numberof_under_limit > 0:
# 均等分割の場合は終了
if not uneven_div:
break
if last_output is None:
feedback.pushConsoleInfo("last output is none")
else:
if type(last_output) is str:
feedback.pushConsoleInfo("last output " + last_output)
else:
feedback.pushConsoleInfo("last output " +
last_output.name())
alg_paramsg_m = {
'LAYERS': last_output,
'OVERWRITE': True,
'SAVE_STYLES': False,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT
}
spmesh = processing.run('native:package',
alg_paramsg_m,
context=context,
feedback=feedback,
is_child_algorithm=True)
new_mesh = agtools.SplitMeshLayer(spmesh["OUTPUT"], meshid)
# statv 行政界別集計データ
# 再度メッシュ集計
param2 = {
'INPUT': input_union,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT,
'pareafield': 'div_area',
'polsmpl': 'pvsum',
'meshid': meshid,
'meshlayer': new_mesh
}
res2 = processing.run('QGIS_stat:AggregatePopMeshbyMeshAlgorithm',
param2,
context=context,
feedback=feedback,
is_child_algorithm=True)
#numberof_under_limit = res2["LIMITPOL"]
numberof_under_limit = 0
# レイヤをGeoPackage化
alg_paramsg2 = {
'LAYERS': res2["OUTPUT"],
'OVERWRITE': True,
'SAVE_STYLES': False,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT
}
retg2 = processing.run('native:package',
alg_paramsg2,
context=context,
feedback=feedback,
is_child_algorithm=True)
mesh_layb = retg2["OUTPUT"]
if type(mesh_layb) is str:
mesh_layb = QgsVectorLayer(mesh_layb, "mesh", "ogr")
#features = mesh_layb.selectedFeatures()
#feedback.pushConsoleInfo( "feature count " +str( len(features)) )
lower_ids = []
for f in mesh_layb.getFeatures():
# feedback.pushConsoleInfo( "value " +str( f["value"]) )
if not f[value_column] is None:
if f[value_column] > 0 and f[value_column] < limit_sample:
numberof_under_limit += 1
lower_ids.append(f[meshid])
if numberof_under_limit == 0:
last_output = res2["OUTPUT"]
next_output = retg2["OUTPUT"]
else:
# 不均等分割でリミット以下のデータがある場合は last_output -> 分割不能抽出 next_output 分割不能削除 next_output -> last_output 代入
# last_output = res2["OUTPUT"]
next_output = retg2["OUTPUT"]
# 集計結果が最小サンプルより小さいものがある場合
if numberof_under_limit > 0:
# 均等分割の場合は終了
if not uneven_div:
break
# 不均等分割の場合は終了データを保全 それ以外のメッシュの分割
else:
rmid = []
for tgid in (lower_ids):
feedback.pushConsoleInfo("lower id " + str(tgid))
# next_output code の下3桁 削除 C27210-02 -> C27210 が last_output の code 番号
# next_output では last_output が同じ番号の最大4メッシュを削除する
# リミットより小さいレコードは旧レコードを退避
# リミットにひっかかるレコードを再処理用リストから削除（同一親メッシュのものも削除）
# 不均等分割でリミット以下のデータがある場合は last_output -> 分割不能抽出 next_output 分割不能削除 next_output -> last_output 代入
parent_code = tgid[0:-3]
rmid.append(parent_code)
addfeatures = []
#if type(last_output) is str:
# last_output = QgsVectorLayer(last_output, "mesh", "ogr")
alg_paramsg_n = {
'LAYERS': last_output,
'OVERWRITE': False,
'SAVE_STYLES': False,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT
}
lmesh = processing.run('native:package',
alg_paramsg_n,
context=context,
feedback=feedback,
is_child_algorithm=True)
#last_output.removeSelection()
last_output = lmesh["OUTPUT"]
if type(last_output) is str:
last_output = QgsVectorLayer(last_output, "mesh",
"ogr")
last_output.selectAll()
for lf in last_output.getFeatures():
for pcode in (rmid):
# feedback.pushConsoleInfo( "pcode " + pcode+ " meshid =" + lf[meshid] )
if lf[meshid] == pcode:
lf["fid"] = None
if not lf[value_column]:
lf[value_column] = 0.0
if lf[meshid] not in appended:
addfeatures.append(lf)
appended[lf[meshid]] = lf
#addfeatures.append(lf)
feedback.pushConsoleInfo("add feature " +
pcode)
resLayer.dataProvider().addFeatures(addfeatures)
deleteFeatures = []
if type(next_output) is str:
next_output = QgsVectorLayer(next_output, "mesh",
"ogr")
for nf in next_output.getFeatures():
for pcode in (rmid):
if nf[meshid][0:-3] == pcode:
deleteFeatures.append(nf.id())
feedback.pushConsoleInfo("delete id " +
str(pcode))
next_output.dataProvider().deleteFeatures(deleteFeatures)
last_output = next_output
# Return the results of the algorithm. In this case our only result is
# the feature sink which contains the processed features, but some
# algorithms may return multiple feature sinks, calculated numeric
# statistics, etc. These should all be included in the returned
# dictionary, with keys matching the feature corresponding parameter
# or output names.
# 不均等分割の場合 最終作業レイヤの地物がはいってないかも
if uneven_div:
alg_paramsg_n = {
'LAYERS': next_output,
'OVERWRITE': False,
'SAVE_STYLES': False,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT
}
lmesh = processing.run('native:package',
alg_paramsg_n,
context=context,
feedback=feedback,
is_child_algorithm=True)
#last_output.removeSelection()
last_output = lmesh["OUTPUT"]
if type(last_output) is str:
last_output = QgsVectorLayer(last_output, "mesh", "ogr")
last_output.selectAll()
addfeatures = []
for lf in last_output.getFeatures():
feedback.pushConsoleInfo("add features meshid =" + lf[meshid])
lf["fid"] = None
if not lf[value_column]:
lf[value_column] = 0.0
if lf[meshid] not in appended:
addfeatures.append(lf)
appended[lf[meshid]] = lf
#addfeatures.append(lf)
resLayer.dataProvider().addFeatures(addfeatures)
# フォーマット変換（gdal_translate）
alg_params = {
'INPUT': resLayer,
'OPTIONS': '',
'OUTPUT': parameters['OUTPUT']
}
ocv = processing.run('gdal:convertformat',
alg_params,
context=context,
feedback=feedback,
is_child_algorithm=True)
results["OUTPUT"] = ocv["OUTPUT"]
return results
# 均等分割の場合
else:
# フォーマット変換（gdal_translate）
alg_params = {
'INPUT': last_output,
'OPTIONS': '',
'OUTPUT': parameters['OUTPUT']
}
ocv = processing.run('gdal:convertformat',
alg_params,
context=context,
feedback=feedback,
is_child_algorithm=True)
results["OUTPUT"] = ocv["OUTPUT"]
return results
def processAlgorithm(self, feedback):
layers = self.getParameterValue(self.INPUT_DATASOURCES)
query = self.getParameterValue(self.INPUT_QUERY)
uid_field = self.getParameterValue(self.INPUT_UID_FIELD)
geometry_field = self.getParameterValue(self.INPUT_GEOMETRY_FIELD)
geometry_type = self.getParameterValue(self.INPUT_GEOMETRY_TYPE)
geometry_crs = self.getParameterValue(self.INPUT_GEOMETRY_CRS)
df = QgsVirtualLayerDefinition()
layerIdx = 1
if layers:
for layerSource in layers.split(';'):
layer = dataobjects.getLayerFromString(layerSource)
if layer:
df.addSource('input{}'.format(layerIdx), layer.id())
layerIdx += 1
if query == '':
raise GeoAlgorithmExecutionException(
self.
tr('Empty SQL. Please enter valid SQL expression and try again.'
))
else:
df.setQuery(query)
if uid_field:
df.setUid(uid_field)
if geometry_type == 1: # no geometry
df.setGeometryWkbType(QgsWkbTypes.NullGeometry)
else:
if geometry_field:
df.setGeometryField(geometry_field)
if geometry_type > 1:
df.setGeometryWkbType(geometry_type - 1)
if geometry_crs:
crs = QgsCoordinateReferenceSystem(geometry_crs)
if crs.isValid():
df.setGeometrySrid(crs.postgisSrid())
vLayer = QgsVectorLayer(df.toString(), "temp_vlayer", "virtual")
if not vLayer.isValid():
raise GeoAlgorithmExecutionException(
vLayer.dataProvider().error().message())
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
vLayer.fields().toList(),
# Create a point layer (without any points) if 'no geometry' is chosen
vLayer.wkbType() if geometry_type != 1 else 1,
vLayer.crs())
features = vector.features(vLayer)
total = 100.0 / len(features)
outFeat = QgsFeature()
for current, inFeat in enumerate(features):
outFeat.setAttributes(inFeat.attributes())
if geometry_type != 1:
outFeat.setGeometry(inFeat.geometry())
writer.addFeature(outFeat)
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, parameters, context, feedback):
layers = self.parameterAsLayerList(parameters, self.INPUT_DATASOURCES, context)
query = self.parameterAsString(parameters, self.INPUT_QUERY, context)
uid_field = self.parameterAsString(parameters, self.INPUT_UID_FIELD, context)
geometry_field = self.parameterAsString(parameters, self.INPUT_GEOMETRY_FIELD, context)
geometry_type = self.parameterAsEnum(parameters, self.INPUT_GEOMETRY_TYPE, context)
geometry_crs = self.parameterAsCrs(parameters, self.INPUT_GEOMETRY_CRS, context)
df = QgsVirtualLayerDefinition()
for layerIdx, layer in enumerate(layers):
df.addSource('input{}'.format(layerIdx + 1), layer.id())
if query == '':
raise QgsProcessingException(
self.tr('Empty SQL. Please enter valid SQL expression and try again.'))
else:
localContext = self.createExpressionContext(parameters, context)
expandedQuery = QgsExpression.replaceExpressionText(query, localContext)
df.setQuery(expandedQuery)
if uid_field:
df.setUid(uid_field)
if geometry_type == 1: # no geometry
df.setGeometryWkbType(QgsWkbTypes.NoGeometry)
else:
if geometry_field:
df.setGeometryField(geometry_field)
if geometry_type > 1:
df.setGeometryWkbType(geometry_type - 1)
if geometry_crs.isValid():
df.setGeometrySrid(geometry_crs.postgisSrid())
vLayer = QgsVectorLayer(df.toString(), "temp_vlayer", "virtual")
if not vLayer.isValid():
raise QgsProcessingException(vLayer.dataProvider().error().message())
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
vLayer.fields(), vLayer.wkbType() if geometry_type != 1 else 1, vLayer.crs())
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
features = vLayer.getFeatures()
total = 100.0 / vLayer.featureCount() if vLayer.featureCount() else 0
for current, inFeat in enumerate(features):
if feedback.isCanceled():
break
sink.addFeature(inFeat, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
class gipodWriter(object):
def __init__(self, iface, layername, CRS=31370, manifestation=False, KML="" ):
self.iface = iface
self.canvas = iface.mapCanvas()
self.layername = layername
self.CRS = CRS
self.manifestation = manifestation
if KML == "KML":
self.KML = 1
else:
self.KML = 0
def __enter__(self):
attributes =[ QgsField("gipodId", QVariant.Int),
QgsField("owner", QVariant.String) ,
QgsField("description", QVariant.String),
QgsField("beginDate", QVariant.String, "Date"),
QgsField("endDate", QVariant.String, "Date"),
QgsField("hinder", QVariant.Int),
QgsField("link", QVariant.String),
QgsField("cities", QVariant.String)
]
if self.manifestation:
attributes += [QgsField("intiatief", QVariant.String),
QgsField("patroon", QVariant.String)]
if self.KML:
attributes += [QgsField("begin", QVariant.String, "Date"),
QgsField("end", QVariant.String, "Date"),
QgsField("icon", QVariant.String)
]
self.gipodlayer = QgsVectorLayer("Point", self.layername, "memory")
self.gipodProvider = self.gipodlayer.dataProvider()
self.gipodProvider.addAttributes(attributes)
self.gipodlayer.updateFields()
self.fields= self.gipodlayer.fields()
return self
def saveGipod2file(self, filename, ftype="ESRI Shapefile" ):
layerOptions = []
datasourceOptions = []
if ftype == "CSV":
layerOptions += ["GEOMETRY=AS_XY","SEPARATOR=SEMICOLON"]
if ftype == "KML":
datasourceOptions += ["NameField=owner"]
srs = QgsCoordinateReferenceSystem(self.CRS)
fpath, name = os.path.split(filename)
if fpath and os.path.exists(fpath):
error, errormsg = QgsVectorFileWriter.writeAsVectorFormat(self.gipodlayer , filename, "utf-8", self.gipodlayer.crs(), ftype, layerOptions= layerOptions, datasourceOptions= datasourceOptions )
if error == QgsVectorFileWriter.NoError:
if ftype == "CSV":
uri =( "file:///%s?delimiter=%s&xField=%s&yField=%s&crs=%s" % (
filename, ";", "X", "Y", self.gipodlayer.crs().authid()) ).replace("\\","/")
self.gipodlayer = QgsVectorLayer(uri, self.layername, "delimitedtext")
else:
self.gipodlayer = QgsVectorLayer( filename, self.layername, "ogr")
self.gipodProvider = self.gipodlayer.dataProvider()
else:
raise gipodError( str(error.hasError()) , errormsg )
else:
raise gipodError( fpath + " doesn't exist" )
def _makeCRSpoint(self, xy):
x,y = xy
fromCrs = QgsCoordinateReferenceSystem(self.CRS)
xform = QgsCoordinateTransform( fromCrs, self.gipodlayer.crs(), QgsProject.instance() )
return xform.transform( QgsPointXY( x,y ))
def writePoint(self, xy, gipodId, owner, description, startDateTime, endDateTime, importantHindrance, detail, cities=[], initiator=None, recurrencePattern=None):
fet = QgsFeature(self.fields)
fet['gipodId'] = gipodId
fet['owner'] = owner
fet['description'] = description
if self.KML:
fet['begin'] = startDateTime.split("T")[0]
fet['end'] = endDateTime.split("T")[0]
if importantHindrance: fet['icon'] = "http://api.gipod.vlaanderen.be/ws/v1/icon/workassignment?important=true"
else: fet['icon'] = "http://api.gipod.vlaanderen.be/ws/v1/icon/workassignment?important=false"
fet['beginDate'] = startDateTime
fet['endDate'] = endDateTime
fet['hinder'] = importantHindrance
fet['link'] = detail
fet['cities'] = ", ".join(cities)
if initiator and self.manifestation:
fet['intiatief'] = initiator
if recurrencePattern and self.manifestation:
fet['patroon'] = recurrencePattern
prjPt = self._makeCRSpoint( xy )
fet.setGeometry(QgsGeometry.fromPointXY(prjPt))
self.gipodProvider.addFeatures([ fet ])
def __exit__(self, type, value, traceback):
' add layer to map and clean up'
render = gipodRender(self.gipodlayer, 'hinder' ).render
self.gipodlayer.setRenderer(render)
QgsProject.instance().addMapLayer(self.gipodlayer)
# refresh and update extends
self.gipodlayer.updateExtents()
self.canvas.refresh()
del self.gipodlayer, self.gipodProvider, self.fields
def processAlgorithm(self, parameters, context, feedback):
layers = self.parameterAsLayerList(parameters, self.INPUT_DATASOURCES, context)
query = self.parameterAsString(parameters, self.INPUT_QUERY, context)
uid_field = self.parameterAsString(parameters, self.INPUT_UID_FIELD, context)
geometry_field = self.parameterAsString(parameters, self.INPUT_GEOMETRY_FIELD, context)
geometry_type = self.parameterAsEnum(parameters, self.INPUT_GEOMETRY_TYPE, context)
geometry_crs = self.parameterAsCrs(parameters, self.INPUT_GEOMETRY_CRS, context)
df = QgsVirtualLayerDefinition()
for layerIdx, layer in enumerate(layers):
df.addSource('input{}'.format(layerIdx + 1), layer.id())
if query == '':
raise QgsProcessingException(
self.tr('Empty SQL. Please enter valid SQL expression and try again.'))
else:
localContext = self.createExpressionContext(parameters, context)
expandedQuery = QgsExpression.replaceExpressionText(query, localContext)
df.setQuery(expandedQuery)
if uid_field:
df.setUid(uid_field)
if geometry_type == 1: # no geometry
df.setGeometryWkbType(QgsWkbTypes.NoGeometry)
else:
if geometry_field:
df.setGeometryField(geometry_field)
if geometry_type > 1:
df.setGeometryWkbType(geometry_type - 1)
if geometry_crs.isValid():
df.setGeometrySrid(geometry_crs.postgisSrid())
vLayer = QgsVectorLayer(df.toString(), "temp_vlayer", "virtual")
if not vLayer.isValid():
raise QgsProcessingException(vLayer.dataProvider().error().message())
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
vLayer.fields(), vLayer.wkbType() if geometry_type != 1 else 1, vLayer.crs())
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
features = vLayer.getFeatures()
total = 100.0 / vLayer.featureCount() if vLayer.featureCount() else 0
for current, inFeat in enumerate(features):
if feedback.isCanceled():
break
sink.addFeature(inFeat, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
def _aggregate(self,
myImpactLayer,
myExpectedResults,
useNativeZonalStats=False):
"""Helper to calculate aggregation.
Expected results is split into two lists - one list contains numeric
attributes, the other strings. This is done so that we can use numpy
.testing.assert_allclose which doesn't work on strings
"""
myExpectedStringResults = []
myExpectedNumericResults = []
for item in myExpectedResults:
myItemNumResults = []
myItemStrResults = []
for field in item:
try:
value = float(field)
myItemNumResults.append(value)
except ValueError:
myItemStrResults.append(str(field))
myExpectedNumericResults.append(myItemNumResults)
myExpectedStringResults.append(myItemStrResults)
myAggregationLayer = QgsVectorLayer(
os.path.join(BOUNDDATA, 'kabupaten_jakarta.shp'),
'test aggregation',
'ogr')
# create a copy of aggregation layer
myGeoExtent = extent_to_geo_array(
myAggregationLayer.extent(),
myAggregationLayer.crs())
myAggrAttribute = self.keywordIO.read_keywords(
myAggregationLayer, self.defaults['AGGR_ATTR_KEY'])
# noinspection PyArgumentEqualDefault
myAggregationLayer = clip_layer(
layer=myAggregationLayer,
extent=myGeoExtent,
explode_flag=True,
explode_attribute=myAggrAttribute)
myAggregator = Aggregator(None, myAggregationLayer)
# setting up
myAggregator.isValid = True
myAggregator.layer = myAggregationLayer
myAggregator.safeLayer = safe_read_layer(
str(myAggregator.layer.source()))
myAggregator.aoiMode = False
myAggregator.useNativeZonalStats = useNativeZonalStats
myAggregator.aggregate(myImpactLayer)
myProvider = myAggregator.layer.dataProvider()
myNumericResults = []
myStringResults = []
for myFeature in myProvider.getFeatures():
myFeatureNumResults = []
myFeatureStrResults = []
myAttrs = myFeature.attributes()
for attr in myAttrs:
if isinstance(attr, (int, float)):
myFeatureNumResults.append(attr)
else:
myFeatureStrResults.append(attr)
myNumericResults.append(myFeatureNumResults)
myStringResults.append(myFeatureStrResults)
# check string attributes
self.assertEqual(myExpectedStringResults, myStringResults)
# check numeric attributes with a 0.01% tolerance compared to the
# native QGIS stats
numpy.testing.assert_allclose(myExpectedNumericResults,
myNumericResults,
rtol=0.01)
def open_file(
dialog=None,
osm_file=None,
output_geom_types=None,
white_list_column=None,
output_format=None,
layer_name="OsmFile",
config_outputs=None,
output_dir=None,
prefix_file=None):
"""
open an osm file
"""
outputs = get_outputs(output_dir, output_format, prefix_file, layer_name)
# Parsing the file
osm_parser = OsmParser(
osm_file=osm_file,
layers=output_geom_types,
white_list_column=white_list_column)
osm_parser.signalText.connect(dialog.set_progress_text)
osm_parser.signalPercentage.connect(dialog.set_progress_percentage)
layers = osm_parser.parse()
# Finishing the process with geojson or shapefile
num_layers = 0
if output_format == "shape":
dialog.set_progress_text(tr("QuickOSM", u"From GeoJSON to Shapefile"))
if output_format == "spatialite":
dialog.set_progress_text(tr("QuickOSM", u"From GeoJSON to SpatiaLite"))
# create spatialite DB
conn = sqlitedb.connect(outputs['file'])
cur = conn.cursor()
cur.execute("SELECT initSpatialMetadata(1)")
conn.close()
for i, (layer, item) in enumerate(layers.iteritems()):
dialog.set_progress_percentage(i / len(layers) * 100)
QApplication.processEvents()
if item['featureCount'] and layer in output_geom_types:
final_layer_name = layer_name
# If configOutputs is not None (from My Queries)
if config_outputs:
if config_outputs[layer]['namelayer']:
final_layer_name = config_outputs[layer]['namelayer']
# Transforming the vector file
osm_geometries = {
'points': QGis.WKBPoint,
'lines': QGis.WKBLineString,
'multilinestrings': QGis.WKBMultiLineString,
'multipolygons': QGis.WKBMultiPolygon}
geojson_layer = QgsVectorLayer(item['geojsonFile'], "temp", "ogr")
encoding = get_default_encoding()
if output_format == "shape":
provider = "ESRI Shapefile"
elif output_format == "geojson":
provider = "GeoJSON"
if output_format == "spatialite":
uri = QgsDataSourceURI()
uri.setDatabase(outputs['file'])
uri.setDataSource('', outputs[layer], 'geom')
layer_source = uri.uri()
layer_provider = 'spatialite'
writer = QgsVectorLayerImport(
layer_source,
layer_provider,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs())
else:
layer_source = outputs[layer]
layer_provider = 'ogr'
writer = QgsVectorFileWriter(
layer_source,
encoding,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs(),
provider)
for f in geojson_layer.getFeatures():
writer.addFeature(f)
del writer
# Loading the final vector file
new_layer = QgsVectorLayer(layer_source, final_layer_name, layer_provider)
# Try to set styling if defined
if config_outputs and config_outputs[layer]['style']:
new_layer.loadNamedStyle(config_outputs[layer]['style'])
else:
# Loading default styles
if layer == "multilinestrings" or layer == "lines":
if "colour" in item['tags']:
new_layer.loadNamedStyle(
join(dirname(dirname(abspath(__file__))),
"styles",
layer + "_colour.qml"))
# Add action about OpenStreetMap
actions = new_layer.actions()
actions.addAction(
QgsAction.OpenUrl,
"OpenStreetMap Browser",
'http://www.openstreetmap.org/browse/'
'[% "osm_type" %]/[% "osm_id" %]',
False)
actions.addAction(
QgsAction.GenericPython,
'JOSM',
'from QuickOSM.CoreQuickOSM.Actions import Actions;'
'Actions.run("josm","[% "full_id" %]")',
False)
actions.addAction(
QgsAction.OpenUrl,
"User default editor",
'http://www.openstreetmap.org/edit?'
'[% "osm_type" %]=[% "osm_id" %]',
False)
for link in ['url', 'website', 'wikipedia', 'ref:UAI']:
if link in item['tags']:
link = link.replace(":", "_")
actions.addAction(
QgsAction.GenericPython,
link,
'from QuickOSM.core.actions import Actions;'
'Actions.run("' + link + '","[% "' + link + '" %]")',
False)
if 'network' in item['tags'] and 'ref' in item['tags']:
actions.addAction(
QgsAction.GenericPython,
"Sketchline",
'from QuickOSM.core.actions import Actions;'
'Actions.run_sketch_line("[% "network" %]","[% "ref" %]")',
False)
# Add index if possible
if output_format == "shape" or output_format == "spatialite":
new_layer.dataProvider().createSpatialIndex()
QgsMapLayerRegistry.instance().addMapLayer(new_layer)
num_layers += 1
return num_layers
class VarMixViewer:
"""QGIS Plugin Implementation."""
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'VarMixViewer_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference
self.dlg = VarMixViewerDialog()
self.pld = PointLayerDialog()
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&VarMixViewer')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'VarMixViewer')
self.toolbar.setObjectName(u'VarMixViewer')
self.distanz = QgsDistanceArea()
self.distanz.setSourceCrs(QgsCoordinateReferenceSystem(25832), QgsCoordinateTransformContext())
self.distanz.setEllipsoid('GRS80')
self.netz = QgsVectorLayer()
# noinspection PyMethodMayBeStatic
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('VarMixViewer', message)
def add_action(
self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar.
:param icon_path: Path to the icon for this action. Can be a resource
path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
:type icon_path: str
:param text: Text that should be shown in menu items for this action.
:type text: str
:param callback: Function to be called when the action is triggered.
:type callback: function
:param enabled_flag: A flag indicating if the action should be enabled
by default. Defaults to True.
:type enabled_flag: bool
:param add_to_menu: Flag indicating whether the action should also
be added to the menu. Defaults to True.
:type add_to_menu: bool
:param add_to_toolbar: Flag indicating whether the action should also
be added to the toolbar. Defaults to True.
:type add_to_toolbar: bool
:param status_tip: Optional text to show in a popup when mouse pointer
hovers over the action.
:type status_tip: str
:param parent: Parent widget for the new action. Defaults None.
:type parent: QWidget
:param whats_this: Optional text to show in the status bar when the
mouse pointer hovers over the action.
:returns: The action that was created. Note that the action is also
added to self.actions list.
:rtype: QAction
"""
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToVectorMenu(
self.menu,
action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = ':/plugins/VarMixViewer/icon.png'
self.add_action(
icon_path,
text=self.tr(u'VarMixViewer'),
callback=self.run,
parent=self.iface.mainWindow())
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginVectorMenu(
self.tr(u'&VarMixViewer'),
action)
self.iface.removeToolBarIcon(action)
# remove the toolbar
del self.toolbar
@staticmethod
def calc_factor(section, xls_feature):
section_length = section['Abschnittslaenge']
geom = section.geometry()
geo_length = geom.length()
factor = 1
if section_length > 0:
factor = geo_length / section_length
vst = xls_feature['vst'] * factor
bst = xls_feature['bst'] * factor
points = geom.asPolyline()
return points, bst, vst
def cut_line(self, section, xls_feature):
feat = QgsFeature(xls_feature)
points, bst, vst = self.calc_factor(section, xls_feature)
p_old = QgsPointXY(points[0])
sum = 0
line = []
for p in points:
p = QgsPointXY(p)
dist = self.distanz.measureLine(p_old, p)
sum += dist
if sum > vst and len(line) == 0:
# print("Anfang")
part = (sum - vst) / dist
dx = p.x() - p_old.x()
dy = p.y() - p_old.y()
x = p.x() - part * dx
y = p.y() - part * dy
line.append(QgsPointXY(x, y))
if sum > bst:
part = (sum - bst) / dist
# print(part)
dx = p.x() - p_old.x()
dy = p.y() - p_old.y()
x = p.x() - part * dx
y = p.y() - part * dy
line.append(QgsPointXY(x, y))
break
if sum > vst:
line.append(p)
# print(sum)
p_old = p
feat.setGeometry(QgsGeometry.fromPolylineXY(line))
return feat
def cut_point(self, section, xls_feature, side_dist_field = -1):
feat = QgsFeature(xls_feature)
points, bst, vst = self.calc_factor(section, xls_feature)
p_old = QgsPointXY(points[0])
sum_len = 0
count_points = len(points)
for i in range(count_points):
p = QgsPointXY(points[i])
dist = self.distanz.measureLine(p_old, p)
sum_len += dist
# print(str(sum_len) + " > " + str(vst))
if sum_len > vst or i == count_points - 1:
part = (sum_len - vst) / dist
dx = p.x() - p_old.x()
dy = p.y() - p_old.y()
side_factor = 0
if side_dist_field >= 0:
side_factor = xls_feature[side_dist_field] / dist
x = p.x() - part * dx + dy * side_factor
y = p.y() - part * dy - dx * side_factor
feat.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(x, y)))
return feat
p_old = p
def select_section(self, vnk, nnk):
"""Returns section out of Strassennetz.tab"""
exp = QgsExpression('\"Anfangsnetzknoten\" = \'' + vnk + '\' AND \"Endnetzknoten\" = \'' + nnk + '\'')
request = QgsFeatureRequest(exp)
for f in self.netz.getFeatures(request):
return f
return None
def generate_layer(self):
"""Generates temporary layers with geometry"""
self.netz = QgsVectorLayer(self.dlg.mQgsFileWidget_2.filePath(), "netz", "ogr")
varmix = QgsVectorLayer(self.dlg.mQgsFileWidget.filePath(), "varMix", "ogr")
varmix.setProviderEncoding(u'UTF-8')
varmix.dataProvider().setEncoding(u'UTF-8')
# varmix = QgsVectorLayer("D:\kreis.xls", "varMix", "ogr")
# d.setEllipsoidalMode(True)
layer_without = QgsVectorLayer("None", os.path.basename(self.dlg.mQgsFileWidget.filePath()) + " (Ohne Geometrie)", "memory")
layer_without.startEditing()
without_data = layer_without.dataProvider()
without_data.addAttributes(varmix.fields()) #
layer_without.commitChanges()
QgsProject.instance().addMapLayer(layer_without)
layer_points = QgsVectorLayer("point?crs=" + self.netz.crs().authid(), os.path.basename(self.dlg.mQgsFileWidget.filePath()) + " (Punkte)", "memory")
layer_points.startEditing()
point_data = layer_points.dataProvider()
point_data.addAttributes(varmix.fields()) #
layer_points.commitChanges()
QgsProject.instance().addMapLayer(layer_points)
layer_lines = QgsVectorLayer("linestring?crs=" + self.netz.crs().authid(), os.path.basename(self.dlg.mQgsFileWidget.filePath()) + " (Linien)", "memory")
layer_lines.startEditing()
lines_data = layer_lines.dataProvider()
lines_data.addAttributes(varmix.fields()) #
layer_lines.commitChanges()
QgsProject.instance().addMapLayer(layer_lines)
results = varmix.getFeatures()
vnk = ""
nnk = ""
feat = None
side_dist_field = None;
for r in results:
if not (vnk == r['VNK'] and nnk == r['NNK']):
vnk = r['VNK']
nnk = r['NNK']
feat = self.select_section(vnk, nnk)
if feat is None:
without_data.addFeatures([r])
elif r['VST'] == r['BST']:
if side_dist_field is None:
self.pld.show()
self.pld.comboBox.clear()
self.pld.comboBox.addItem("-- kein seitlicher Abstand --")
for f in varmix.fields():
self.pld.comboBox.addItem(f.name())
self.pld.comboBox.setCurrentIndex(0)
result = self.pld.exec_()
if result:
side_dist_field = self.pld.comboBox.currentIndex()-1
f = self.cut_point(feat, r, side_dist_field)
if f is not None:
point_data.addFeatures([f])
else:
without_data.addFeatures([r])
else:
f = self.cut_line(feat, r)
if f is not None:
lines_data.addFeatures([f])
else:
without_data.addFeatures([r])
if lines_data.featureCount() == 0:
QgsProject.instance().removeMapLayer(layer_lines)
if point_data.featureCount() == 0:
QgsProject.instance().removeMapLayer(layer_points)
if without_data.featureCount() == 0:
QgsProject.instance().removeMapLayer(layer_without)
def run(self):
"""Run method that performs all the real work"""
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
self.generate_layer()
pass
def on_btnRun_clicked(self):
if self.inputfile == '':
QMessageBox.critical(self,'Map Creator',
'Please specify input coordinate file.')
return
if self.outputfile == '':
QMessageBox.critical(self,'Map Creator',
'Please specify output shapefile.')
return
self.setCursor(Qt.WaitCursor)
#Open coordinate input file
f = open(self.inputfile, 'r')
lines = f.readlines()
f.close()
header = lines[0].split(',')[0]
totfeat = len(lines) - 1
lines.pop(0)
lines.reverse()
#Create vector layer
basename = os.path.basename(self.outputfile)
vlayer = QgsVectorLayer("Polygon", basename, "memory")
vprovider = vlayer.dataProvider()
fld = QgsField(header,QVariant.String)
flds = QgsFields()
flds.append(fld)
vprovider.addAttributes([fld])
vlayer.startEditing()
hull = []
for cnt, line in enumerate(lines):
line = line.rstrip().split(',')
numcoords = int((len(line) - 1) / 2)
hull[:] = []
geom = QgsGeometry()
feat = QgsFeature()
feat.setFields(flds)
for i in range(numcoords):
hull.append(QgsPoint(float(line[i*2+1]),float(line[i*2+2])))
geom = geom.fromMultiPoint(hull)
geom = geom.convexHull()
feat.setGeometry(geom)
feat.setAttribute(header,str(line[0]))
result = vlayer.addFeature(feat)
if not result:
self.setCursor(Qt.ArrowCursor)
QMessageBox.critical(self,'Map Creator', 'Processing error.')
return
self.ui.ProgressBar.setValue(float(cnt+1)/float(totfeat) * 100.0)
QApplication.processEvents()
vlayer.commitChanges()
vlayer.updateExtents()
#Write the output shapefile
if os.path.exists(self.outputfile):
QgsVectorFileWriter.deleteShapeFile(self.outputfile)
result = QgsVectorFileWriter.writeAsVectorFormat(vlayer,
self.outputfile,
'utf-8',
vlayer.crs())
if result != QgsVectorFileWriter.NoError:
QMessageBox.critical(self,'Map Creator','Error creating shapefile.')
else: #Ask to add shapfile to map
name = QFileInfo(self.outputfile).completeBaseName()
result = QMessageBox.question(self,'Map Creator',
'Add shapefile to map?',
QMessageBox.Yes,
QMessageBox.No)
if result == QMessageBox.Yes:
self.iface.addVectorLayer(self.outputfile, name, 'ogr')
self.setCursor(Qt.ArrowCursor)
def load_path_vector_layer(path, **kwargs):
"""Return the test vector layer.
:param path: Path to the vector layer.
:type path: str
:param kwargs: It can be :
clone=True if you want to copy the layer first to a temporary file.
clone_to_memory=True if you want to create a memory layer.
with_keywords=False if you do not want keywords. "clone_to_memory" is
required.
:type kwargs: dict
:return: The vector layer.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
if not exists(path):
raise Exception('%s do not exist.' % path)
path = os.path.normcase(os.path.abspath(path))
name = splitext(basename(path))[0]
extension = splitext(path)[1]
extensions = [
'.shp', '.shx', '.dbf', '.prj', '.gpkg', '.geojson', '.xml', '.qml'
]
if kwargs.get('with_keywords'):
if not kwargs.get('clone_to_memory'):
raise Exception('with_keywords needs a clone_to_memory')
if kwargs.get('clone', False):
target_directory = mkdtemp()
current_path = splitext(path)[0]
path = join(target_directory, name + extension)
for ext in extensions:
src_path = current_path + ext
if exists(src_path):
target_path = join(target_directory, name + ext)
shutil.copy2(src_path, target_path)
if path.endswith('.csv'):
# Explicitly use URI with delimiter or tests fail in Windows. TS.
uri = 'file:///%s?delimiter=%s' % (path, ',')
layer = QgsVectorLayer(uri, name, 'delimitedtext')
else:
layer = QgsVectorLayer(path, name, 'ogr')
if not layer.isValid():
raise Exception('%s is not a valid layer.' % name)
monkey_patch_keywords(layer)
if kwargs.get('clone_to_memory', False):
keywords = layer.keywords.copy()
memory_layer = create_memory_layer(name, layer.geometryType(),
layer.crs(), layer.fields())
copy_layer(layer, memory_layer)
if kwargs.get('with_keywords', True):
memory_layer.keywords = keywords
return memory_layer
else:
return layer
def run(settings, progress_bars):
for key in list(progress_bars.keys()):
bar = progress_bars[key]
bar['bar'].setValue(0)
bar['label'].setText('')
CreateTempDir()
receiver_layer_name = os.path.splitext(
os.path.basename(settings['receivers_path']))[0]
receiver_layer = QgsVectorLayer(settings['receivers_path'],
receiver_layer_name, "ogr")
if settings['sources_pts_path'] is not None:
source_pts_layer_name = os.path.splitext(
os.path.basename(settings['sources_pts_path']))[0]
source_pts_layer = QgsVectorLayer(settings['sources_pts_path'],
source_pts_layer_name, "ogr")
else:
source_pts_layer = None
if settings['sources_roads_path'] is not None:
source_roads_layer_name = os.path.splitext(
os.path.basename(settings['sources_roads_path']))[0]
source_roads_layer = QgsVectorLayer(settings['sources_roads_path'],
source_roads_layer_name, "ogr")
else:
source_roads_layer = None
if settings['buildings_path'] is not None:
obstacles_layer_name = os.path.splitext(
os.path.basename(settings['buildings_path']))[0]
obstacles_layer = QgsVectorLayer(settings['buildings_path'],
obstacles_layer_name, "ogr")
else:
obstacles_layer = None
rays_layer_path = settings['rays_path']
diff_rays_layer_path = settings['diff_rays_path']
# defines rays layer
if rays_layer_path is not None:
rays_fields = QgsFields()
rays_fields.append(QgsField("id_ray", QVariant.Int))
rays_fields.append(QgsField("id_rec", QVariant.Int))
rays_fields.append(QgsField("id_emi", QVariant.Int))
rays_fields.append(QgsField("d_rTOe", QVariant.Double, len=10, prec=2))
rays_fields.append(
QgsField("d_rTOe_4m", QVariant.Double, len=10, prec=2))
if settings['period_pts_gen'] == "True" or settings[
'period_roads_gen'] == "True":
rays_fields.append(
QgsField("gen_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("gen", QVariant.Double, len=5, prec=1))
if settings['period_pts_day'] == "True" or settings[
'period_roads_day'] == "True":
rays_fields.append(
QgsField("day_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("day", QVariant.Double, len=5, prec=1))
if settings['period_pts_eve'] == "True" or settings[
'period_roads_eve'] == "True":
rays_fields.append(
QgsField("eve_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("eve", QVariant.Double, len=5, prec=1))
if settings['period_pts_nig'] == "True" or settings[
'period_roads_nig'] == "True":
rays_fields.append(
QgsField("nig_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("nig", QVariant.Double, len=5, prec=1))
rays_writer = QgsVectorFileWriter(rays_layer_path, "System",
rays_fields, QgsWkbTypes.LineString,
receiver_layer.crs(),
"ESRI Shapefile")
else:
rays_writer = None
# defines diff rays layer
if diff_rays_layer_path is not None:
rays_fields = QgsFields()
rays_fields.append(QgsField("id_ray", QVariant.Int))
rays_fields.append(QgsField("id_rec", QVariant.Int))
rays_fields.append(QgsField("id_dif", QVariant.Int))
rays_fields.append(QgsField("id_emi", QVariant.Int))
rays_fields.append(QgsField("d_rTOd", QVariant.Double, len=10, prec=2))
rays_fields.append(QgsField("d_dTOe", QVariant.Double, len=10, prec=2))
rays_fields.append(QgsField("d_rTOe", QVariant.Double, len=10, prec=2))
if settings['period_pts_gen'] == "True" or settings[
'period_roads_gen'] == "True":
rays_fields.append(
QgsField("gen_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("gen", QVariant.Double, len=5, prec=1))
if settings['period_pts_day'] == "True" or settings[
'period_roads_day'] == "True":
rays_fields.append(
QgsField("day_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("day", QVariant.Double, len=5, prec=1))
if settings['period_pts_eve'] == "True" or settings[
'period_roads_eve'] == "True":
rays_fields.append(
QgsField("eve_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("eve", QVariant.Double, len=5, prec=1))
if settings['period_pts_nig'] == "True" or settings[
'period_roads_nig'] == "True":
rays_fields.append(
QgsField("nig_emi", QVariant.Double, len=5, prec=1))
rays_fields.append(QgsField("nig", QVariant.Double, len=5, prec=1))
diff_rays_writer = QgsVectorFileWriter(diff_rays_layer_path, "System",
rays_fields,
QgsWkbTypes.LineString,
receiver_layer.crs(),
"ESRI Shapefile")
else:
diff_rays_writer = None
# puts the sound level in the receivers points attribute table
# gets fields from recever point layer and initializes the final receiver_point_field_level to populate the receiver points layer attribute table
fields_number = int(receiver_layer.fields().count())
level_field_index = {}
#modified version in creating fields on existing layer in qgis 3.x
receiver_layer.startEditing()
#level_fields = []
if settings['period_pts_gen'] == "True" or settings[
'period_roads_gen'] == "True":
receiver_layer.addAttribute(
QgsField('gen', QVariant.Double, len=5, prec=1))
level_field_index['gen'] = fields_number
fields_number = fields_number + 1
if settings['period_pts_day'] == "True" or settings[
'period_roads_day'] == "True":
receiver_layer.addAttribute((QgsField('day',
QVariant.Double,
len=5,
prec=1)))
level_field_index['day'] = fields_number
fields_number = fields_number + 1
if settings['period_pts_eve'] == "True" or settings[
'period_roads_eve'] == "True":
receiver_layer.addAttribute(
QgsField('eve', QVariant.Double, len=5, prec=1))
level_field_index['eve'] = fields_number
fields_number = fields_number + 1
if settings['period_pts_nig'] == "True" or settings[
'period_roads_nig'] == "True":
receiver_layer.addAttribute(
QgsField('nig', QVariant.Double, len=5, prec=1))
level_field_index['nig'] = fields_number
fields_number = fields_number + 1
if settings['period_den'] == "True":
receiver_layer.addAttribute(
QgsField('den', QVariant.Double, len=5, prec=1))
level_field_index['den'] = fields_number
fields_number = fields_number + 1
#receiver_layer.dataProvider().addAttributes( level_fields )
receiver_layer.updateFields()
#calculation
receiver_feat_new_fields = calc(progress_bars, receiver_layer,
source_pts_layer, source_roads_layer,
settings, level_field_index,
obstacles_layer, rays_writer,
diff_rays_writer)
#old way to insert data in table
# receiver_layer.dataProvider().changeAttributeValues(receiver_feat_new_fields)
#new way to insert data in table
for f in receiver_layer.getFeatures():
if 'gen' in level_field_index:
f['gen'] = receiver_feat_new_fields[f.id()][
level_field_index['gen']]
#print(receiver_feat_new_fields,f.id(),f['gen'])
if 'day' in level_field_index:
f['day'] = receiver_feat_new_fields[f.id()][
level_field_index['day']]
if 'eve' in level_field_index:
f['eve'] = receiver_feat_new_fields[f.id()][
level_field_index['eve']]
if 'nig' in level_field_index:
f['nig'] = receiver_feat_new_fields[f.id()][
level_field_index['nig']]
if 'den' in level_field_index:
f['den'] = receiver_feat_new_fields[f.id()][
level_field_index['den']]
receiver_layer.updateFeature(f)
receiver_layer.updateExtents()
receiver_layer.commitChanges()
#reload all layers to see the updates of shapefile of receivers
QgsProject.instance().reloadAllLayers()
if rays_layer_path is not None:
del rays_writer
rays_layer_name = os.path.splitext(
os.path.basename(rays_layer_path))[0]
rays_layer = QgsVectorLayer(rays_layer_path, str(rays_layer_name),
"ogr")
QgsProject.instance().addMapLayers([rays_layer])
if diff_rays_layer_path is not None:
del diff_rays_writer
diff_rays_layer_name = os.path.splitext(
os.path.basename(diff_rays_layer_path))[0]
diff_rays_layer = QgsVectorLayer(diff_rays_layer_path,
str(diff_rays_layer_name), "ogr")
QgsProject.instance().addMapLayers([diff_rays_layer])
QgsProject.instance().reloadAllLayers()
# render receivers with noise colours
level_fields_new = list(receiver_layer.dataProvider().fields())
if len(level_fields_new) > 0:
receiver_layer_name = settings['receivers_name']
layer = QgsProject.instance().mapLayersByName(receiver_layer_name)[0]
on_ApplyNoiseSymbology.renderizeXY(
layer, level_fields_new[len(level_fields_new) - 1].name())
DeleteTempDir()
def test_insert_srsName(self):
"""Test srsName is respected when insering"""
post_data = """
<Transaction xmlns="http://www.opengis.net/wfs" xsi:schemaLocation="http://www.qgis.org/gml http://localhost:8000/?SERVICE=WFS&REQUEST=DescribeFeatureType&VERSION=1.0.0&TYPENAME=as_symbols" service="WFS" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="{version}" xmlns:gml="http://www.opengis.net/gml">
<Insert xmlns="http://www.opengis.net/wfs">
<as_symbols xmlns="http://www.qgis.org/gml">
<name xmlns="http://www.qgis.org/gml">{name}</name>
<geometry xmlns="http://www.qgis.org/gml">
<gml:Point srsName="{srsName}">
<gml:coordinates cs="," ts=" ">{coordinates}</gml:coordinates>
</gml:Point>
</geometry>
</as_symbols>
</Insert>
</Transaction>
"""
project = self.testdata_path + \
"test_project_wms_grouped_layers.qgs"
assert os.path.exists(project), "Project file not found: " + project
query_string = '?SERVICE=WFS&MAP={}'.format(
urllib.parse.quote(project))
request = post_data.format(
name='4326-test1',
version='1.1.0',
srsName='EPSG:4326',
coordinates='10.67,52.48'
)
header, body = self._execute_request(
query_string, requestMethod=QgsServerRequest.PostMethod, data=request.encode('utf-8'))
# Verify
vl = QgsVectorLayer(self.testdata_path + 'test_project_wms_grouped_layers.gpkg|layername=as_symbols', 'as_symbols')
self.assertTrue(vl.isValid())
feature = next(vl.getFeatures(QgsFeatureRequest(QgsExpression('"name" = \'4326-test1\''))))
geom = feature.geometry()
tr = QgsCoordinateTransform(QgsCoordinateReferenceSystem.fromEpsgId(4326), vl.crs(), QgsCoordinateTransformContext())
geom_4326 = QgsGeometry.fromWkt('point( 10.67 52.48)')
geom_4326.transform(tr)
self.assertEqual(geom.asWkt(0), geom_4326.asWkt(0))
# Now: insert a feature in layer's CRS
request = post_data.format(
name='25832-test1',
version='1.1.0',
srsName='EPSG:25832',
coordinates='613412,5815738'
)
header, body = self._execute_request(
query_string, requestMethod=QgsServerRequest.PostMethod, data=request.encode('utf-8'))
feature = next(vl.getFeatures(QgsFeatureRequest(QgsExpression('"name" = \'25832-test1\''))))
geom = feature.geometry()
self.assertEqual(geom.asWkt(0), geom_4326.asWkt(0))
# Tests for inverted axis issue GH #36584
# Cleanup
self.assertTrue(vl.startEditing())
vl.selectByExpression('"name" LIKE \'4326-test%\'')
vl.deleteSelectedFeatures()
self.assertTrue(vl.commitChanges())
self.i = 0
def _test(version, srsName, lat_lon=False):
self.i += 1
name = '4326-test_%s' % self.i
request = post_data.format(
name=name,
version=version,
srsName=srsName,
coordinates='52.48,10.67' if lat_lon else '10.67,52.48'
)
header, body = self._execute_request(
query_string, requestMethod=QgsServerRequest.PostMethod, data=request.encode('utf-8'))
feature = next(vl.getFeatures(QgsFeatureRequest(QgsExpression('"name" = \'%s\'' % name))))
geom = feature.geometry()
self.assertEqual(geom.asWkt(0), geom_4326.asWkt(0), "Transaction Failed: %s , %s, lat_lon=%s" % (version, srsName, lat_lon))
_test('1.1.0', 'urn:ogc:def:crs:EPSG::4326', lat_lon=True)
_test('1.1.0', 'http://www.opengis.net/def/crs/EPSG/0/4326', lat_lon=True)
_test('1.1.0', 'http://www.opengis.net/gml/srs/epsg.xml#4326', lat_lon=False)
_test('1.1.0', 'EPSG:4326', lat_lon=False)
_test('1.0.0', 'urn:ogc:def:crs:EPSG::4326', lat_lon=True)
_test('1.0.0', 'http://www.opengis.net/def/crs/EPSG/0/4326', lat_lon=True)
_test('1.0.0', 'http://www.opengis.net/gml/srs/epsg.xml#4326', lat_lon=False)
_test('1.0.0', 'EPSG:4326', lat_lon=False)
def _test_getFeature(version, srsName, lat_lon=False):
# Now get the feature through WFS using BBOX filter
bbox = QgsGeometry.fromWkt('point( 10.7006 52.4317)').boundingBox()
bbox.grow(0.0001)
bbox_text = "%s,%s,%s,%s" % ((bbox.yMinimum(), bbox.xMinimum(), bbox.yMaximum(), bbox.xMaximum()) if lat_lon else (bbox.xMinimum(), bbox.yMinimum(), bbox.xMaximum(), bbox.yMaximum()))
req = query_string + '&REQUEST=GetFeature&VERSION={version}&TYPENAME=as_symbols&SRSNAME={srsName}&BBOX={bbox},{srsName}'.format(version=version, srsName=srsName, bbox=bbox_text)
header, body = self._execute_request(req)
self.assertTrue(b'gid>7' in body, "GetFeature Failed: %s , %s, lat_lon=%s" % (version, srsName, lat_lon))
_test_getFeature('1.1.0', 'urn:ogc:def:crs:EPSG::4326', lat_lon=True)
_test_getFeature('1.1.0', 'EPSG:4326', lat_lon=False)
_test_getFeature('1.0.0', 'urn:ogc:def:crs:EPSG::4326', lat_lon=True)
_test_getFeature('1.0.0', 'EPSG:4326', lat_lon=False)
# Cleanup
self.assertTrue(vl.startEditing())
vl.selectByExpression('"name" LIKE \'4326-test%\'')
vl.deleteSelectedFeatures()
self.assertTrue(vl.commitChanges())
def open_file(
dialog=None,
osm_file=None,
output_geom_types=None,
white_list_column=None,
output_format=None,
layer_name="OsmFile",
config_outputs=None,
output_dir=None,
prefix_file=None,
):
"""
open an osm file
"""
outputs = get_outputs(output_dir, output_format, prefix_file, layer_name)
# Parsing the file
osm_parser = OsmParser(osm_file=osm_file, layers=output_geom_types, white_list_column=white_list_column)
osm_parser.signalText.connect(dialog.set_progress_text)
osm_parser.signalPercentage.connect(dialog.set_progress_percentage)
layers = osm_parser.parse()
# Finishing the process with geojson or shapefile
num_layers = 0
if output_format == "shape":
dialog.set_progress_text(tr("QuickOSM", u"From GeoJSON to Shapefile"))
for i, (layer, item) in enumerate(layers.iteritems()):
dialog.set_progress_percentage(i / len(layers) * 100)
QApplication.processEvents()
if item["featureCount"] and layer in output_geom_types:
final_layer_name = layer_name
# If configOutputs is not None (from My Queries)
if config_outputs:
if config_outputs[layer]["namelayer"]:
final_layer_name = config_outputs[layer]["namelayer"]
# Transforming the vector file
osm_geometries = {
"points": QGis.WKBPoint,
"lines": QGis.WKBLineString,
"multilinestrings": QGis.WKBMultiLineString,
"multipolygons": QGis.WKBMultiPolygon,
}
geojson_layer = QgsVectorLayer(item["geojsonFile"], "temp", "ogr")
encoding = get_default_encoding()
if output_format == "shape":
writer = QgsVectorFileWriter(
outputs[layer],
encoding,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs(),
"ESRI Shapefile",
)
else:
writer = QgsVectorFileWriter(
outputs[layer],
encoding,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs(),
"GeoJSON",
)
for f in geojson_layer.getFeatures():
writer.addFeature(f)
del writer
# Loading the final vector file
new_layer = QgsVectorLayer(outputs[layer], final_layer_name, "ogr")
# Try to set styling if defined
if config_outputs and config_outputs[layer]["style"]:
new_layer.loadNamedStyle(config_outputs[layer]["style"])
else:
# Loading default styles
if layer == "multilinestrings" or layer == "lines":
if "colour" in item["tags"]:
new_layer.loadNamedStyle(
join(dirname(dirname(abspath(__file__))), "styles", layer + "_colour.qml")
)
# Add action about OpenStreetMap
actions = new_layer.actions()
actions.addAction(
QgsAction.OpenUrl,
"OpenStreetMap Browser",
"http://www.openstreetmap.org/browse/" '[% "osm_type" %]/[% "osm_id" %]',
False,
)
actions.addAction(
QgsAction.GenericPython,
"JOSM",
"from QuickOSM.CoreQuickOSM.Actions import Actions;" 'Actions.run("josm","[% "full_id" %]")',
False,
)
actions.addAction(
QgsAction.OpenUrl,
"User default editor",
"http://www.openstreetmap.org/edit?" '[% "osm_type" %]=[% "osm_id" %]',
False,
)
for link in ["url", "website", "wikipedia", "ref:UAI"]:
if link in item["tags"]:
link = link.replace(":", "_")
actions.addAction(
QgsAction.GenericPython,
link,
"from QuickOSM.core.actions import Actions;"
'Actions.run("' + link + '","[% "' + link + '" %]")',
False,
)
if "network" in item["tags"] and "ref" in item["tags"]:
actions.addAction(
QgsAction.GenericPython,
"Sketchline",
"from QuickOSM.core.actions import Actions;"
'Actions.run_sketch_line("[% "network" %]","[% "ref" %]")',
False,
)
# Add index if possible
if output_format == "shape":
new_layer.dataProvider().createSpatialIndex()
QgsMapLayerRegistry.instance().addMapLayer(new_layer)
num_layers += 1
return num_layers
def nodeCreateVectorLayer(nodename, position='bottom',target_node=None,path=None,source="Point",crs=None,providertype="ESRI Shapefile",indexfieldname='id'):
if target_node == None:
target_node = QgsProject.instance().layerTreeRoot()
else:
if oeq_global.isStringOrUnicode(target_node):
target_node = nodeByName(target_node)
if len(target_node) == 0:
return None
target_node = target_node[0]
if path == None:
path= oeq_global.OeQ_project_path()
if crs == None:
crs = config.project_crs
new_layer = QgsVectorLayer(source + '?crs=' + crs, nodename, "memory")
new_layer.setProviderEncoding('System')
#test
dataprovider = new_layer.dataProvider()
dataprovider.addAttributes([QgsField(indexfieldname, QVariant.Int)])
new_layer.updateFields()
writer = QgsVectorFileWriter.writeAsVectorFormat(new_layer, os.path.join(path , nodename+'.shp'), "System", new_layer.crs(), providertype)
if writer != QgsVectorFileWriter.NoError:
oeq_global.OeQ_push_error(title='Write Error:', message=os.path.join(path , nodename+'.shp'))
return None
del writer
oeq_global.OeQ_wait_for_file(os.path.join(path , nodename+'.shp'))
iface.addVectorLayer(os.path.join(path , nodename+'.shp'),nodename, 'ogr')
#oeq_global.OeQ_wait_for_renderer(60000)
new_node = nodeMove(nodename,position,target_node)
new_layer = new_node.layer()
#dataprovider = new_layer.dataProvider()
#dataprovider.addAttributes([QgsField(indexfieldname, QVariant.Int)])
#new_layer.updateFields()
#oeq_global.OeQ_unlockQgis()
return new_node
