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 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 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 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 _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