def createReferencingLayer(): layer = QgsVectorLayer("Point?field=fldtxt:string&field=foreignkey:integer", "referencinglayer", "memory") pr = layer.dataProvider() f1 = QgsFeature() f1.setFields(layer.pendingFields()) f1.setAttributes(["test1", 123]) f1.setGeometry(QgsGeometry.fromPoint(QgsPoint(100, 200))) f2 = QgsFeature() f2.setFields(layer.pendingFields()) f2.setAttributes(["test2", 123]) f2.setGeometry(QgsGeometry.fromPoint(QgsPoint(101, 201))) assert pr.addFeatures([f1, f2]) return layer
def add_flooded_field(self, shapefile_path): """Create the layer from the local shp adding the flooded field. .. versionadded:: 3.3 Use this method to add a calculated field to a shapefile. The shapefile should have a field called 'count' containing the number of flood reports for the field. The field values will be set to 0 if the count field is < 1, otherwise it will be set to 1. :param shapefile_path: Path to the shapefile that will have the flooded field added. :type shapefile_path: basestring :return: A vector layer with the flooded field added. :rtype: QgsVectorLayer """ layer = QgsVectorLayer( shapefile_path, self.tr('Jakarta Floods'), 'ogr') # Add a calculated field indicating if a poly is flooded or not # from PyQt4.QtCore import QVariant layer.startEditing() # Add field with integer from 0 to 4 which represents the flood # class. Its the same as 'state' field except that is being treated # as a string. # This is used for cartography flood_class_field = QgsField('floodclass', QVariant.Int) layer.dataProvider().addAttributes([flood_class_field]) layer.commitChanges() layer.startEditing() flood_class_idx = layer.fieldNameIndex('floodclass') flood_class_expression = QgsExpression('to_int(state)') flood_class_expression.prepare(layer.pendingFields()) # Add field with boolean flag to say if the area is flooded # This is used by the impact function flooded_field = QgsField('flooded', QVariant.Int) layer.dataProvider().addAttributes([flooded_field]) layer.commitChanges() layer.startEditing() flooded_idx = layer.fieldNameIndex('flooded') flood_flag_expression = QgsExpression('state > 0') flood_flag_expression.prepare(layer.pendingFields()) for feature in layer.getFeatures(): feature[flood_class_idx] = flood_class_expression.evaluate(feature) feature[flooded_idx] = flood_flag_expression.evaluate(feature) layer.updateFeature(feature) layer.commitChanges() return layer
def createReferencingLayer(): layer = QgsVectorLayer("Point?field=fldtxt:string&field=foreignkey:integer", "referencinglayer", "memory") pr = layer.dataProvider() f1 = QgsFeature() f1.setFields(layer.pendingFields()) f1.setAttributes(["test1", 123]) f2 = QgsFeature() f2.setFields(layer.pendingFields()) f2.setAttributes(["test2", 123]) f3 = QgsFeature() f3.setFields(layer.pendingFields()) f3.setAttributes(["foobar'bar", 124]) assert pr.addFeatures([f1, f2, f3]) return layer
def __createMemoryLayer(self, layer_name, gtype, geometries, attributes, fNames, fTypes): """ Create a memory layer from parameters :param layer_name: name for the layer :param gtype: geometry type of the layer :param geometries: objects geometries :param attributes: objects attributes :param fNames: fields names :param fTypes: fields types """ layerList = QgsMapLayerRegistry.instance().mapLayersByName(layer_name) if layerList: QgsMapLayerRegistry.instance().removeMapLayers([layerList[0].id()]) epsg = self.canvas().mapRenderer().destinationCrs().authid() fieldsParam = "" for i in range(len(fNames)): fieldsParam += "&field=" + fNames[i] + ":" + fTypes[i] layer = QgsVectorLayer(gtype + "?crs=" + epsg + fieldsParam + "&index=yes", layer_name, "memory") QgsMapLayerRegistry.instance().addMapLayer(layer) layer.startEditing() for i in range(len(geometries)): feature = QgsFeature() feature.setGeometry(QgsGeometry().fromWkt(geometries[i])) fields = layer.pendingFields() feature.setFields(fields) for j in range(len(fNames)): feature.setAttribute(fNames[j], attributes[i][j]) layer.addFeature(feature) layer.commitChanges()
def add_flooded_field(self, shapefile_path): """Create the layer from the local shp adding the flooded field. .. versionadded:: 3.3 Use this method to add a calculated field to a shapefile. The shapefile should have a field called 'count' containing the number of flood reports for the field. The field values will be set to 0 if the count field is < 1, otherwise it will be set to 1. :param shapefile_path: Path to the shapefile that will have the flooded field added. :type shapefile_path: basestring :return: A vector layer with the flooded field added. :rtype: QgsVectorLayer """ layer = QgsVectorLayer( shapefile_path, self.tr('Jakarta Floods'), 'ogr') # Add a calculated field indicating if a poly is flooded or not # from PyQt4.QtCore import QVariant layer.startEditing() field = QgsField('flooded', QVariant.Int) layer.dataProvider().addAttributes([field]) layer.commitChanges() layer.startEditing() idx = layer.fieldNameIndex('flooded') expression = QgsExpression('state > 0') expression.prepare(layer.pendingFields()) for feature in layer.getFeatures(): feature[idx] = expression.evaluate(feature) layer.updateFeature(feature) layer.commitChanges() return layer
def createReferencedLayer(): layer = QgsVectorLayer( "Point?field=x:string&field=y:integer&field=z:integer", "referencedlayer", "memory") pr = layer.dataProvider() f1 = QgsFeature() f1.setFields(layer.pendingFields()) f1.setAttributes(["foo", 123, 321]) f2 = QgsFeature() f2.setFields(layer.pendingFields()) f2.setAttributes(["bar", 456, 654]) f3 = QgsFeature() f3.setFields(layer.pendingFields()) f3.setAttributes(["foobar'bar", 789, 554]) assert pr.addFeatures([f1, f2, f3]) return layer
def processAlgorithm(self, progress): 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()) 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.pendingFields().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) progress.setPercentage(int(current * total)) del writer
def loadData(self, resultFile, chunkId): """ Load data to the map """ if isMimeTypeVector(self.mimeType, True) != None: # Memory layer: geometryTypes = ["Point","LineString","Polygon","Unknown", "NoGeometry"] vlayer = QgsVectorLayer(resultFile, "chunk", "ogr") if self.__bFirstChunk: self.__bFirstChunk = False self.__geometryType = geometryTypes[vlayer.geometryType()] self.__bGeomMulti = vlayer.wkbType() in [4,5,6,11,12,13] self.__memoryLayer = QgsVectorLayer(self.__geometryType,"Streamed data","memory") self.__memoryLayer.dataProvider().addAttributes(vlayer.pendingFields().values()) self.__memoryLayer.updateFieldMap() provider = vlayer.dataProvider() allAttrs = provider.attributeIndexes() vlayer.select(allAttrs) # Visualize temporal geometries during the downloading process # Don't add temporal geometries if last chunk if self.DEBUG: print "Loaded chunkId:",chunkId res = self.__memoryLayer.dataProvider().addFeatures( [feat for feat in vlayer] ) self.__deliveredChunks += 1 if not self.allChunksDelivered(): inFeat = QgsFeature() inGeom = QgsGeometry() self.createTempGeometry(chunkId, self.__geometryType) while provider.nextFeature( inFeat ): inGeom = inFeat.geometry() featList = self.extractAsSingle(self.__geometryType, inGeom) if self.__bGeomMulti else [inGeom] for geom in featList: self.addTempGeometry(chunkId, self.__geometryType, geom) else: self.finishLoading() # Raster data elif isMimeTypeRaster(self.mimeType, True) != None: # We can directly attach the new layer if self.__bFirstChunk: self.__bFirstChunk = False self.__groupIndex = self.__legend.addGroup("Streamed-raster") rLayer = QgsRasterLayer(resultFile, "raster_"+str(chunkId)) bLoaded = QgsMapLayerRegistry.instance().addMapLayer(rLayer) self.stretchRaster(rLayer) self.__legend.moveLayer(rLayer, self.__groupIndex + 1) self.__deliveredChunks += 1 if self.allChunksDelivered(): self.finishLoading()
def test_ExpressionFieldNestedGeometry(self): myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp') layer = QgsVectorLayer(myShpFile, 'Points', 'ogr') self.assertTrue(layer.isValid()) cnt = layer.pendingFields().count() idx = layer.addExpressionField('$x*2', QgsField('exp1', QVariant.LongLong)) idx = layer.addExpressionField('"exp1"/1.5', QgsField('exp2', QVariant.LongLong)) fet = next(layer.getFeatures(QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry).setSubsetOfAttributes(['exp2'], layer.fields()))) # nested virtual fields should have made geometry be fetched self.assertEqual(fet['exp2'], -156) self.assertEqual(fet['exp1'], -234)
def test_ExpressionFieldNested(self): myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp') layer = QgsVectorLayer(myShpFile, 'Points', 'ogr') self.assertTrue(layer.isValid()) cnt = layer.pendingFields().count() idx = layer.addExpressionField('"Staff"*2', QgsField('exp1', QVariant.LongLong)) idx = layer.addExpressionField('"exp1"-1', QgsField('exp2', QVariant.LongLong)) fet = next(layer.getFeatures(QgsFeatureRequest().setSubsetOfAttributes(['exp2'], layer.fields()))) self.assertEqual(fet['Class'], NULL) # nested virtual fields should make all these attributes be fetched self.assertEqual(fet['Staff'], 2) self.assertEqual(fet['exp2'], 3) self.assertEqual(fet['exp1'], 4)
def test_ExpressionFieldNestedCircular(self): """ test circular virtual field definitions """ myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp') layer = QgsVectorLayer(myShpFile, 'Points', 'ogr') self.assertTrue(layer.isValid()) cnt = layer.pendingFields().count() # NOQA idx = layer.addExpressionField('"exp3"*2', QgsField('exp1', QVariant.LongLong)) # NOQA idx = layer.addExpressionField('"exp1"-1', QgsField('exp2', QVariant.LongLong)) # NOQA idx = layer.addExpressionField('"exp2"*3', QgsField('exp3', QVariant.LongLong)) # NOQA # really just testing that this doesn't hang/crash... there's no good result here! fet = next(layer.getFeatures(QgsFeatureRequest().setSubsetOfAttributes(['exp2'], layer.fields()))) self.assertEqual(fet['Class'], NULL)
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 rotation_test(self): # We will create a polygon layer with a rotated rectangle. # Then we will make it the object layer for the atlas, # rotate the map and test that the bounding rectangle # is smaller than the bounds without rotation. polygonLayer = QgsVectorLayer('Polygon', 'test_polygon', 'memory') poly = QgsFeature(polygonLayer.pendingFields()) points = [(10, 15), (15, 10), (45, 40), (40, 45)] poly.setGeometry(QgsGeometry.fromPolygon([[QgsPointXY(x[0], x[1]) for x in points]])) polygonLayer.dataProvider().addFeatures([poly]) QgsProject.instance().addMapLayer(polygonLayer) # Recreating the composer locally composition = QgsComposition(QgsProject.instance()) composition.setPaperSize(297, 210) # the atlas map atlasMap = QgsComposerMap(composition, 20, 20, 130, 130) atlasMap.setFrameEnabled(True) atlasMap.setLayers([polygonLayer]) atlasMap.setNewExtent(QgsRectangle(0, 0, 100, 50)) composition.addComposerMap(atlasMap) # the atlas atlas = composition.atlasComposition() atlas.setCoverageLayer(polygonLayer) atlas.setEnabled(True) composition.setAtlasMode(QgsComposition.ExportAtlas) atlasMap.setAtlasDriven(True) atlasMap.setAtlasScalingMode(QgsComposerMap.Auto) atlasMap.setAtlasMargin(0.0) # Testing atlasMap.setMapRotation(0.0) atlas.firstFeature() nonRotatedExtent = QgsRectangle(atlasMap.currentMapExtent()) atlasMap.setMapRotation(45.0) atlas.firstFeature() rotatedExtent = QgsRectangle(atlasMap.currentMapExtent()) assert rotatedExtent.width() < nonRotatedExtent.width() * 0.9 assert rotatedExtent.height() < nonRotatedExtent.height() * 0.9 QgsProject.instance().removeMapLayer(polygonLayer)
def f(): crs = iface.mapCanvas().mapRenderer().destinationCrs() uri = "%s?srsname=%s&typename=geonode:%s&version=1.0.0&request=GetFeature&service=WFS" % (url, crs.authid(), name) qgslayer = QgsVectorLayer(uri, name, "WFS") if not qgslayer.isValid(): raise Exception ("Layer at %s is not a valid layer" % uri) fieldname = self._getTimeField(qgslayer) if fieldname is None: QgsMapLayerRegistry.instance().addMapLayers([qgslayer]) else: memlayer = QgsVectorLayer("%s?crs=%s" % (GEOM_TYPE_MAP[qgslayer.wkbType()], crs.authid()), name, "memory") memlayer.startEditing() for field in qgslayer.pendingFields(): memlayer.addAttribute(field) for feat in qgslayer.getFeatures(): memlayer.addFeatures([feat]) memlayer.commitChanges() QgsMapLayerRegistry.instance().addMapLayers([memlayer]) memlayer.setSelectedFeatures([]) addWfsAnimation(memlayer, fieldname)
def test_ExpressionFieldNestedCircular(self): """ test circular virtual field definitions """ myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp') layer = QgsVectorLayer(myShpFile, 'Points', 'ogr') self.assertTrue(layer.isValid()) cnt = layer.pendingFields().count() # NOQA idx = layer.addExpressionField('"exp3"*2', QgsField('exp1', QVariant.LongLong)) # NOQA idx = layer.addExpressionField('"exp1"-1', QgsField('exp2', QVariant.LongLong)) # NOQA idx = layer.addExpressionField('"exp2"*3', QgsField('exp3', QVariant.LongLong)) # NOQA # really just testing that this doesn't hang/crash... there's no good result here! fet = next( layer.getFeatures(QgsFeatureRequest().setSubsetOfAttributes( ['exp2'], layer.fields()))) self.assertEqual(fet['Class'], NULL)
shp_filename = sys.argv[2] try: m = crayfish.Mesh(sys.argv[1]) except ValueError: print "Failed to load mesh in %s" % sys.argv[1] sys.exit(1) from qgis.core import QgsApplication, QgsVectorLayer, QgsVectorFileWriter, QgsPoint, QgsGeometry, QgsFeature a = QgsApplication([], True) a.initQgis() vl = QgsVectorLayer("Point?field=node_id:integer&field=value:double", "nodes", "memory") flds = vl.pendingFields() o = m.dataset(0).output(0) lst = [] for index, n in enumerate(m.nodes()): f = QgsFeature() f.setFields(flds) f.setGeometry(QgsGeometry.fromPoint(QgsPoint(n.x, n.y))) f[0] = n.id f[1] = o.value(index) lst.append(f) vl.dataProvider().addFeatures(lst) QgsVectorFileWriter.writeAsVectorFormat(vl, shp_filename, '', None)
def WPT2Layer(self): mapUnits = define._canvas.mapUnits() if define._mapCrs == None: if mapUnits == QGis.Meters: resultLayer = QgsVectorLayer( "Point?crs=EPSG:32633", "WPT_" + self.surfaceType.replace(" ", "_").replace("-", "_"), "memory") else: resultLayer = QgsVectorLayer( "Point?crs=EPSG:4326", "WPT_" + self.surfaceType.replace(" ", "_").replace("-", "_"), "memory") else: resultLayer = QgsVectorLayer( "Point?crs=%s" % define._mapCrs.authid(), "WPT_" + self.surfaceType.replace(" ", "_").replace("-", "_"), "memory") shpPath = "" if define.obstaclePath != None: shpPath = define.obstaclePath elif define.xmlPath != None: shpPath = define.xmlPath else: shpPath = define.appPath er = QgsVectorFileWriter.writeAsVectorFormat( resultLayer, shpPath + "/" + "RnavTurningSegmentAnalyserWpt" + ".shp", "utf-8", resultLayer.crs()) resultLayer = QgsVectorLayer( shpPath + "/" + "RnavTurningSegmentAnalyserWpt" + ".shp", "WPT_RnavTurningSegmentAnalyser", "ogr") fieldName = "CATEGORY" resultLayer.dataProvider().addAttributes( [QgsField(fieldName, QVariant.String)]) resultLayer.startEditing() fields = resultLayer.pendingFields() i = 1 feature = QgsFeature() feature.setFields(fields) feature.setGeometry( QgsGeometry.fromPoint(self.parametersPanel.pnlWaypoint1.Point3d)) feature.setAttribute(fieldName, "Waypoint1") pr = resultLayer.dataProvider() pr.addFeatures([feature]) # resultLayer.addFeature(feature) feature.setGeometry( QgsGeometry.fromPoint(self.parametersPanel.pnlWaypoint2.Point3d)) feature.setAttribute(fieldName, "Waypoint2") pr = resultLayer.dataProvider() pr.addFeatures([feature]) # resultLayer.addFeature(feature) resultLayer.commitChanges() renderCatFly = None if self.parametersPanel.cmbType1.SelectedIndex == 1: '''FlyOver''' symbolFlyOver = QgsSymbolV2.defaultSymbol( resultLayer.geometryType()) symbolFlyOver.deleteSymbolLayer(0) svgSymLayer = QgsSvgMarkerSymbolLayerV2("Resource/flyover.svg", 10.0, 0.0) symbolFlyOver.appendSymbolLayer(svgSymLayer) renderCatFly = QgsRendererCategoryV2(0, symbolFlyOver, "Fly Over") elif self.parametersPanel.cmbType1.SelectedIndex == 0: '''FlyBy''' symbolFlyBy = QgsSymbolV2.defaultSymbol(resultLayer.geometryType()) symbolFlyBy.deleteSymbolLayer(0) svgSymLayer = QgsSvgMarkerSymbolLayerV2("Resource/flyby.svg", 10.0, 0.0) symbolFlyBy.appendSymbolLayer(svgSymLayer) renderCatFly = QgsRendererCategoryV2(0, symbolFlyBy, "Fly By") else: return None WPT_EXPRESION = "CASE WHEN \"CATEGORY\" = 'Waypoint1' THEN 0 " + \ "END" symRenderer = QgsCategorizedSymbolRendererV2(WPT_EXPRESION, [renderCatFly]) resultLayer.setRendererV2(symRenderer) return resultLayer
class mesh_canvas(QgsMapCanvas): def __init__(self,iface,tile_name,tile_credit,tile_url,tile_zmin,tile_zmax,tile_bbox): QgsMapCanvas.__init__(self) self.iface = iface self.setWheelAction(QgsMapCanvas.WheelZoom,1) self.setDestinationCrs(self.iface.mapCanvas().mapSettings().destinationCrs()) self.setCrsTransformEnabled(True) self.iface.mapCanvas().destinationCrsChanged.connect(self.onCrsChanged) self.iface.mapCanvas().extentsChanged.connect(self.onExtentsChanged) self.iface.mapCanvas().scaleChanged.connect(self.onScaleChanged) layerdef = TileLayerDefinition(tile_name, tile_credit, tile_url, zmin=tile_zmin, zmax=tile_zmax, bbox=tile_bbox) creditVisibility=True plugin = plugins.get("TileLayerPlugin") self.chirin_layer = TileLayer(plugin,layerdef, creditVisibility) QgsMapLayerRegistry.instance().addMapLayer(self.chirin_layer,False) self.meshPolyLayer = QgsVectorLayer("polygon?crs=postgis:4612",u"地域メッシュインデックス","memory") renderer = self.meshPolyLayer.rendererV2() renderer.symbols()[0].symbolLayers()[0].setFillColor(QtGui.QColor(0,0,0,0)) renderer.symbols()[0].symbolLayers()[0].setBorderWidth(0.1) self.meshPolyLayer.label().setLabelField(0,0) self.meshPolyLayer.startEditing() self.meshPolyLayer.addAttribute(QgsField("meshC",QtCore.QVariant.String)) self.meshPolyLayer.commitChanges() QgsMapLayerRegistry.instance().addMapLayer(self.meshPolyLayer,False) main_crs = self.iface.mapCanvas().mapSettings().destinationCrs() self.Trs_laln = QgsCoordinateTransform(main_crs,QgsCoordinateReferenceSystem(4612)) self.redraw_mesh() layers = [] layers.append(QgsMapCanvasLayer(self.meshPolyLayer)) layers.append(QgsMapCanvasLayer(self.chirin_layer)) self.setLayerSet(layers) self.setExtent( self.iface.mapCanvas().extent() ) self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint) self.resize(self.iface.mapCanvas().size()/2) def onCrsChanged(self): main_crs = self.iface.mapCanvas().mapSettings().destinationCrs() self.setDestinationCrs(main_crs) def onExtentsChanged(self): self.setExtent( self.iface.mapCanvas().extent() ) self.redraw_mesh() self.refresh() def onScaleChanged(self): self.resize(self.iface.mapCanvas().size()/2) def PPopend(self): self.iface.mapCanvas().extentsChanged.disconnect() self.iface.mapCanvas().scaleChanged.disconnect() def res_mesh_index(self,latitude,longitude): x1d = math.floor(longitude - 100) x2d = math.floor((longitude - x1d - 100 ) * 8 ) x3d = math.floor((longitude - x1d - 100 - x2d/8.0 )*80 ) y1d = math.floor(latitude*1.5) y2d = math.floor((latitude*1.5 - y1d ) * 8 ) y3d = math.floor((latitude*1.5 - y1d - y2d/8.0 )*80 ) return (x1d,x2d,x3d,y1d,y2d,y3d) def res_extent_mesh(self): main_crs = self.iface.mapCanvas().mapSettings().destinationCrs() self.Trs_laln.setSourceCrs(main_crs) my_rect = self.iface.mapCanvas().extent() laln_rect = self.Trs_laln.transform(my_rect) x_min = laln_rect.xMinimum() x_max = laln_rect.xMaximum() y_min = laln_rect.yMinimum() y_max = laln_rect.yMaximum() Lx1d,Lx2d,Lx3d,Ly1d,Ly2d,Ly3d = self.res_mesh_index(y_min, x_min) Rx1d,Rx2d,Rx3d,Uy1d,Uy2d,Uy3d = self.res_mesh_index(y_max, x_max) x_range = x_max - x_min y_range = y_max - y_min return {"Lx1d":Lx1d,"Lx2d":Lx2d,"Lx3d":Lx3d, "Rx1d":Rx1d,"Rx2d":Rx2d,"Rx3d":Rx3d, "Ly1d":Ly1d,"Ly2d":Ly2d,"Ly3d":Ly3d, "Uy1d":Uy1d,"Uy2d":Uy2d,"Uy3d":Uy3d, "xRange":x_range,"yRange":y_range} def draw_m1d(self): x = self.e_mesh["Lx1d"] -1 while x <= self.e_mesh["Rx1d"] + 1: y = self.e_mesh["Ly1d"] while y <= self.e_mesh["Uy1d"]: f = QgsFeature(self.meshPolyLayer.pendingFields()) f.setGeometry(QgsGeometry.fromPolygon( [[QgsPoint(x+100,y/1.5),QgsPoint(x+100,(y+1)/1.5), QgsPoint(x+101,(y+1)/1.5),QgsPoint(x+101,y/1.5)]])) m1d_str = str(int(y)) + str(int(x)) f.setAttribute("meshC",m1d_str) self.meshPolyLayer.addFeature(f) y += 1 x += 1 def draw_m2d(self): x = self.e_mesh["Lx1d"] + self.e_mesh["Lx2d"] / 8.0 - 1 / 8.0 while x <= self.e_mesh["Rx1d"] + self.e_mesh["Rx2d"] / 8.0 + 1 / 8.0: x1d = math.floor(x) x2d = math.floor((x-x1d)*8) y = self.e_mesh["Ly1d"] + self.e_mesh["Ly2d"] / 8.0 - 1 / 8.0 while y <= self.e_mesh["Uy1d"] + self.e_mesh["Uy2d"] + 1 / 8.0: y1d = math.floor(y) y2d = math.floor((y-y1d)*8) f = QgsFeature(self.meshPolyLayer.pendingFields()) f.setGeometry(QgsGeometry.fromPolygon( [[QgsPoint(x+100,y/1.5),QgsPoint(x+100,(y+1/8.0)/1.5), QgsPoint(x+100+1/8.0,(y+1/8.0)/1.5),QgsPoint(x+100+1/8.0,y/1.5)]])) m1d_str = str(int(y1d)) + str(int(x1d)) m2d_str = str(int(y2d)) + str(int(x2d)) mesh_str = m1d_str + m2d_str f.setAttribute("meshC",mesh_str) self.meshPolyLayer.addFeature(f) y += 1/8.0 x += 1/8.0 def draw_m3d(self): x = self.e_mesh["Lx1d"] + self.e_mesh["Lx2d"] / 8.0 + self.e_mesh["Lx3d"] / 80.0 - 1 / 80.0 while x <= self.e_mesh["Rx1d"] + self.e_mesh["Rx2d"] / 8.0 + self.e_mesh["Rx3d"] / 80.0 + 1 / 80.0: x1d = math.floor(x) x2d = math.floor((x-x1d)*8) x3d = math.floor((x-x1d-x2d/8.0)*80) y = self.e_mesh["Ly1d"] + self.e_mesh["Ly2d"] / 8.0 + self.e_mesh["Ly3d"] / 80.0 - 1 / 80.0 while y <= self.e_mesh["Uy1d"] + self.e_mesh["Uy2d"] / 8.0 + self.e_mesh["Uy3d"] / 80.0 + 1 / 80.0: y1d = math.floor(y) y2d = math.floor((y-y1d)*8) y3d = math.floor((y-y1d-y2d/8.0)*80) f = QgsFeature(self.meshPolyLayer.pendingFields()) f.setGeometry(QgsGeometry.fromPolygon( [[QgsPoint(x+100,y/1.5),QgsPoint(x+100,(y+1/80.0)/1.5), QgsPoint(x+100+1/80.0,(y+1/80.0)/1.5),QgsPoint(x+100+1/80.0,y/1.5)]])) m1d_str = str(int(y1d)) + str(int(x1d)) m2d_str = str(int(y2d)) + str(int(x2d)) m3d_str = str(int(y3d)) + str(int(x3d)) mesh_str = m1d_str + m2d_str + m3d_str f.setAttribute("meshC",mesh_str) self.meshPolyLayer.addFeature(f) y += 1/80.0 x += 1/80.0 def draw_m5x(self): x = self.e_mesh["Lx1d"] - 1 while x <= self.e_mesh["Rx1d"]+1: x1d = math.floor(x) x2d = math.floor((x-x1d)*8) x5x = math.floor((x-x1d-x2d/8.0)*16) y = self.e_mesh["Ly1d"] - 1 while y <= self.e_mesh["Uy1d"]+1: y1d = math.floor(y) y2d = math.floor((y-y1d)*8) y5x = math.floor((y-y1d-y2d/8.0)*16) f = QgsFeature(self.meshPolyLayer.pendingFields()) f.setGeometry(QgsGeometry.fromPolygon( [[QgsPoint(x+100,y/1.5),QgsPoint(x+100,(y+1/16.0)/1.5), QgsPoint(x+100+1/16.0,(y+1/16.0)/1.5),QgsPoint(x+100+1/16.0,y/1.5)]])) m1d_str = str(int(y1d)) + str(int(x1d)) m2d_str = str(int(y2d)) + str(int(x2d)) m5x_str = str(int(x5x+y5x*2+1)) mesh_str = m1d_str + "-" + m2d_str + "-" + m5x_str f.setAttribute("meshC",mesh_str) self.meshPolyLayer.addFeature(f) y += 1/16.0 x += 1/16.0 def redraw_mesh(self): self.e_mesh = self.res_extent_mesh() if self.e_mesh["xRange"] < 50: self.meshPolyLayer.startEditing() self.meshPolyLayer.selectAll() self.meshPolyLayer.deleteSelectedFeatures() if self.e_mesh["xRange"] > 2.0: self.draw_m1d() elif self.e_mesh["xRange"] > 1.0/8.0: self.draw_m2d() else: self.draw_m3d() self.meshPolyLayer.commitChanges() self.meshPolyLayer.enableLabels(self.e_mesh["xRange"] <= 8.0) def closeEvent(self,event): QgsMapLayerRegistry.instance().removeMapLayers( [ self.meshPolyLayer.id(), self.chirin_layer.id() ]) self.iface.mapCanvas().destinationCrsChanged.disconnect() self.iface.mapCanvas().extentsChanged.disconnect() self.iface.mapCanvas().scaleChanged.disconnect()
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 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 mesh_canvas(QgsMapCanvas): def __init__(self, iface, tile_name, tile_credit, tile_url, tile_zmin, tile_zmax, tile_bbox): QgsMapCanvas.__init__(self) self.iface = iface self.setWheelAction(QgsMapCanvas.WheelZoom, 1) self.setDestinationCrs( self.iface.mapCanvas().mapSettings().destinationCrs()) self.setCrsTransformEnabled(True) self.iface.mapCanvas().destinationCrsChanged.connect(self.onCrsChanged) self.iface.mapCanvas().extentsChanged.connect(self.onExtentsChanged) self.iface.mapCanvas().scaleChanged.connect(self.onScaleChanged) layerdef = TileLayerDefinition(tile_name, tile_credit, tile_url, zmin=tile_zmin, zmax=tile_zmax, bbox=tile_bbox) creditVisibility = True plugin = plugins.get("TileLayerPlugin") self.chirin_layer = TileLayer(plugin, layerdef, creditVisibility) QgsMapLayerRegistry.instance().addMapLayer(self.chirin_layer, False) self.meshPolyLayer = QgsVectorLayer("polygon?crs=postgis:4612", u"地域メッシュインデックス", "memory") renderer = self.meshPolyLayer.rendererV2() renderer.symbols()[0].symbolLayers()[0].setFillColor( QtGui.QColor(0, 0, 0, 0)) renderer.symbols()[0].symbolLayers()[0].setBorderWidth(0.1) self.meshPolyLayer.label().setLabelField(0, 0) self.meshPolyLayer.startEditing() self.meshPolyLayer.addAttribute( QgsField("meshC", QtCore.QVariant.String)) self.meshPolyLayer.commitChanges() QgsMapLayerRegistry.instance().addMapLayer(self.meshPolyLayer, False) main_crs = self.iface.mapCanvas().mapSettings().destinationCrs() self.Trs_laln = QgsCoordinateTransform( main_crs, QgsCoordinateReferenceSystem(4612)) self.redraw_mesh() layers = [] layers.append(QgsMapCanvasLayer(self.meshPolyLayer)) layers.append(QgsMapCanvasLayer(self.chirin_layer)) self.setLayerSet(layers) self.setExtent(self.iface.mapCanvas().extent()) self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint) self.resize(self.iface.mapCanvas().size() / 2) def onCrsChanged(self): main_crs = self.iface.mapCanvas().mapSettings().destinationCrs() self.setDestinationCrs(main_crs) def onExtentsChanged(self): self.setExtent(self.iface.mapCanvas().extent()) self.redraw_mesh() self.refresh() def onScaleChanged(self): self.resize(self.iface.mapCanvas().size() / 2) def PPopend(self): self.iface.mapCanvas().extentsChanged.disconnect() self.iface.mapCanvas().scaleChanged.disconnect() def res_mesh_index(self, latitude, longitude): x1d = math.floor(longitude - 100) x2d = math.floor((longitude - x1d - 100) * 8) x3d = math.floor((longitude - x1d - 100 - x2d / 8.0) * 80) y1d = math.floor(latitude * 1.5) y2d = math.floor((latitude * 1.5 - y1d) * 8) y3d = math.floor((latitude * 1.5 - y1d - y2d / 8.0) * 80) return (x1d, x2d, x3d, y1d, y2d, y3d) def res_extent_mesh(self): main_crs = self.iface.mapCanvas().mapSettings().destinationCrs() self.Trs_laln.setSourceCrs(main_crs) my_rect = self.iface.mapCanvas().extent() laln_rect = self.Trs_laln.transform(my_rect) x_min = laln_rect.xMinimum() x_max = laln_rect.xMaximum() y_min = laln_rect.yMinimum() y_max = laln_rect.yMaximum() Lx1d, Lx2d, Lx3d, Ly1d, Ly2d, Ly3d = self.res_mesh_index(y_min, x_min) Rx1d, Rx2d, Rx3d, Uy1d, Uy2d, Uy3d = self.res_mesh_index(y_max, x_max) x_range = x_max - x_min y_range = y_max - y_min return { "Lx1d": Lx1d, "Lx2d": Lx2d, "Lx3d": Lx3d, "Rx1d": Rx1d, "Rx2d": Rx2d, "Rx3d": Rx3d, "Ly1d": Ly1d, "Ly2d": Ly2d, "Ly3d": Ly3d, "Uy1d": Uy1d, "Uy2d": Uy2d, "Uy3d": Uy3d, "xRange": x_range, "yRange": y_range } def draw_m1d(self): x = self.e_mesh["Lx1d"] - 1 while x <= self.e_mesh["Rx1d"] + 1: y = self.e_mesh["Ly1d"] while y <= self.e_mesh["Uy1d"]: f = QgsFeature(self.meshPolyLayer.pendingFields()) f.setGeometry( QgsGeometry.fromPolygon([[ QgsPoint(x + 100, y / 1.5), QgsPoint(x + 100, (y + 1) / 1.5), QgsPoint(x + 101, (y + 1) / 1.5), QgsPoint(x + 101, y / 1.5) ]])) m1d_str = str(int(y)) + str(int(x)) f.setAttribute("meshC", m1d_str) self.meshPolyLayer.addFeature(f) y += 1 x += 1 def draw_m2d(self): x = self.e_mesh["Lx1d"] + self.e_mesh["Lx2d"] / 8.0 - 1 / 8.0 while x <= self.e_mesh["Rx1d"] + self.e_mesh["Rx2d"] / 8.0 + 1 / 8.0: x1d = math.floor(x) x2d = math.floor((x - x1d) * 8) y = self.e_mesh["Ly1d"] + self.e_mesh["Ly2d"] / 8.0 - 1 / 8.0 while y <= self.e_mesh["Uy1d"] + self.e_mesh["Uy2d"] + 1 / 8.0: y1d = math.floor(y) y2d = math.floor((y - y1d) * 8) f = QgsFeature(self.meshPolyLayer.pendingFields()) f.setGeometry( QgsGeometry.fromPolygon([[ QgsPoint(x + 100, y / 1.5), QgsPoint(x + 100, (y + 1 / 8.0) / 1.5), QgsPoint(x + 100 + 1 / 8.0, (y + 1 / 8.0) / 1.5), QgsPoint(x + 100 + 1 / 8.0, y / 1.5) ]])) m1d_str = str(int(y1d)) + str(int(x1d)) m2d_str = str(int(y2d)) + str(int(x2d)) mesh_str = m1d_str + m2d_str f.setAttribute("meshC", mesh_str) self.meshPolyLayer.addFeature(f) y += 1 / 8.0 x += 1 / 8.0 def draw_m3d(self): x = self.e_mesh["Lx1d"] + self.e_mesh["Lx2d"] / 8.0 + self.e_mesh[ "Lx3d"] / 80.0 - 1 / 80.0 while x <= self.e_mesh["Rx1d"] + self.e_mesh[ "Rx2d"] / 8.0 + self.e_mesh["Rx3d"] / 80.0 + 1 / 80.0: x1d = math.floor(x) x2d = math.floor((x - x1d) * 8) x3d = math.floor((x - x1d - x2d / 8.0) * 80) y = self.e_mesh["Ly1d"] + self.e_mesh["Ly2d"] / 8.0 + self.e_mesh[ "Ly3d"] / 80.0 - 1 / 80.0 while y <= self.e_mesh["Uy1d"] + self.e_mesh[ "Uy2d"] / 8.0 + self.e_mesh["Uy3d"] / 80.0 + 1 / 80.0: y1d = math.floor(y) y2d = math.floor((y - y1d) * 8) y3d = math.floor((y - y1d - y2d / 8.0) * 80) f = QgsFeature(self.meshPolyLayer.pendingFields()) f.setGeometry( QgsGeometry.fromPolygon([[ QgsPoint(x + 100, y / 1.5), QgsPoint(x + 100, (y + 1 / 80.0) / 1.5), QgsPoint(x + 100 + 1 / 80.0, (y + 1 / 80.0) / 1.5), QgsPoint(x + 100 + 1 / 80.0, y / 1.5) ]])) m1d_str = str(int(y1d)) + str(int(x1d)) m2d_str = str(int(y2d)) + str(int(x2d)) m3d_str = str(int(y3d)) + str(int(x3d)) mesh_str = m1d_str + m2d_str + m3d_str f.setAttribute("meshC", mesh_str) self.meshPolyLayer.addFeature(f) y += 1 / 80.0 x += 1 / 80.0 def draw_m5x(self): x = self.e_mesh["Lx1d"] - 1 while x <= self.e_mesh["Rx1d"] + 1: x1d = math.floor(x) x2d = math.floor((x - x1d) * 8) x5x = math.floor((x - x1d - x2d / 8.0) * 16) y = self.e_mesh["Ly1d"] - 1 while y <= self.e_mesh["Uy1d"] + 1: y1d = math.floor(y) y2d = math.floor((y - y1d) * 8) y5x = math.floor((y - y1d - y2d / 8.0) * 16) f = QgsFeature(self.meshPolyLayer.pendingFields()) f.setGeometry( QgsGeometry.fromPolygon([[ QgsPoint(x + 100, y / 1.5), QgsPoint(x + 100, (y + 1 / 16.0) / 1.5), QgsPoint(x + 100 + 1 / 16.0, (y + 1 / 16.0) / 1.5), QgsPoint(x + 100 + 1 / 16.0, y / 1.5) ]])) m1d_str = str(int(y1d)) + str(int(x1d)) m2d_str = str(int(y2d)) + str(int(x2d)) m5x_str = str(int(x5x + y5x * 2 + 1)) mesh_str = m1d_str + "-" + m2d_str + "-" + m5x_str f.setAttribute("meshC", mesh_str) self.meshPolyLayer.addFeature(f) y += 1 / 16.0 x += 1 / 16.0 def redraw_mesh(self): self.e_mesh = self.res_extent_mesh() if self.e_mesh["xRange"] < 50: self.meshPolyLayer.startEditing() self.meshPolyLayer.selectAll() self.meshPolyLayer.deleteSelectedFeatures() if self.e_mesh["xRange"] > 2.0: self.draw_m1d() elif self.e_mesh["xRange"] > 1.0 / 8.0: self.draw_m2d() else: self.draw_m3d() self.meshPolyLayer.commitChanges() self.meshPolyLayer.enableLabels(self.e_mesh["xRange"] <= 8.0) def closeEvent(self, event): QgsMapLayerRegistry.instance().removeMapLayers( [self.meshPolyLayer.id(), self.chirin_layer.id()]) self.iface.mapCanvas().destinationCrsChanged.disconnect() self.iface.mapCanvas().extentsChanged.disconnect() self.iface.mapCanvas().scaleChanged.disconnect()
class InputNetworkTabManager(QtCore.QObject): ''' Class to hide managing of relative tab ''' projectModified = QtCore.pyqtSignal() def __init__(self, parent=None): '''constructor''' super(InputNetworkTabManager, self).__init__(parent) # parent is the dock widget with all graphical elements self.gui = parent # init some globals self.applicationPath = os.path.dirname(os.path.realpath(__file__)) self.project = None self.projectPath = None self.roadLayer = None self.roadLayerId = None # retrieve the current tab index self.initTabTabIndex() # disable tab at the beginning self.gui.tabWidget.setTabEnabled(self.tabIndex, False) # set basic events self.gui.inputLayer_lineEdit.returnPressed.connect(self.loadLayer) self.gui.selectLayer_TButton.clicked.connect(self.askLayer) self.gui.selectFile_TButton.clicked.connect(self.askLayerFile) self.gui.inputNetwork_validate_PButton.clicked.connect(self.validateWithNotification) def initTabTabIndex(self): ''' Retrieve what tab index refer the current tab manager ''' for tabIndex in range(self.gui.tabWidget.count()): if self.gui.tabWidget.tabText(tabIndex) == "Input Network": self.tabIndex = tabIndex def setProject(self, project=None): ''' setting the new project on which the tab is based ''' self.project = project if self.project: # set some globals confFileName = self.project.fileName() self.projectPath = os.path.dirname(confFileName) # emit configurationLoaded with the status of loading self.setTabGUIBasingOnProject() # enable current tab because project has been loaded self.gui.tabWidget.setTabEnabled(self.tabIndex, True) else: # disable current tab because no project has been loaded yet self.gui.tabWidget.setTabEnabled(self.tabIndex, False) def setTabGUIBasingOnProject(self): '''Set tab basing on project conf ''' if not self.project: return # get conf parameters inputLayerFile = self.project.value('InputNetwork/inputLayer', '') columnRoadType = self.project.value('InputNetwork/columnRoadType', '') columnRoadLenght = self.project.value('InputNetwork/columnRoadLenght', '') columnRoadSlope = self.project.value('InputNetwork/columnRoadSlope', '') # if layer exist load it otherwise only reset comboboxes if os.path.exists(inputLayerFile): # check if layer is already loaded in layer list checking it's source # that would be equal to the inputLayerFile (for this reason is not simple # to work with db data) found = False for layerName, layer in QgsMapLayerRegistry.instance().mapLayers().items(): if inputLayerFile == layer.publicSource(): # set the found layer as roadLayer self.roadLayer = layer found = True break # if layer is not loaded... load it if not found: # get layer name to set as public name in the legend layerName = os.path.splitext( os.path.basename(inputLayerFile) )[0] # load layer self.roadLayer = QgsVectorLayer(inputLayerFile, layerName, 'ogr') if not self.roadLayer.isValid(): message = self.tr("Error loading layer: %s" % self.roadLayer.error().message(QgsErrorMessage.Text)) iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return # show layer in the canvas QgsMapLayerRegistry.instance().addMapLayer(self.roadLayer) # now layer is available self.roadLayerId = self.roadLayer.id() else: message = self.tr("Input network does not exist: %s" % inputLayerFile) iface.messageBar().pushMessage(message, QgsMessageBar.WARNING) self.roadLayer = None self.roadLayerId = None # avoid emitting signal in case of reset of indexes try: # to avoid add multiple listener, remove previous listener self.gui.inputLayer_lineEdit.returnPressed.disconnect(self.saveTabOnProject) self.gui.roadType_CBox.currentIndexChanged.disconnect(self.saveTabOnProject) self.gui.roadLenght_CBox.currentIndexChanged.disconnect(self.saveTabOnProject) self.gui.roadGradient_CBox.currentIndexChanged.disconnect(self.saveTabOnProject) except (Exception) as ex: pass # set text of loaded layer if self.roadLayer: self.gui.inputLayer_lineEdit.setText(self.roadLayer.publicSource()) else: self.gui.inputLayer_lineEdit.setText(inputLayerFile) # now populare combo boxes with layer colums if self.roadLayer: fieldNames = sorted([field.name() for field in self.roadLayer.pendingFields().toList()]) else: fieldNames = [] unknownIndex = -1 self.gui.roadType_CBox.clear() self.gui.roadLenght_CBox.clear() self.gui.roadGradient_CBox.clear() self.gui.roadType_CBox.addItems(fieldNames) self.gui.roadLenght_CBox.addItems(fieldNames) self.gui.roadGradient_CBox.addItems(fieldNames) # select the combobox item as in the project file... if not available then "Please select" index = self.gui.roadType_CBox.findText(columnRoadType) self.gui.roadType_CBox.setCurrentIndex( index if index >= 0 else unknownIndex ) index = self.gui.roadLenght_CBox.findText(columnRoadLenght) self.gui.roadLenght_CBox.setCurrentIndex( index if index >= 0 else unknownIndex ) index = self.gui.roadGradient_CBox.findText(columnRoadSlope) self.gui.roadGradient_CBox.setCurrentIndex( index if index >= 0 else unknownIndex ) # add all modification events to notify project modification self.gui.inputLayer_lineEdit.returnPressed.connect(self.saveTabOnProject) self.gui.roadType_CBox.currentIndexChanged.connect(self.saveTabOnProject) self.gui.roadLenght_CBox.currentIndexChanged.connect(self.saveTabOnProject) self.gui.roadGradient_CBox.currentIndexChanged.connect(self.saveTabOnProject) # # set parameters for vechicle count/speed columns # # get parameters fron project columnPassengerCars = self.project.value('VehicleCountSpeed/columnPassengerCars', '') columnLightDutyVehicle = self.project.value('VehicleCountSpeed/columnLightDutyVehicle', '') columnHeavyDutyVechicle = self.project.value('VehicleCountSpeed/columnHeavyDutyVechicle', '') columnUrbanBuses = self.project.value('VehicleCountSpeed/columnUrbanBuses', '') columnMotorcycle = self.project.value('VehicleCountSpeed/columnMotorcycle', '') columnCouch = self.project.value('VehicleCountSpeed/columnCouch', '') columnAverageSpeed = self.project.value('VehicleCountSpeed/columnAverageSpeed', '') # avoid emitting signal in case of reset of indexes try: # to avoid add multiple listener, remove previous listener self.gui.passengerCarsCount_CBox.currentIndexChanged.disconnect(self.saveTabOnProject) self.gui.lightDutyVehicleCount_CBox.currentIndexChanged.disconnect(self.saveTabOnProject) self.gui.heavyDutyVehicleCount_CBox.currentIndexChanged.disconnect(self.saveTabOnProject) self.gui.urbanBusesCount_CBox.currentIndexChanged.disconnect(self.saveTabOnProject) self.gui.coachesCount_CBox.currentIndexChanged.disconnect(self.saveTabOnProject) self.gui.motorcycleCount_CBox.currentIndexChanged.disconnect(self.saveTabOnProject) self.gui.averageVehicleSpeed_Cbox.currentIndexChanged.disconnect(self.saveTabOnProject) except (Exception) as ex: pass # now populare combo boxes with layer colums self.gui.passengerCarsCount_CBox.clear() self.gui.lightDutyVehicleCount_CBox.clear() self.gui.heavyDutyVehicleCount_CBox.clear() self.gui.urbanBusesCount_CBox.clear() self.gui.coachesCount_CBox.clear() self.gui.motorcycleCount_CBox.clear() self.gui.averageVehicleSpeed_Cbox.clear() self.gui.passengerCarsCount_CBox.addItems(fieldNames) self.gui.lightDutyVehicleCount_CBox.addItems(fieldNames) self.gui.heavyDutyVehicleCount_CBox.addItems(fieldNames) self.gui.urbanBusesCount_CBox.addItems(fieldNames) self.gui.coachesCount_CBox.addItems(fieldNames) self.gui.motorcycleCount_CBox.addItems(fieldNames) self.gui.averageVehicleSpeed_Cbox.addItems(fieldNames) # select the combobox item as in the project file... if not available then "Please select" index = self.gui.passengerCarsCount_CBox.findText(columnPassengerCars) self.gui.passengerCarsCount_CBox.setCurrentIndex( index if index >= 0 else unknownIndex ) index = self.gui.lightDutyVehicleCount_CBox.findText(columnLightDutyVehicle) self.gui.lightDutyVehicleCount_CBox.setCurrentIndex( index if index >= 0 else unknownIndex ) index = self.gui.heavyDutyVehicleCount_CBox.findText(columnHeavyDutyVechicle) self.gui.heavyDutyVehicleCount_CBox.setCurrentIndex( index if index >= 0 else unknownIndex ) index = self.gui.urbanBusesCount_CBox.findText(columnUrbanBuses) self.gui.urbanBusesCount_CBox.setCurrentIndex( index if index >= 0 else unknownIndex ) index = self.gui.coachesCount_CBox.findText(columnCouch) self.gui.coachesCount_CBox.setCurrentIndex( index if index >= 0 else unknownIndex ) index = self.gui.motorcycleCount_CBox.findText(columnMotorcycle) self.gui.motorcycleCount_CBox.setCurrentIndex( index if index >= 0 else unknownIndex ) index = self.gui.averageVehicleSpeed_Cbox.findText(columnAverageSpeed) self.gui.averageVehicleSpeed_Cbox.setCurrentIndex( index if index >= 0 else unknownIndex ) # add all modification events to notify project modification self.gui.passengerCarsCount_CBox.currentIndexChanged.connect(self.saveTabOnProject) self.gui.lightDutyVehicleCount_CBox.currentIndexChanged.connect(self.saveTabOnProject) self.gui.heavyDutyVehicleCount_CBox.currentIndexChanged.connect(self.saveTabOnProject) self.gui.urbanBusesCount_CBox.currentIndexChanged.connect(self.saveTabOnProject) self.gui.coachesCount_CBox.currentIndexChanged.connect(self.saveTabOnProject) self.gui.motorcycleCount_CBox.currentIndexChanged.connect(self.saveTabOnProject) self.gui.averageVehicleSpeed_Cbox.currentIndexChanged.connect(self.saveTabOnProject) def saveTabOnProject(self): ''' Save tab configuration in the project basing on GUI values ''' if self.sender(): message = "QTraffic: saveTabOnProject by sender {}".format(self.sender().objectName()) QgsLogger.debug(message, debuglevel=3) # get values from the GUI inputLayerFile = self.gui.inputLayer_lineEdit.text() columnRoadType = self.gui.roadType_CBox.currentText() columnRoadLenght = self.gui.roadLenght_CBox.currentText() columnRoadSlope = self.gui.roadGradient_CBox.currentText() # set conf parameters self.project.setValue('InputNetwork/inputLayer', inputLayerFile) self.project.setValue('InputNetwork/columnRoadType', columnRoadType) self.project.setValue('InputNetwork/columnRoadLenght', columnRoadLenght) self.project.setValue('InputNetwork/columnRoadSlope', columnRoadSlope) # # save parameters for vechicle count/speed columns # # get values from the GUI columnPassengerCars = self.gui.passengerCarsCount_CBox.currentText() columnLightDutyVehicle = self.gui.lightDutyVehicleCount_CBox.currentText() columnHeavyDutyVechicle = self.gui.heavyDutyVehicleCount_CBox.currentText() columnUrbanBuses = self.gui.urbanBusesCount_CBox.currentText() columnCouch = self.gui.coachesCount_CBox.currentText() columnMotorcycle = self.gui.motorcycleCount_CBox.currentText() columnAverageSpeed = self.gui.averageVehicleSpeed_Cbox.currentText() # set conf parameters self.project.setValue('VehicleCountSpeed/columnPassengerCars', columnPassengerCars) self.project.setValue('VehicleCountSpeed/columnLightDutyVehicle', columnLightDutyVehicle) self.project.setValue('VehicleCountSpeed/columnHeavyDutyVechicle', columnHeavyDutyVechicle) self.project.setValue('VehicleCountSpeed/columnUrbanBuses', columnUrbanBuses) self.project.setValue('VehicleCountSpeed/columnMotorcycle', columnMotorcycle) self.project.setValue('VehicleCountSpeed/columnCouch', columnCouch) self.project.setValue('VehicleCountSpeed/columnAverageSpeed', columnAverageSpeed) # notify project modification self.projectModified.emit() def askLayer(self): ''' Ask for the layer to load Look for layer already loaded in the layer list ''' # create dialog to select layer dlg = SelectLayerDialog(self.gui) ret = dlg.exec_() if ret: # get selected layer newLayer = dlg.selectLayer_CBox.currentLayer() # set gui with the new layer name self.gui.inputLayer_lineEdit.setText(newLayer.publicSource()) # then load layer self.loadLayer() def askLayerFile(self): ''' Ask for the layer file to load Don't load it if already loaded comparing source of tre layer ''' if not self.project: return # if a layer is present in the project start from the path of that layer oldLayer = self.project.value('InputNetwork/inputLayer', '') if oldLayer: startPath = os.path.dirname(oldLayer) else: startPath = self.projectPath # get porject path layerFileName = QtGui.QFileDialog.getOpenFileName(self.gui, "Select road layer", startPath, self.tr("Shp (*.shp);;All (*)")) if not layerFileName: return # set gui with the new layer name self.gui.inputLayer_lineEdit.setText(layerFileName) # then load layer self.loadLayer() def loadLayer(self): ''' Load a shape layer ''' # get layer filename layerFileName = self.gui.inputLayer_lineEdit.text() if not layerFileName: return if not os.path.exists(layerFileName): title = self.tr("Warning") message = self.tr("Layer does not exist") iface.messageBar().pushMessage(message, QgsMessageBar.WARNING) return currentLayerFile = self.project.value('InputNetwork/inputLayer', '') if currentLayerFile != layerFileName: self.project.setValue('InputNetwork/inputLayer', layerFileName) self.setTabGUIBasingOnProject() # notify project modification if layer source is modified if currentLayerFile != layerFileName: self.projectModified.emit() def getRoadLayer(self): return self.roadLayer def getRoadLayerId(self): return self.roadLayerId def removeRoadLayer(self): ''' Remove current road layer from canvas ''' if self.roadLayer and self.roadLayer.isValid(): # do nothing if layer already removed by user QgsMapLayerRegistry.instance().removeMapLayer(self.roadLayer.id()) def validateWithNotification(self): ''' Do validation and notify if it success ''' if self.validate(): message = self.tr("QTraffic: Input Network validation passed successfully") iface.messageBar().pushMessage(message, QgsMessageBar.SUCCESS) def validate(self): ''' Validate parameters inserted in the Input Network tab: Validation performed is: Mandatory parameters: Input layer Road Type Road lenght Road Gradient Average vehicle speed At least one of vehicle count Value validation: Road Type have to be integer Road lenght, lenght, Gradient have to be float Average vehicle speed have to be lfoat Count column have to be float or integer Inter tab validation Road type column values have to be present as categories in Fleet Distribution classes This method notify the error in case of validation failure This method notify success in case of correct validation @return: True is validated or False if not ''' if not self.project: return False inputLayerFile = self.gui.inputLayer_lineEdit.text() columnRoadType = self.gui.roadType_CBox.currentText() columnRoadLenght = self.gui.roadLenght_CBox.currentText() columnRoadSlope = self.gui.roadGradient_CBox.currentText() columnAverageSpeed = self.gui.averageVehicleSpeed_Cbox.currentText() columnPassengerCars = self.gui.passengerCarsCount_CBox.currentText() columnLightDutyVehicle = self.gui.lightDutyVehicleCount_CBox.currentText() columnHeavyDutyVechicle = self.gui.heavyDutyVehicleCount_CBox.currentText() columnUrbanBuses = self.gui.urbanBusesCount_CBox.currentText() columnCouch = self.gui.coachesCount_CBox.currentText() columnMotorcycle = self.gui.motorcycleCount_CBox.currentText() # mandatory fields if not inputLayerFile: message = self.tr("Validation error: Input shape have to be choosed") iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return False if not columnRoadType: message = self.tr("Validation error: Road type column have to be selected from input layer") iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return False if not columnRoadLenght: message = self.tr("Validation error: Road lenght column have to be selected from input layer") iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return False if not columnRoadSlope: message = self.tr("Validation error: Road gradient column have to be selected from input layer") iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return False if not columnRoadLenght: message = self.tr("Validation error: Road slope column have to be selected from input layer") iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return False if not columnAverageSpeed: message = self.tr("Validation error: Average vechicle speed column have to be selected from input layer") iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return False # at least one column count have to be selected if (not columnPassengerCars and not columnLightDutyVehicle and not columnHeavyDutyVechicle and not columnUrbanBuses and not columnCouch and not columnMotorcycle): message = self.tr("Validation error: At least a vehicle count column have to be selected from input layer") iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return False # value validations fields = self.roadLayer.pendingFields() checkDict = { columnRoadType: [QtCore.QVariant.Int, QtCore.QVariant.LongLong], columnRoadLenght: [QtCore.QVariant.Int, QtCore.QVariant.Double, QtCore.QVariant.LongLong], columnRoadSlope: [QtCore.QVariant.Int, QtCore.QVariant.Double, QtCore.QVariant.LongLong], columnAverageSpeed: [QtCore.QVariant.Int, QtCore.QVariant.Double, QtCore.QVariant.LongLong], columnPassengerCars: [QtCore.QVariant.Int, QtCore.QVariant.Double, QtCore.QVariant.LongLong], columnLightDutyVehicle: [QtCore.QVariant.Int, QtCore.QVariant.Double, QtCore.QVariant.LongLong], columnHeavyDutyVechicle: [QtCore.QVariant.Int, QtCore.QVariant.Double, QtCore.QVariant.LongLong], columnUrbanBuses: [QtCore.QVariant.Int, QtCore.QVariant.Double, QtCore.QVariant.LongLong], columnCouch: [QtCore.QVariant.Int, QtCore.QVariant.Double, QtCore.QVariant.LongLong], columnMotorcycle: [QtCore.QVariant.Int, QtCore.QVariant.Double, QtCore.QVariant.LongLong], } for columnName, admissibleTypes in checkDict.items(): if not columnName: continue field = fields.field(columnName) if not field.type() in admissibleTypes: message = self.tr("Validation error: column {} has incompatible type {}".format(columnName, field.typeName())) iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return False # inter tab validation index = self.roadLayer.fieldNameIndex(columnRoadType) roadTypes = self.roadLayer.uniqueValues(index, -1) if len(roadTypes) == 0: message = self.tr("Validation error: column {} has no values".format(columnRoadType)) iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return False # check if each road type is present in the list of road types in the fleet distribution tab fleetDistributionRoadTypes = self.gui.getRoadTypes() for roadType in roadTypes: if not str(roadType) in fleetDistributionRoadTypes: message = self.tr("Validation error: Road type value {} is not defined in Fleet Composition tab".format(roadType)) iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return False return True # 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 QtCore.QCoreApplication.translate('QTraffic', message)
def save_hazard_data(self): hazard_geojson = PetaJakartaAPI.get_aggregate_report( self.duration, self.level) if not hazard_geojson: raise PetaJakartaAPIError("Can't access PetaJakarta REST API") with open(self.hazard_path, 'w+') as f: f.write(hazard_geojson) # Save the layer as shp file_info = QFileInfo(self.hazard_path) hazard_layer = QgsVectorLayer(self.hazard_path, file_info.baseName(), 'ogr', False) target_name = 'flood_data.shp' self.hazard_path = os.path.join(self.report_path, target_name) QgsVectorFileWriter.writeAsVectorFormat(hazard_layer, self.hazard_path, 'CP1250', None, 'ESRI Shapefile') file_info = QFileInfo(self.hazard_path) hazard_layer = QgsVectorLayer(self.hazard_path, file_info.baseName(), 'ogr') hazard_layer.startEditing() field = QgsField('flooded', QVariant.Int) hazard_layer.dataProvider().addAttributes([field]) hazard_layer.commitChanges() idx = hazard_layer.fieldNameIndex('flooded') expression = QgsExpression('count > 0') expression.prepare(hazard_layer.pendingFields()) hazard_layer.startEditing() for feature in hazard_layer.getFeatures(): feature[idx] = expression.evaluate(feature) hazard_layer.updateFeature(feature) hazard_layer.commitChanges() # writing keywords keyword_io = KeywordIO() keywords = { 'field': 'flooded', 'hazard': 'flood', 'hazard_category': 'single_event', 'keyword_version': '3.3', 'layer_geometry': 'polygon', 'layer_mode': 'classified', 'layer_purpose': 'hazard', 'title': 'Flood', 'value_map': '{"wet": [1], "dry": [0]}', 'vector_hazard_classification': 'flood_vector_hazard_classes' } keyword_io.write_keywords(hazard_layer, keywords) # archiving hazard layer with ZipFile(self.hazard_zip_path, 'w') as zf: for root, dirs, files in os.walk(self.report_path): for f in files: _, ext = os.path.splitext(f) if 'flood_data' in f: filename = os.path.join(root, f) zf.write(filename, arcname=f)
def run(self): """Run method that performs all the real work""" # Add items to Management Practices & Soil Type k_lists = [] m_lists = [] k_lists = self.k_list() m_lists = self.m_list() self.dlg.comboBox.addItems(k_lists) self.dlg.comboBox_2.addItems(m_lists) # show dialog box self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Save paths of input directories selectedBoundary = self.dlg.lineEdit.text() selectedDEM = self.dlg.lineEdit_2.text() selectedRLayer = self.dlg.lineEdit_3.text() selectedOutput = self.dlg.lineEdit_4.text() for letter in selectedOutput: if letter == "\\": selectedOutput = selectedOutput.replace(letter, "/") print(selectedBoundary) print(selectedDEM) print(selectedRLayer) print(selectedOutput) # Save indices for K and M selectedKLayer = self.dlg.comboBox.currentIndex() selectedMLayer = self.dlg.comboBox_2.currentIndex() boundary = QgsVectorLayer(selectedBoundary, 'Boundary', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(boundary) entries = [] # Retrieve K and M values k_value = self.k_index(selectedKLayer) m_value = self.m_index(selectedMLayer) km_value = k_value * m_value km_value = str(km_value) # Process R index ## CSV to Layer uri = 'file:///' + selectedRLayer + '?delimiter=%s&xField=%s&yField=%s&crs=%s' % ( ",", "x", "y", "EPSG:4326") rainfall_unedited = QgsVectorLayer(uri, "rainfall", "delimitedtext") QgsMapLayerRegistry.instance().addMapLayer(rainfall_unedited) spatRef = QgsCoordinateReferenceSystem( 4326, QgsCoordinateReferenceSystem.EpsgCrsId) ## CSV points to editable shapefile rainfall_edited = QgsVectorFileWriter( selectedOutput + '/rainfall_edited.shp', None, rainfall_unedited.pendingFields(), QGis.WKBPoint, spatRef) pt = QgsPoint() outFeature = QgsFeature() for feat in rainfall_unedited.getFeatures(): attrs = feat.attributes() pt.setX(feat['x']) pt.setY(feat['y']) outFeature.setAttributes(attrs) outFeature.setGeometry(QgsGeometry.fromPoint(pt)) rainfall_edited.addFeature(outFeature) del rainfall_edited rainfall_edited2 = QgsVectorLayer( selectedOutput + '/rainfall_edited.shp', 'rainfall_edited', 'ogr') ## Add and calculate average field rainfall_edited2.startEditing() avgField = QgsField('average', QVariant.Double) rainfall_edited2.dataProvider().addAttributes([avgField]) rainfall_edited2.updateFields() idx = rainfall_edited2.fieldNameIndex('average') time_count = idx - 2 str_output = '' for i in range(1, time_count + 1): if i == 1: a = str(i) str_output += 'time' + a else: a = str(i) str_output += '+ time' + a e = QgsExpression(str_output) e.prepare(rainfall_edited2.pendingFields()) for f in rainfall_edited2.getFeatures(): f[idx] = e.evaluate(f) / time_count rainfall_edited2.updateFeature(f) rainfall_edited2.commitChanges() rainfall_edited3 = QgsVectorLayer( selectedOutput + '/rainfall_edited.shp', 'rainfall_edited', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(rainfall_edited3) ## Interpolating average using IDW ### Parameters for interpolation idx = rainfall_edited3.fieldNameIndex('average') layer_data = qgis.analysis.QgsInterpolator.LayerData() layer_data.vectorLayer = rainfall_edited3 layer_data.zCoordInterpolation = False layer_data.interpolationAttribute = idx layer_data.mInputType = 1 idw_interpolator = QgsIDWInterpolator([layer_data]) ### Output parameter export_path = selectedOutput + "/interpolated_r_{}.asc".format(idx) rect = boundary.extent() res = 0.0001 ncol = (rect.xMaximum() - rect.xMinimum()) / res nrows = (rect.yMaximum() - rect.yMinimum()) / res interpolated_r = QgsGridFileWriter(idw_interpolator, export_path, rect, int(ncol), int(nrows), res, res) interpolated_r.writeFile(True) interpolated_r2 = QgsRasterLayer(export_path, "interpolated_r") ## Clip output to boundary clippedR = processing.runandload( 'gdalogr:cliprasterbymasklayer', interpolated_r2, #INPUT <ParameterRaster> boundary, #MASK <ParameterVector> "-9999", #NO_DATA <ParameterString> False, #ALPHA_BAND <ParameterBoolean> False, #CROP_TO_CUTLINE <ParameterBoolean> False, #KEEP_RESOLUTION <ParameterBoolean> 5, #RTYPE <ParameterSelection> 4, #COMPRESS <ParameterSelection> 1, #JPEGCOMPRESSION <ParameterNumber> 6, #ZLEVEL <ParameterNumber> 1, #PREDICTOR <ParameterNumber> False, #TILED <ParameterBoolean> 2, #BIGTIFF <ParameterSelection> False, #TFW <ParameterBoolean> "", #EXTRA <ParameterString> selectedOutput + '/clip_interpolated_r.tif') #OUTPUT <OutputRaster> r_layer = QgsRasterLayer( selectedOutput + '/clip_interpolated_r.tif', "R-index") boh4 = QgsRasterCalculatorEntry() boh4.ref = 'boh4@1' boh4.raster = r_layer boh4.bandNumber = 1 entries.append(boh4) # Process S index ## Load DEM bohLayer1 = QgsRasterLayer(selectedDEM, "DEM") boh2 = QgsRasterCalculatorEntry() boh2.ref = 'boh2@1' boh2.raster = bohLayer1 boh2.bandNumber = 1 entries.append(boh2) ## Clip output to boundary clippedOutput2 = processing.runandload( 'gdalogr:cliprasterbymasklayer', bohLayer1, # INPUT <ParameterRaster> boundary, # MASK <ParameterVector> "-9999", # NO_DATA <ParameterString> False, # ALPHA_BAND <ParameterBoolean> False, # CROP_TO_CUTLINE <ParameterBoolean> False, # KEEP_RESOLUTION <ParameterBoolean> 5, # RTYPE <ParameterSelection> 4, # COMPRESS <ParameterSelection> 1, # JPEGCOMPRESSION <ParameterNumber> 6, # ZLEVEL <ParameterNumber> 1, # PREDICTOR <ParameterNumber> False, # TILED <ParameterBoolean> 2, # BIGTIFF <ParameterSelection> False, # TFW <ParameterBoolean> "", # EXTRA <ParameterString> selectedOutput + '/clip_dem.tif') # OUTPUT <OutputRaster> bohLayer5 = QgsRasterLayer(selectedOutput + '/clip_dem.tif', "DEM-clipped") boh5 = QgsRasterCalculatorEntry() boh5.ref = 'boh5@1' boh5.raster = bohLayer5 boh5.bandNumber = 1 entries.append(boh5) ## GDAL algorithm for slope processing.runalg('gdalogr:slope', bohLayer5, 1, False, True, True, 111120, selectedOutput + '/slope(percent).tif') bohLayer6 = QgsRasterLayer(selectedOutput + '/slope(percent).tif', "slope(percent)") QgsMapLayerRegistry.instance().addMapLayer(bohLayer6) boh6 = QgsRasterCalculatorEntry() boh6.ref = 'boh6@1' boh6.raster = bohLayer6 boh6.bandNumber = 1 entries.append(boh6) # Process calculation with input extent and resolution calc = QgsRasterCalculator('(boh4@1 * boh6@1) *' + km_value, selectedOutput + '/soil_risk.tif', 'GTiff', bohLayer6.extent(), bohLayer6.width(), bohLayer6.height(), entries) calc.processCalculation() bohLayer4 = QgsRasterLayer(selectedOutput + '/soil_risk.tif', "Soil_Risk") QgsMapLayerRegistry.instance().addMapLayer(bohLayer4)
def prepareReclassification(self, cl, areaLyr, centroidLyr, relateDict): """ area without centroid: destid = -1 area with conflicted centroid: destid = 0 """ destIdx = areaLyr.fieldNameIndex('destid') for id in relateDict[cl].keys(): numberOfCentroids = len(relateDict[cl][id]) if numberOfCentroids == 1: if relateDict[cl][id][0]['cl'] == cl: # perfect case - must be reclassified areaLyr.dataProvider().changeAttributeValues( {id: { destIdx: relateDict[cl][id][0]['featid'] }}) elif numberOfCentroids == 0: # area without centroid - this must become a flag areaLyr.dataProvider().changeAttributeValues( {id: { destIdx: -1000 }}) else: #first sweep: identify centroids with conflicted classes conflictedCentroids = [ feat for feat in relateDict[cl][id] if feat['cl'] <> cl ] conflictedChildCentroids = [ feat['child'] for feat in relateDict[cl][id] ] conflictedDict = dict() for conf in conflictedChildCentroids: conflictedDict[conf] = 1 if len(conflictedCentroids) > 0: areaLyr.dataProvider().changeAttributeValues( {id: { destIdx: -2000 }}) elif len(conflictedDict.keys()) > 1: areaLyr.dataProvider().changeAttributeValues( {id: { destIdx: -2000 }}) else: sameClassCentroids = relateDict[cl][id] #get original centroid layer auxLyr = QgsVectorLayer( self.abstractDb.getURI(cl, False, geomColumn='centroid').uri(), relateDict[cl][id][0][0], "postgres") #get all field names fieldNames = [ field.name() for field in auxLyr.pendingFields() ] #we must not consider these fields notAllowedFields = [ name for name in fieldNames if (name in ['id', 'geom', 'centroid'] or 'id_' in name ) ] #check by index is easier, therefore, this step notAllowedIndexes = [] for notAllowedField in notAllowedFields: notAllowedIndexes.append( auxLyr.fieldNameIndex(notAllowedField)) #comparing centroid attributes duplicated = True # aux variable firstCentroid = [ feat for feat in auxLyr.dataProvider().getFeatures( QgsFeatureRequest(relateDict[cl][id][0][1])) ][0] firstAttributes = firstCentroid.attributes() for i in range(1, len(sameClassCentroids)): centroid = [ feat for feat in auxLyr.dataProvider().getFeatures( QgsFeatureRequest(sameClassCentroids[i][1])) ][0] attributes = centroid.attributes() for j in range(len(attributes)): if j not in notAllowedIndexes: #in this case the attribute j is not equal, we must flag this out if centroid[j] != firstCentroid[j]: duplicated = False break break if duplicated: areaLyr.dataProvider().changeAttributeValues( {id: { destIdx: relateDict[cl][id][0]['featid'] }}) else: areaLyr.dataProvider().changeAttributeValues( {id: { destIdx: -2000 }})
class AutoFieldsTests( unittest.TestCase ): @classmethod def setUpClass( self ): self.msg = MessageManager( 'debug', None ) self.msg.show( "Info! SetUp started", 'info', True ) #Initialize QGIS app app = QgsApplication([], True) QgsApplication.setPrefixPath("/usr", True) QgsApplication.initQgis() #Configure QSettings (organization and application name) self.settings = QSettings("GeoTux", "QGIS-Plugin-Test") #Load layer, add field f1, and add layer to Registry baseDir = os.path.dirname( os.path.realpath( __file__ ) ) self.layerPath = os.path.join( baseDir, 'test_data', 'test_points.shp' ) self.layer = QgsVectorLayer( self.layerPath, 'puntos', 'ogr' ) self.layer.dataProvider().addAttributes([QgsField('f1', QVariant.Double)]) self.layer.updateFields() QgsMapLayerRegistry.instance().addMapLayer( self.layer ) #Instantiate AutoFieldManager self.autoFieldManager = AutoFieldManager( self.msg, None, '/AutoFieldsTest', 'GeoTux', 'QGIS-Plugin-Test' ) def readStoredSettings( self, layer, fieldName ): """ Helper function to get a dictionary of stored QSettings for an AutoField """ dictTmpProperties = {} autoFieldId = self.autoFieldManager.buildAutoFieldId( layer, fieldName ) self.settings.beginGroup('/AutoFieldsTest/data/' + autoFieldId) dictTmpProperties['layer'] = self.settings.value( "layer", "", type=str ) dictTmpProperties['field'] = self.settings.value( "field", u"", type=unicode ) dictTmpProperties['expression'] = self.settings.value( "expression", u"", type=unicode ) dictTmpProperties['layer2'] = self.settings.value( "layer2", "", type=str ) dictTmpProperties['field2'] = self.settings.value( "field2", "", type=str ) dictTmpProperties['enabled'] = self.settings.value( "enabled", False, type=bool ) self.settings.endGroup() return dictTmpProperties def test01CreateEnabledAutoField( self ): """ QSettings should be properly stored, AutoField should be enabled """ self.msg.show( "Info! Test 1 started", 'info', True ) self.autoFieldManager.createAutoField( layer=self.layer, fieldName=u'f1', expression=u'$x' ) dictTmpProperties = self.readStoredSettings( self.layer, u'f1' ) dictExpectedProperties = { 'layer':self.layerPath, 'field':u'f1', 'expression':u'$x', 'layer2':"", 'field2':"", 'enabled':True } self.assertEqual( dictTmpProperties, dictExpectedProperties ) def test02AvoidTwoAutoFieldsOnSameField( self ): """ AutoField should not be created if another one already exists on the same field.""" self.msg.show( "Info! Test 2 started", 'info', True ) res = self.autoFieldManager.createAutoField( layer=self.layer, fieldName=u'f1', expression=u'$y' ) self.assertFalse( res ) def test03EditAutoFieldLayer( self ): """ AutoField value should be updated if a feature is added. Note: It cannot handle the case when writing directly to the provider, as QGIS doesn't have a SIGNAL for that. self.layer.dataProvider().addFeatures( [ tmpFeature ] ) """ self.msg.show( "Info! Test 3 started", 'info', True ) tmpFeature = QgsFeature( self.layer.pendingFields() ) tmpFeature.setGeometry( QgsGeometry.fromPoint( QgsPoint(-74.4, 4.5) ) ) # Either 1: self.layer.startEditing() self.layer.addFeature( tmpFeature ) self.layer.commitChanges() # Or 2: #with edit( self.layer ): # self.layer.addFeature( tmpFeature ) addedFeature = self.layer.getFeatures().next() self.assertEquals( addedFeature['f1'], -74.4 ) def test04ChangeAttributeValue( self ): """ AutoField value should be updated if another AutoField value is changed """ self.msg.show( "Info! Test 4 started", 'info', True ) self.autoFieldManager.createAutoField( layer=self.layer, fieldName=u'modified', expression=u'\'now: \' + to_string("f1")' ) self.layer.startEditing() self.layer.changeAttributeValue( 0, self.layer.fieldNameIndex( u'id' ), 1 ) self.layer.commitChanges() feature = self.layer.getFeatures().next() self.assertEquals( feature['modified'], 'now: -74.4' ) def test05FieldRemovedThenDisableAutoField( self ): """ AutoField should be disabled if its base field is removed """ self.msg.show( "Info! Test 5 started", 'info', True ) fieldIndex = self.layer.fieldNameIndex( u'f1' ) self.layer.startEditing() self.layer.deleteAttribute( fieldIndex ) self.layer.commitChanges() dictTmpProperties = self.readStoredSettings( self.layer, u'f1' ) self.assertFalse( dictTmpProperties['enabled'] ) def test06MissingFieldAddedThenEnableAutoField( self ): """ AutoField should be enabled if missing field is added """ self.msg.show( "Info! Test 6 started", 'info', True ) self.layer.startEditing() self.layer.addAttribute( QgsField( 'f1', QVariant.Double, len=10, prec=2 ) ) self.layer.commitChanges() dictTmpProperties = self.readStoredSettings( self.layer, u'f1' ) self.assertTrue( dictTmpProperties['enabled'] ) def test07LayerRemovedThenDisableAutoField( self ): """ AutoField should be disabled if its base layer is removed """ self.msg.show( "Info! Test 7 started", 'info', True ) QgsMapLayerRegistry.instance().removeMapLayer( self.layer.id() ) # removeMapLayer deletes the underlying object, so create it again self.layer = QgsVectorLayer( self.layerPath, 'puntos', 'ogr' ) dictTmpProperties = self.readStoredSettings( self.layer, u'f1' ) self.assertFalse( dictTmpProperties['enabled'] ) def test08MissingLayerAddedThenEnableAutoField( self ): """ AutoField should be enabled if missing layer is added """ self.msg.show( "Info! Test 8 started", 'info', True ) # test07 deletes the layer object, so create it again self.layer = QgsVectorLayer( self.layerPath, 'puntos', 'ogr' ) QgsMapLayerRegistry.instance().addMapLayer( self.layer ) dictTmpProperties = self.readStoredSettings( self.layer, u'f1' ) self.assertTrue( dictTmpProperties['enabled'] ) def test09RemoveAutoField( self ): """ QSettings should be deleted for the removed AutoField """ self.msg.show( "Info! Test 9 started", 'info', True ) # test07 deletes the layer object, so create it again self.layer = QgsVectorLayer( self.layerPath, 'puntos', 'ogr' ) autoFieldId = self.autoFieldManager.buildAutoFieldId( self.layer, u'f1') self.autoFieldManager.removeAutoField( autoFieldId ) dictTmpProperties = self.readStoredSettings( self.layer, u'f1' ) self.assertEqual( dictTmpProperties, {'layer':"",'field':"",'expression':"",'layer2':"",'field2':"",'enabled':False} ) @classmethod def tearDownClass( self ): self.msg.show( "Info! TearDown started", 'info', True ) # test07 deletes the layer object, so create it again self.layer = QgsVectorLayer( self.layerPath, 'puntos', 'ogr' ) #Remove AutoField modified autoFieldId = self.autoFieldManager.buildAutoFieldId( self.layer, u'modified' ) self.autoFieldManager.removeAutoField( autoFieldId ) #Delete field f1 fieldIndex = self.layer.fieldNameIndex('f1') self.layer.dataProvider().deleteAttributes( [fieldIndex] ) self.layer.updateFields() #Delete features from test layer fIds = self.layer.allFeatureIds() self.layer.dataProvider().deleteFeatures( fIds ) #Remove layer from Registry QgsMapLayerRegistry.instance().removeMapLayer( self.layer.id() ) self.msg.show( "Info! TearDown finished", 'info', True ) QgsApplication.exitQgis()
def start_progress(self): import datetime start = datetime.datetime.now() # Check OS and dep if sys.platform == 'darwin': gdal_os_dep = '/Library/Frameworks/GDAL.framework/Versions/Current/Programs/' else: gdal_os_dep = '' if self.dlg.canvasButton.isChecked(): # Map Canvas extentCanvasCRS = self.iface.mapCanvas() srs = extentCanvasCRS.mapSettings().destinationCrs() crs = str(srs.authid()) # old_crs = osr.SpatialReference() # old_crs.ImportFromEPSG(int(crs[5:])) can_crs = QgsCoordinateReferenceSystem(int(crs[5:])) # can_wkt = extentCanvasCRS.mapRenderer().destinationCrs().toWkt() # can_crs = osr.SpatialReference() # can_crs.ImportFromWkt(can_wkt) # Raster Layer dem_layer = self.layerComboManagerDEM.currentLayer() dem_prov = dem_layer.dataProvider() dem_path = str(dem_prov.dataSourceUri()) dem_raster = gdal.Open(dem_path) projdsm = osr.SpatialReference(wkt=dem_raster.GetProjection()) projdsm.AutoIdentifyEPSG() projdsmepsg = int(projdsm.GetAttrValue('AUTHORITY', 1)) dem_crs = QgsCoordinateReferenceSystem(projdsmepsg) # dem_wkt = dem_raster.GetProjection() # dem_crs = osr.SpatialReference() # dem_crs.ImportFromWkt(dem_wkt) if can_crs != dem_crs: extentCanvas = self.iface.mapCanvas().extent() extentDEM = dem_layer.extent() transformExt = QgsCoordinateTransform(can_crs, dem_crs) # transformExt = osr.CoordinateTransformation(can_crs, dem_crs) canminx = extentCanvas.xMinimum() canmaxx = extentCanvas.xMaximum() canminy = extentCanvas.yMinimum() canmaxy = extentCanvas.yMaximum() canxymin = transformExt.TransformPoint(canminx, canminy) canxymax = transformExt.TransformPoint(canmaxx, canmaxy) extDiffminx = canxymin[0] - extentDEM.xMinimum( ) # If smaller than zero = warning extDiffminy = canxymin[1] - extentDEM.yMinimum( ) # If smaller than zero = warning extDiffmaxx = canxymax[0] - extentDEM.xMaximum( ) # If larger than zero = warning extDiffmaxy = canxymax[0] - extentDEM.yMaximum( ) # If larger than zero = warning if extDiffminx < 0 or extDiffminy < 0 or extDiffmaxx > 0 or extDiffmaxy > 0: QMessageBox.warning( None, "Warning! Extent of map canvas is larger than raster extent.", "Change to an extent equal to or smaller than the raster extent." ) return # Extent self.yMax = self.dlg.lineEditNorth.text() self.yMin = self.dlg.lineEditSouth.text() self.xMin = self.dlg.lineEditWest.text() self.xMax = self.dlg.lineEditEast.text() if not self.DSMoutputfile: QMessageBox.critical(None, "Error", "Specify a raster output file") return if self.dlg.checkBoxPolygon.isChecked() and not self.OSMoutputfile: QMessageBox.critical(None, "Error", "Specify an output file for OSM data") return # Acquiring geodata and attributes dem_layer = self.layerComboManagerDEM.currentLayer() if dem_layer is None: QMessageBox.critical(None, "Error", "No valid raster layer is selected") return else: provider = dem_layer.dataProvider() filepath_dem = str(provider.dataSourceUri()) demRaster = gdal.Open(filepath_dem) dem_layer_crs = osr.SpatialReference() dem_layer_crs.ImportFromWkt(demRaster.GetProjection()) self.dem_layer_unit = dem_layer_crs.GetAttrValue("UNIT") posUnits = [ 'metre', 'US survey foot', 'meter', 'm', 'ft', 'feet', 'foot', 'ftUS', 'International foot' ] # Possible units if not self.dem_layer_unit in posUnits: QMessageBox.critical( None, "Error", "Raster projection is not in metre or foot. Please reproject.") return polygon_layer = self.layerComboManagerPolygon.currentLayer() osm_layer = self.dlg.checkBoxOSM.isChecked() if polygon_layer is None and osm_layer is False: QMessageBox.critical(None, "Error", "No valid building height layer is selected") return elif polygon_layer: vlayer = QgsVectorLayer(polygon_layer.source(), "buildings", "ogr") fileInfo = QFileInfo(polygon_layer.source()) polygon_ln = fileInfo.baseName() polygon_field = self.layerComboManagerPolygonField.currentField() idx = vlayer.fieldNameIndex(polygon_field) flname = vlayer.attributeDisplayName(idx) if idx == -1: QMessageBox.critical( None, "Error", "An attribute with unique fields must be selected") return ### main code ### self.dlg.progressBar.setRange(0, 5) self.dlg.progressBar.setValue(1) if self.dlg.checkBoxOSM.isChecked(): # TODO replace osr.CoordinateTransformation with QgsCoordinateTransform dem_original = gdal.Open(filepath_dem) dem_wkt = dem_original.GetProjection() ras_crs = osr.SpatialReference() ras_crs.ImportFromWkt(dem_wkt) rasEPSG = ras_crs.GetAttrValue("PROJCS|AUTHORITY", 1) if self.dlg.layerButton.isChecked(): old_crs = ras_crs elif self.dlg.canvasButton.isChecked(): canvasCRS = self.iface.mapCanvas() outputWkt = canvasCRS.mapRenderer().destinationCrs().toWkt() old_crs = osr.SpatialReference() old_crs.ImportFromWkt(outputWkt) wgs84_wkt = """ GEOGCS["WGS 84", DATUM["WGS_1984", SPHEROID["WGS 84",6378137,298.257223563, AUTHORITY["EPSG","7030"]], AUTHORITY["EPSG","6326"]], PRIMEM["Greenwich",0, AUTHORITY["EPSG","8901"]], UNIT["degree",0.01745329251994328, AUTHORITY["EPSG","9122"]], AUTHORITY["EPSG","4326"]]""" new_crs = osr.SpatialReference() new_crs.ImportFromWkt(wgs84_wkt) transform = osr.CoordinateTransformation(old_crs, new_crs) minx = float(self.xMin) miny = float(self.yMin) maxx = float(self.xMax) maxy = float(self.yMax) lonlatmin = transform.TransformPoint(minx, miny) lonlatmax = transform.TransformPoint(maxx, maxy) if ras_crs != old_crs: rasTrans = osr.CoordinateTransformation(old_crs, ras_crs) raslonlatmin = rasTrans.TransformPoint(float(self.xMin), float(self.yMin)) raslonlatmax = rasTrans.TransformPoint(float(self.xMax), float(self.yMax)) #else: #raslonlatmin = [float(self.xMin), float(self.yMin)] #raslonlatmax = [float(self.xMax), float(self.yMax)] self.xMin = raslonlatmin[0] self.yMin = raslonlatmin[1] self.xMax = raslonlatmax[0] self.yMax = raslonlatmax[1] # Make data queries to overpass-api urlStr = 'http://overpass-api.de/api/map?bbox=' + str( lonlatmin[0]) + ',' + str(lonlatmin[1]) + ',' + str( lonlatmax[0]) + ',' + str(lonlatmax[1]) osmXml = urllib.urlopen(urlStr).read() #print urlStr # Make OSM building file osmPath = self.plugin_dir + '/temp/OSM_building.osm' osmFile = open(osmPath, 'w') osmFile.write(osmXml) if os.fstat(osmFile.fileno()).st_size < 1: urlStr = 'http://api.openstreetmap.org/api/0.6/map?bbox=' + str( lonlatmin[0]) + ',' + str(lonlatmin[1]) + ',' + str( lonlatmax[0]) + ',' + str(lonlatmax[1]) osmXml = urllib.urlopen(urlStr).read() osmFile.write(osmXml) #print 'Open Street Map' if os.fstat(osmFile.fileno()).st_size < 1: QMessageBox.critical(None, "Error", "No OSM data available") return osmFile.close() outputshp = self.plugin_dir + '/temp/' osmToShape = gdal_os_dep + 'ogr2ogr --config OSM_CONFIG_FILE "' + self.plugin_dir + '/osmconf.ini" -skipfailures -t_srs EPSG:' + str( rasEPSG ) + ' -overwrite -nlt POLYGON -f "ESRI Shapefile" "' + outputshp + '" "' + osmPath + '"' if sys.platform == 'win32': si = subprocess.STARTUPINFO() si.dwFlags |= subprocess.STARTF_USESHOWWINDOW subprocess.call(osmToShape, startupinfo=si) else: os.system(osmToShape) driver = ogr.GetDriverByName('ESRI Shapefile') driver.DeleteDataSource(outputshp + 'lines.shp') driver.DeleteDataSource(outputshp + 'multilinestrings.shp') driver.DeleteDataSource(outputshp + 'other_relations.shp') driver.DeleteDataSource(outputshp + 'points.shp') osmPolygonPath = outputshp + 'multipolygons.shp' vlayer = QgsVectorLayer(osmPolygonPath, 'multipolygons', 'ogr') polygon_layer = vlayer fileInfo = QFileInfo(polygon_layer.source()) polygon_ln = fileInfo.baseName() def renameField(srcLayer, oldFieldName, newFieldName): ds = gdal.OpenEx(srcLayer.source(), gdal.OF_VECTOR | gdal.OF_UPDATE) ds.ExecuteSQL('ALTER TABLE {} RENAME COLUMN {} TO {}'.format( srcLayer.name(), oldFieldName, newFieldName)) srcLayer.reload() vlayer.startEditing() renameField(vlayer, 'building_l', 'bld_levels') renameField(vlayer, 'building_h', 'bld_hght') renameField(vlayer, 'building_c', 'bld_colour') renameField(vlayer, 'building_m', 'bld_materi') renameField(vlayer, 'building_u', 'bld_use') vlayer.commitChanges() vlayer.startEditing() vlayer.dataProvider().addAttributes( [QgsField('bld_height', QVariant.Double, 'double', 3, 2)]) vlayer.updateFields() bld_lvl = vlayer.fieldNameIndex('bld_levels') hght = vlayer.fieldNameIndex('height') bld_hght = vlayer.fieldNameIndex('bld_hght') bld_height = vlayer.fieldNameIndex('bld_height') bldLvlHght = float(self.dlg.doubleSpinBoxBldLvl.value()) illegal_chars = string.ascii_letters + "!#$%&'*+^_`|~:" + " " counterNone = 0 counter = 0 #counterWeird = 0 for feature in vlayer.getFeatures(): if feature[hght]: try: #feature[bld_height] = float(re.sub("[^0-9]", ".", str(feature[hght]))) feature[bld_height] = float( str(feature[hght]).translate(None, illegal_chars)) except: counterNone += 1 elif feature[bld_hght]: try: #feature[bld_height] = float(re.sub("[^0-9]", ".", str(feature[bld_hght]))) feature[bld_height] = float( str(feature[bld_hght]).translate( None, illegal_chars)) except: counterNone += 1 elif feature[bld_lvl]: try: #feature[bld_height] = float(re.sub("[^0-9]", "", str(feature[bld_lvl])))*bldLvlHght feature[bld_height] = float( str(feature[bld_lvl]).translate( None, illegal_chars)) * bldLvlHght except: counterNone += 1 else: counterNone += 1 vlayer.updateFeature(feature) counter += 1 vlayer.commitChanges() flname = vlayer.attributeDisplayName(bld_height) counterDiff = counter - counterNone # Zonal statistics vlayer.startEditing() zoneStat = QgsZonalStatistics(vlayer, filepath_dem, "stat_", 1, QgsZonalStatistics.Mean) zoneStat.calculateStatistics(None) vlayer.dataProvider().addAttributes( [QgsField('height_asl', QVariant.Double)]) vlayer.updateFields() e = QgsExpression('stat_mean + ' + flname) e.prepare(vlayer.pendingFields()) idx = vlayer.fieldNameIndex('height_asl') for f in vlayer.getFeatures(): f[idx] = e.evaluate(f) vlayer.updateFeature(f) vlayer.commitChanges() vlayer.startEditing() idx2 = vlayer.fieldNameIndex('stat_mean') vlayer.dataProvider().deleteAttributes([idx2]) vlayer.updateFields() vlayer.commitChanges() self.dlg.progressBar.setValue(2) # Convert polygon layer to raster # Define pixel_size and NoData value of new raster pixel_size = self.dlg.spinBox.value() # half picture size # Create the destination data source gdalrasterize = gdal_os_dep + 'gdal_rasterize -a ' + 'height_asl' + ' -te ' + str(self.xMin) + ' ' + str(self.yMin) + ' ' + str(self.xMax) + ' ' + str(self.yMax) +\ ' -tr ' + str(pixel_size) + ' ' + str(pixel_size) + ' -l "' + str(polygon_ln) + '" "' \ + str(polygon_layer.source()) + '" "' + self.plugin_dir + '/temp/clipdsm.tif"' # gdalclipdem = gdal_os_dep + 'gdalwarp -dstnodata -9999 -q -overwrite -te ' + str(self.xMin) + ' ' + str(self.yMin) + ' ' + str(self.xMax) + ' ' + str(self.yMax) +\ # ' -tr ' + str(pixel_size) + ' ' + str(pixel_size) + \ # ' -of GTiff ' + '"' + filepath_dem + '" "' + self.plugin_dir + '/temp/clipdem.tif"' # Rasterize if sys.platform == 'win32': si = subprocess.STARTUPINFO() si.dwFlags |= subprocess.STARTF_USESHOWWINDOW subprocess.call(gdalrasterize, startupinfo=si) # subprocess.call(gdalclipdem, startupinfo=si) gdal.Warp(self.plugin_dir + '/temp/clipdem.tif', filepath_dem, xRes=pixel_size, yRes=pixel_size) else: os.system(gdalrasterize) # os.system(gdalclipdem) gdal.Warp(self.plugin_dir + '/temp/clipdem.tif', filepath_dem, xRes=pixel_size, yRes=pixel_size) # Remove gdalwarp with gdal.Translate # bigraster = gdal.Open(filepath_dem) # bbox = (self.xMin, self.yMax, self.xMax, self.yMin) # gdal.Translate(self.plugin_dir + '/data/clipdem.tif', bigraster, projWin=bbox) self.dlg.progressBar.setValue(3) # Adding DSM to DEM # Read DEM dem_raster = gdal.Open(self.plugin_dir + '/temp/clipdem.tif') dem_array = np.array(dem_raster.ReadAsArray().astype(np.float)) dsm_raster = gdal.Open(self.plugin_dir + '/temp/clipdsm.tif') dsm_array = np.array(dsm_raster.ReadAsArray().astype(np.float)) indx = dsm_array.shape for ix in range(0, int(indx[0])): for iy in range(0, int(indx[1])): if int(dsm_array[ix, iy]) == 0: dsm_array[ix, iy] = dem_array[ix, iy] if self.dlg.checkBoxPolygon.isChecked(): vlayer.startEditing() idxHght = vlayer.fieldNameIndex('height_asl') idxBld = vlayer.fieldNameIndex('building') features = vlayer.getFeatures() #for f in vlayer.getFeatures(): for f in features: geom = f.geometry() posUnitsMetre = ['metre', 'meter', 'm'] # Possible metre units posUnitsFt = [ 'US survey foot', 'ft', 'feet', 'foot', 'ftUS', 'International foot' ] # Possible foot units if self.dem_layer_unit in posUnitsMetre: sqUnit = 1 elif self.dem_layer_unit in posUnitsFt: sqUnit = 10.76 if int(geom.area()) > 50000 * sqUnit: vlayer.deleteFeature(f.id()) #if not f[idxHght]: #vlayer.deleteFeature(f.id()) #elif not f[idxBld]: #vlayer.deleteFeature(f.id()) vlayer.updateFields() vlayer.commitChanges() QgsVectorFileWriter.writeAsVectorFormat(vlayer, str(self.OSMoutputfile), "UTF-8", None, "ESRI Shapefile") else: vlayer.startEditing() idx3 = vlayer.fieldNameIndex('height_asl') vlayer.dataProvider().deleteAttributes([idx3]) vlayer.updateFields() vlayer.commitChanges() self.dlg.progressBar.setValue(4) # Save raster def saveraster( gdal_data, filename, raster ): # gdal_data = raster extent, filename = output filename, raster = numpy array (raster to be saved) rows = gdal_data.RasterYSize cols = gdal_data.RasterXSize outDs = gdal.GetDriverByName("GTiff").Create( filename, cols, rows, int(1), gdal.GDT_Float32) outBand = outDs.GetRasterBand(1) # write the data outBand.WriteArray(raster, 0, 0) # flush data to disk, set the NoData value and calculate stats outBand.FlushCache() outBand.SetNoDataValue(-9999) # georeference the image and set the projection outDs.SetGeoTransform(gdal_data.GetGeoTransform()) outDs.SetProjection(gdal_data.GetProjection()) saveraster(dsm_raster, self.DSMoutputfile, dsm_array) # Load result into canvas rlayer = self.iface.addRasterLayer(self.DSMoutputfile) # Trigger a repaint if hasattr(rlayer, "setCacheImage"): rlayer.setCacheImage(None) rlayer.triggerRepaint() self.dlg.progressBar.setValue(5) #runTime = datetime.datetime.now() - start if self.dlg.checkBoxOSM.isChecked(): QMessageBox.information( self.dlg, 'DSM Generator', 'Operation successful! ' + str(counterDiff) + ' building polygons out of ' + str(counter) + ' contained height values.') #self.iface.messageBar().pushMessage("DSM Generator. Operation successful! " + str(counterDiff) + " buildings out of " + str(counter) + " contained height values.", level=QgsMessageBar.INFO, duration=5) else: #self.iface.messageBar().pushMessage("DSM Generator. Operation successful!", level=QgsMessageBar.INFO, duration=5) QMessageBox.information(self.dlg, 'DSM Generator', 'Operation successful!') self.resetPlugin()
def loadData(self, resultFile, chunkId): """ Load data to the map """ if isMimeTypeVector(self.mimeType, True) != None: # Memory layer: geometryTypes = [ "Point", "LineString", "Polygon", "Unknown", "NoGeometry" ] vlayer = QgsVectorLayer(resultFile, "chunk", "ogr") if self.__bFirstChunk: self.__bFirstChunk = False self.__geometryType = geometryTypes[vlayer.geometryType()] self.__bGeomMulti = vlayer.wkbType() in [4, 5, 6, 11, 12, 13] self.__memoryLayer = QgsVectorLayer(self.__geometryType, "Streamed data", "memory") self.__memoryLayer.dataProvider().addAttributes( list(vlayer.pendingFields().values())) self.__memoryLayer.updateFieldMap() provider = vlayer.dataProvider() allAttrs = provider.attributeIndexes() vlayer.select(allAttrs) # Visualize temporal geometries during the downloading process # Don't add temporal geometries if last chunk if self.DEBUG: # fix_print_with_import # fix_print_with_import print("Loaded chunkId:", chunkId) res = self.__memoryLayer.dataProvider().addFeatures( [feat for feat in vlayer]) self.__deliveredChunks += 1 if not self.allChunksDelivered(): inFeat = QgsFeature() inGeom = QgsGeometry() self.createTempGeometry(chunkId, self.__geometryType) while provider.nextFeature(inFeat): inGeom = inFeat.geometry() featList = self.extractAsSingle( self.__geometryType, inGeom) if self.__bGeomMulti else [inGeom] for geom in featList: self.addTempGeometry(chunkId, self.__geometryType, geom) else: self.finishLoading() # Raster data elif isMimeTypeRaster(self.mimeType, True) != None: # We can directly attach the new layer if self.__bFirstChunk: self.__bFirstChunk = False self.__groupIndex = self.__legend.addGroup("Streamed-raster") rLayer = QgsRasterLayer(resultFile, "raster_" + str(chunkId)) bLoaded = QgsProject.instance().addMapLayer(rLayer) self.stretchRaster(rLayer) self.__legend.moveLayer(rLayer, self.__groupIndex + 1) self.__deliveredChunks += 1 if self.allChunksDelivered(): self.finishLoading()
class MdbLayer: """ Pretend we are a data provider """ dirty = False doing_attr_update = False def __init__(self, mdb_path, mdb_table, mdb_columns='*', mdb_hide_columns=''): """ Initialize the layer by reading a Access mdb file, creating a memory layer, and adding records to it :param mdb_path: Path to the database you wish to access. :type mdb_path: str :param mdb_table: Table name of the table to open. :type mdb_table: str :param mdb_columns: Comma separated list of columns to use for this layer. Defaults to all (*). :type mdb_columns: str :param mdb_hide_columns: Comma separated list of columns to hide for this layer. Use in combination with mdb_columns='*' :type mdb_hide_columns: str """ self.mdb_path = mdb_path self.mdb_table = mdb_table self.mdb_columns = mdb_columns self.mdb_hide_columns = [ x.strip() for x in mdb_hide_columns.split(",") ] self.record_count = 0 self.progress = object self.old_pk_values = {} self.read_only = READ_ONLY # connect to the database constr = "DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};FIL={MS Access};DBQ=" + self.mdb_path try: conn = pyodbc.connect(constr, timeout=3) self.cur = conn.cursor() except Exception as e: logger("Couldn't connect. Error: {}".format(e)) return # determine primary key(s) if table table = self.cur.tables(table=self.mdb_table).fetchone() if table.table_type == 'TABLE': self.pk_cols = [ row[8] for row in self.cur.statistics(self.mdb_table) if row[5] == 'PrimaryKey' ] elif table.table_type == 'VIEW': self.pk_cols = [] else: logger("Database object type '{}' not supported".format( table.table_type)) return # get record count try: self.cur.execute("SELECT COUNT(*) FROM {}".format(self.mdb_table)) self.record_count = self.cur.fetchone()[0] except Exception as e: self.iface.messageBar().pushWarning( "MDB Layer", "There's a problem with this table or query. Error: {}".format( e)) return # get records from the table sql = "SELECT {} FROM {}".format(self.mdb_columns, self.mdb_table) self.cur.execute(sql) # create a dictionary with fieldname:type # QgsField only supports: String / Int / Double # falling back to string for: bytearray, bool, datetime.datetime, datetime.date, datetime.time, ? field_name_types = [] field_type_map = { str: QVariant.String, unicode: QVariant.String, int: QVariant.Int, float: QVariant.Double } # create a list with a QgsFields for every db column for column in self.cur.description: if column[0] not in self.mdb_hide_columns: if column[1] in field_type_map: field_name_types.append( QgsField(column[0], field_type_map[column[1]])) else: field_name_types.append( QgsField(column[0], QVariant.String)) self.read_only = True # no reliably editing for other data types # create the layer, add columns self.lyr = QgsVectorLayer("None", 'mdb_' + mdb_table, 'memory') provider = self.lyr.dataProvider() provider.addAttributes(field_name_types) self.lyr.updateFields() # add the records self.add_records() # set read only or make connections/triggers # if there are no primary keys there is no way to edit if self.read_only or not self.pk_cols: self.lyr.setReadOnly() else: self.lyr.beforeCommitChanges.connect(self.before_commit) # add the layer the map QgsMapLayerRegistry.instance().addMapLayer(self.lyr) def add_records(self): """ Add records to the memory layer by stepping through the query result """ self.setup_progressbar( "Loading {} records from table {}...".format( self.record_count, self.lyr.name()), self.record_count) provider = self.lyr.dataProvider() for i, row in enumerate(self.cur): feature = QgsFeature() feature.setGeometry(QgsGeometry()) feature.setAttributes([flds for flds in row]) provider.addFeatures([feature]) self.update_progressbar(i) iface.messageBar().clearWidgets() iface.messageBar().pushMessage("Ready", "{} records added to {}".format( str(self.record_count), self.lyr.name()), level=QgsMessageBar.INFO) def before_commit(self): """" Just before a definitive commit (update to the memory layer) try updating the database""" # fixme: implement rollback on db fail # Update attribute values # --------------------------------------------------------------------- # changes: { fid: {pk1: value, pk2: value, etc}} changes = self.lyr.editBuffer().changedAttributeValues() field_names = [field.name() for field in self.lyr.pendingFields()] row_count = 0 for fid, attributes in changes.iteritems(): feature = self.lyr.dataProvider().getFeatures( QgsFeatureRequest(fid)).next() fields = [field_names[att_id] + " = (?)" for att_id in attributes] params = tuple(attributes.values()) # assemble SQL query where_clause, params = self.get_where_clause(feature, params) sql = "UPDATE {} SET {}".format(self.mdb_table, ", ".join(fields)) sql += where_clause logger(sql + " : " + str(params)) self.cur.execute(sql, params) row_count += self.cur.rowcount self.cur.commit() logger("changed: " + str(row_count)) # Delete features: 'DELETE * FROM spoor WHERE pk = id # --------------------------------------------------------------------- row_count = 0 fids = self.lyr.editBuffer().deletedFeatureIds() for feature in self.lyr.dataProvider().getFeatures( QgsFeatureRequest().setFilterFids(fids)): where_clause, params = self.get_where_clause(feature) # assemble SQL query sql = "DELETE * FROM {}".format(self.mdb_table) sql += where_clause logger(sql + " : " + str(params)) self.cur.execute(sql, params) row_count += self.cur.rowcount self.cur.commit() logger("deleted: " + str(row_count)) # Add features # --------------------------------------------------------------------- # fixme: implement def get_where_clause(self, feature, params=()): """ Return where_clause with pk fields and updated params""" where_clause = [] for pk in self.pk_cols: params += (feature[pk], ) where_clause.append(pk + " = (?)") where_clause = " WHERE " + " AND ".join(where_clause) return where_clause, params def setup_progressbar(self, message, maximum): if not SHOW_PROGRESSBAR: return progress_message_bar = iface.messageBar().createMessage(message) self.progress = QProgressBar() self.progress.setMaximum(maximum) self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) progress_message_bar.layout().addWidget(self.progress) iface.messageBar().pushWidget(progress_message_bar, iface.messageBar().INFO) def update_progressbar(self, progress): if SHOW_PROGRESSBAR: self.progress.setValue(progress)
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 ECOIDF(self): #Cria a lista da relacão tempo em horas relacaoTempo = self.dadosUsuario()[2] prec_line = self.dadosUsuario()[0] lat_line = self.dadosUsuario()[4] long_line = self.dadosUsuario()[5] transformacaoHoras = [] for i in relacaoTempo: transformacaoHoras.append(i / 60) # Cria uma layer tipo ponto, já em WGS84 point_layer = QgsVectorLayer("Point?crs=EPSG:4326", "coordenada", "memory") provider = point_layer.dataProvider() # Adiciona primeiro ponto pt = QgsFeature() point = QgsPoint(float(lat_line), float(long_line)) pt.setGeometry(QgsGeometry.fromPoint(point)) provider.addFeatures([pt]) # Diz para o vetor ponto para buscar mudanças com o provedor point_layer.updateExtents() #Adiciona o ponto ao mapa QgsMapLayerRegistry.instance().addMapLayer(point_layer) #point_layer é o ponto criado #Encontra o caminho do plugin em cada computador plugin_path = os.path.dirname(os.path.realpath(__file__)) #Abrir o shape das Isozona que está na pasta do plugin pol_layer = QgsVectorLayer(plugin_path, "isozonas", "ogr") #Adiciona a Layer isozonas ao mapa (NÃO É NECESSÁRIO) #QgsMapLayerRegistry.instance().addMapLayer(pol_layer) #Extrai a feição do shape das Isozonas e cruza com o shape do ponto das coordenadas #Como resultado a variável Isozona_zone_layer com a zona extraída ebl_out = processing.runalg('qgis:extractbylocation', pol_layer, point_layer, u'intersects', 0, None) if ebl_out is None: ebl_out = processing.runalg('qgis:extractbylocation', pol_layer, point_layer, u'intersects', None) Isozona_zone = ebl_out['OUTPUT'] Isozona_zone_layer = QgsVectorLayer(Isozona_zone, "Isozona_zone", "ogr") #Adiciona a Layer Isozona_zone_layer ao mapa QgsMapLayerRegistry.instance().addMapLayers([Isozona_zone_layer]) #Salva em txt os campos da layer extraída separado por vírgula filename = self.dadosUsuario()[3] + '\dadosIsozona.txt' output_file = open(filename, 'w') #Escreve o valor de precipitação e duração inseridos pelo usuário output_file.write("%s\n" % (prec_line)) #Escreve os valores da feição do shape das isozonas Isozona_fields = Isozona_zone_layer.pendingFields() Isozona_fieldnames = [field.name() for field in Isozona_fields] for f in Isozona_zone_layer.getFeatures(): line = '\n'.join(unicode(f[x]) for x in Isozona_fieldnames) unicode_line = line.encode('utf-8') output_file.write(unicode_line) output_file.close() #Abre o arquivo txt para leitura output_file = open(filename, 'r') #Separa os valores em lista porcentagemChuva = output_file.read().split('\n') #Remove os primeiros valores da lista del porcentagemChuva[0:3] #Transforma a lista em float floatChuva = [] for i in porcentagemChuva: floatChuva.append(float(i)) #Multiplica a precipitação inserida pelo usuário pelos valores da porcentagem da chuva chuvaFinal = [] for i in floatChuva: chuvaFinal.append(i * (float(prec_line) / 100)) #Cria a lista da intensidade dividindo a precipitação pela relacaoTempo em horas intensidade = [ chuvaFinali / transformacaoHorasi for chuvaFinali, transformacaoHorasi in zip( chuvaFinal, transformacaoHoras) ] #self.ECOIDF()[0] e self.ECOIDF()[1] return chuvaFinal, intensidade
from qgis.core import QGis, QgsMapLayerRegistry, QgsFeature, QgsVectorLayer def touchesLayer(point, exclude_id, layer): for feature in layer.getFeatures(): vertex_list = feature.geometry().asPolyline() if feature.id() != exclude_id and point.compare( vertex_list[0]) or point.compare(vertex_list[-1]): return True return False intersectionLayer = QgsVectorLayer("Point?crs=epsg:3857&field=rif_id:integer", "nodi", "memory") if layer.geometryType() == QGis.Line: features = [] for feature in layer.getFeatures(): vertex_list = feature.geometry().asPolyline() for node in (vertex_list[0], vertex_list[-1]): if touchesLayer(node, feature.id(), layer): new_feature = QgsFeature(intersectionLayer.pendingFields()) new_feature.setAttribute('rif_id', feature.id()) new_feature.setGeometry(QgsGeometry.fromPoint(node)) features.append(new_feature) intersectionLayer.dataProvider().addFeatures(features) QgsMapLayerRegistry.instance().addMapLayer(intersectionLayer)
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_() GTFSDir = self.dlg.GTFSLocation.text() StopsFile = self.dlg.StopsFile.text() StopsShapefileName = self.dlg.StopsShapefileName.text() #####output_shp = ##output_file = open(filename, 'w') # See if OK was pressed if result: print "one" stop_id = "UNK" stop_name = "UNK" stop_lat = "UNK" stop_lon = "UNK" c_stop_id = 0 c_stop_name = 0 c_stop_lat = 0 c_stop_lon = 0 counter = 0 text_file = os.path.join(GTFSDir, StopsFile) #text_file = 'C:/UWGIS/Geog569/Data/Test/stops.txt' ## EPSG_code = 4326 EPSG_code_WM = 3857 StopsShapefilePath = os.path.join(GTFSDir, StopsShapefileName + ".shp") StopsShapefilePathWM = os.path.join(GTFSDir, StopsShapefileName + "WM.shp") ###export_shp = "C:/UWGIS/Geog569/Data/Test/stoptest1.shp" spatialReference = osgeo.osr.SpatialReference() #will create a spatial reference locally to tell the system what the reference will be spatialReference.ImportFromEPSG(int(EPSG_code)) #here we define this reference to be the EPSG code driver = osgeo.ogr.GetDriverByName('ESRI Shapefile') # will select the driver for our shp-file creation. shapeData = driver.CreateDataSource(StopsShapefilePath) #so there we will store our data layer = shapeData.CreateLayer('layer', spatialReference, osgeo.ogr.wkbPoint) #this will create a corresponding layer for our data with given spatial information. layer_defn = layer.GetLayerDefn() # gets parameters of the current shapefile index = 0 spatialReferenceWM = osgeo.osr.SpatialReference() #will create a spatial reference locally to tell the system what the reference will be spatialReferenceWM.ImportFromEPSG(int(EPSG_code_WM)) #here we define this reference to be the EPSG code driver = osgeo.ogr.GetDriverByName('ESRI Shapefile') # will select the driver for our shp-file creation. shapeDataWM = driver.CreateDataSource(StopsShapefilePathWM) #so there we will store our data layerWM = shapeDataWM.CreateLayer('layerWM', spatialReferenceWM, osgeo.ogr.wkbPoint) #this will create a corresponding layer for our data with given spatial information. layerWM_defn = layerWM.GetLayerDefn() # gets parameters of the current shapefile index = 0 ###print "two" fieldnames = [] with open(text_file, 'r') as f: first_line = f.readline() fl = first_line.split(",") for fn in fl: fieldnames.append(fn) for f in fl: #print f if f == "stop_id": c_stop_id = counter if f == "stop_name": c_stop_name = counter if f == "stop_lat": c_stop_lat = counter print "c_stop_lat" print c_stop_lat if f == "stop_lon": c_stop_lon = counter new_field = ogr.FieldDefn(f, ogr.OFTString) #we will create a new field with the content of our header print "three" layer.CreateField(new_field) ##layerWM.CreateField(new_field) counter = counter + 1 print "four" stop_layer = QgsVectorLayer(StopsShapefilePath, "stop_layer", "ogr") stop_layer.startEditing() #stop_layer = iface.addVectorLayer(StopsShapefilePath, "stop_layer", "ogr") if not stop_layer: print "Layer failed to load!" ##for line in text_file: with open(text_file, 'r') as f: lines = f.readlines() #print "len(line)" #print len(line) #l = str(line).split(",") #print line for line in lines: #print line l = str(line).split(",") #print l[0] #print "c_stop_lat, c_stop_lon" #print c_stop_lat, c_stop_lon if l[c_stop_id] != "stop_id": stop_id = l[c_stop_id] if l[c_stop_name] != "stop_name": stop_name = l[c_stop_name] if l[c_stop_lat] != "stop_lat": stop_lat = float(l[c_stop_lat]) if l[c_stop_lon] != "stop_lon": stop_lon = float(l[c_stop_lon]) ##DICT_stop_lon [l[c_stop_id]] = l[c_stop_lon] ##print(stop_lat, stop_lon) if type(stop_lat) == float: if type (stop_lon) == float: print(stop_lat, stop_lon) caps = stop_layer.dataProvider().capabilities() caps_string = stop_layer.dataProvider().capabilitiesString() print caps_string # Check if a particular capability is supported: ##caps & QgsVectorDataProvider.DeleteFeatures # Print 2 if DeleteFeatures is supported #caps = layer.dataProvider().capabilities() if caps & QgsVectorDataProvider.AddFeatures: feat = QgsFeature(stop_layer.pendingFields()) #feat.setAttributes([0, 'hello']) #feat.setAttributes(['stop_id', str(stop_id)]) #feat.setAttributes([0, 'hello']) # Or set a single attribute by key or by index: #feat.setAttribute('stop_id', stop_id) feat.setAttribute(2, 'hello') feat.setGeometry(QgsGeometry.fromPoint(QgsPoint(float(stop_lon), float(stop_lat)))) (res, outFeats) = stop_layer.dataProvider().addFeatures([feat]) top_layer.commitChanges()
class NewObject(QDockWidget, Ui_NewObject): def __init__(self, iface, objecttype, project, lang_dict, lang): # setup UI and connect the buttons QDockWidget.__init__(self) self.iface = iface self.setupUi(self) # get variable references from "GeODinQGIS_Main" self.obj_type = objecttype.name self.loctype = objecttype.gen_desc self.path = project.parent.filepath self.dbtype = project.parent.options["connection"] self.alias = project.parent.name self.project_names = project.name self.proj_ID = project.id self.plugin_dir = os.path.dirname(__file__) self.saveFileFolder = self.plugin_dir + "/tmp/" self.lgr = logging.getLogger('GeODinQGIS.NewObject') self.lang_dict = lang_dict self.lang = lang # select whole table row instead of single cell self.coord_tab.setSelectionBehavior(QAbstractItemView.SelectRows) # some empty lists to store coordinates from map canvas self.x_list = [] self.y_list = [] self.id_list = [] self.rows = [] self.attrs_list = [] self.shortname = None self.easting = None self.northing = None # reference to the map canvas self.canvas = self.iface.mapCanvas() # define button signals for vector file management self.btn_createshp.clicked.connect(self.createVector) self.btn_openshp.clicked.connect(self.openVector) self.btn_dragshp.clicked.connect(self.dragVector) # set behavior to load an existing vector file from layer registry to coordinate table self.open = False self.drag = False #self.btn_dragshp.setEnabled(False) self.btn_geodin.setEnabled(False) self.btn_del.setEnabled(False) self.btn_desel.setEnabled(False) self.cmb_short.setEnabled(True) # connect buttons to their functions self.btn_geodin.clicked.connect(self.geodin) self.btn_close.clicked.connect(self.close) self.btn_del.clicked.connect(self.delete) self.btn_desel.clicked.connect(self.deselect) self.cmb_short.currentIndexChanged.connect(self.shortNameChoose) self.cmb_east.currentIndexChanged.connect(self.eastingChoose) self.cmb_north.currentIndexChanged.connect(self.northingChoose) # manage button icons self.btn_createshp.setIcon( QIcon(":\plugins\GeODinQGIS\icons\point_create_n.png")) self.btn_openshp.setIcon( QIcon(":\plugins\GeODinQGIS\icons\point_add_n.png")) self.btn_dragshp.setIcon( QIcon(":\plugins\GeODinQGIS\icons\point_drag_n.png")) self.btn_del.setIcon(QIcon(":\plugins\GeODinQGIS\icons\delete.png")) self.btn_geodin.setIcon(QIcon(":\plugins\GeODinQGIS\icons\logo.png")) self.btn_desel.setIcon(QIcon(":\plugins\GeODinQGIS\icons\minus.png")) self.btn_del.setIconSize(QSize(24, 24)) self.btn_geodin.setIconSize(QSize(24, 24)) self.btn_desel.setIconSize(QSize(24, 24)) self.btn_createshp.setIconSize(QSize(24, 24)) self.btn_openshp.setIconSize(QSize(24, 24)) self.btn_dragshp.setIconSize(QSize(24, 24)) # manage tool tips createshp = self.lang_dict.getWord(self.lang, "Create new shape file") loadshp = self.lang_dict.getWord(self.lang, "Load shape file from file system") dragshp = self.lang_dict.getWord(self.lang, "Load shape file from layers panel") deleteRow = self.lang_dict.getWord(self.lang, "Delete selected rows") deselectRow = self.lang_dict.getWord(self.lang, "Deselect rows") openGeodin = self.lang_dict.getWord(self.lang, "Import to GeODin") self.btn_createshp.setToolTip(createshp) self.btn_openshp.setToolTip(loadshp) self.btn_dragshp.setToolTip(dragshp) self.btn_del.setToolTip(deleteRow) self.btn_desel.setToolTip(deselectRow) self.btn_geodin.setToolTip(openGeodin) # # set headers for child nodes # if self.obj_type == "All Objects": # self.le_obtyp.setText("All Objects") # else: # self.le_obtyp.setText(self.obj_type) self.delete = False self.editMode = False # clear coordinate table self.coord_tab.setRowCount(0) # decimal places self.dp = 8 # self.coord_tab.itemChanged.connect(self.Changed) #self.coord_tab.cellClicked.connect(self.clicked) self.coord_tab.itemSelectionChanged.connect(self.selectionChanged) self.root = QgsProject.instance().layerTreeRoot() def dragVector(self): # open layer list table to drag shape into coordinate table sel = DragShp(self.iface, self.lang_dict, self.lang) sel.show() sel.exec_() # set open file name for shape (filePath) # add shape to coordinate table if sel.accepted: self.drag = True self.openName = sel.filePath self.loadVector() def onremovedChildren(self, node, indexFrom, indexTo): # execute if a layer has been removed from QGIS layer list # ,ap over layer ID's in layer list ids = self.root.findLayerIds() # deleted, if layer ID cannot be found in layer list if self.layerID not in ids: # if layer was loaded in coordinate table, empty it self.coord_tab.setRowCount(0) def Started(self): # if editing mode has been toggled on self.editMode = True self.cmb_short.setEnabled(False) # table cell is only editable if has been double clicked if not QAbstractItemView == None: self.coord_tab.setEditTriggers(QAbstractItemView.DoubleClicked) # if one or more item have been selected, deletion allowed if len(self.coord_tab.selectedItems()) > 0: self.btn_del.setEnabled(True) def Stopped(self): # turn edit triggers and deletion off self.editMode = False if not QAbstractItemView == None: self.coord_tab.setEditTriggers(QAbstractItemView.NoEditTriggers) self.btn_del.setEnabled(False) self.cmb_short.setEnabled(True) if len(self.cmb_short.currentText()) > 0: self.shortname = self.cmb_short.currentText() else: self.shortname = None if len(self.cmb_east.currentText()) > 0: self.easting = self.cmb_east.currentText() else: self.easting = None if len(self.cmb_north.currentText()) > 0: self.northing = self.cmb_north.currentText() else: self.northing = None # read attribute table and insert items into coordinate table self.insertItem() self.v_points.updateFields() self.selectionChanged() def Changed(self, item): # if item has been changed in coordinate table # editing mode is required # print self.coord_tab.currentColumn() # print self.coord_tab.currentRow() if self.v_points.isEditable(): # print self.coord_tab.currentItem() # print self.coord_tab.currentColumn() # print self.coord_tab.currentRow() # coordinate which has been edited (only one at a time) coord_edit = float(self.coord_tab.currentItem().text()) # change coordinate equals "coord_edit" if self.coord_tab.currentColumn() == 1: x = coord_edit y = float(self.coord_tab.item(self.rows[0], 2).text()) elif self.coord_tab.currentColumn() == 2: x = float(self.coord_tab.item(self.rows[0], 1).text()) y = coord_edit # QGIS internal functions # move vertex to new coordinates ch = QgsVectorLayerEditUtils(self.v_points) ch.moveVertex(x, y, self.rows[0], 0) def selectionChanged(self): #its = self.coord_tab.selectedItems() # write list with indices of all selected rows lines = self.coord_tab.selectionModel().selectedRows() self.btn_desel.setEnabled(True) # new empty list # loop over lines and add to rowlist # sort reversed self.rows = [] for idx in lines: self.rows.append(idx.row()) self.rows.sort(reverse=True) if len(self.rows) == 1: # get coordinates from selection self.coord_x = self.coord_tab.item(self.rows[0], 1).text() self.coord_y = self.coord_tab.item(self.rows[0], 2).text() self.name = self.coord_tab.item(self.rows[0], 0).text() self.btn_geodin.setEnabled(True) else: self.btn_geodin.setEnabled(False) self.sel_x = [] self.sel_y = [] self.sel_id = [] self.sel_attrs = [] for i in self.rows: id = self.id_list[i] self.sel_id.append(id) x_coord = self.x_list[i] self.sel_x.append(x_coord) y_coord = self.y_list[i] self.sel_y.append(y_coord) if self.editMode: self.btn_del.setEnabled(True) def delete(self): self.delete = True # delete entries from coordinate list and from temporary shape file # self.le_east.clear() # self.le_north.clear() self.rows.sort(reverse=True) # map over vector layer and get attributes features = self.v_points.getFeatures() for f in features: fid = str(f.id()) # map over selected ID's # check if feature ID matches selected ID for i in self.sel_id: if i == fid: self.v_points.deleteFeature(f.id()) self.v_points.dataProvider().forceReload() self.v_points.triggerRepaint() #delete from self.coord_tab for row in self.rows: self.coord_tab.removeRow(row) self.rows = [] self.btn_del.setEnabled(False) self.delete = False def openVector(self): # load vector file from file system self.open = True # get path of vector file self.openName = QFileDialog.getOpenFileName(self, "Load Vector Layer", ".", "Shape (*.shp)") # if open dialog has been aborted if not self.openName: return # take file path and load vector file self.loadVector() def loadVector(self): self.v_points = None # name of loaded shape file equals geodin object type self.display_name = self.obj_type # get reference of shape self.v_points = QgsVectorLayer(self.openName, self.display_name, "ogr") # vector file must be a point shape # important for vector drag from layer list if not self.v_points.wkbType() == QgsWkbTypes.Point: QMessageBox.information( None, self.lang_dict.getWord(self.lang, "Wrong Datatype"), self.lang_dict.getWord(self.lang, "You must load a Point Shape")) return # if vector file has been loaded from file system if self.open == True: # add file to map canvas QgsProject.instance().addMapLayer(self.v_points) self.addVector() self.open = False # if vector file has been dragged from layer list elif self.drag == True: self.addVector() self.drag = False def addVector(self): # get reference from layer list to loaded vector layer # build coordinate table # map over layer list layers = QgsProject.instance().mapLayers() # split into layer ID and layer instance for ID, layer in layers.iteritems(): source = layer.source() # if paths of vector layer equal each other # take instance of vector layer from layer list if self.openName == source: self.v_points = layer self.layerID = ID # execute if layer has been removed self.root.removedChildren.connect(self.onremovedChildren) # select short name, easting and northing from attribute table self.cmb_short.clear() self.cmb_east.clear() self.cmb_north.clear() self.cmb_short.addItem("") self.cmb_east.addItem("") self.cmb_north.addItem("") for field in self.v_points.pendingFields(): self.cmb_short.addItem(field.name()) self.cmb_east.addItem(field.name()) self.cmb_north.addItem(field.name()) # fill coordinate table and update attribute table self.insertItem() # toggle editing modes self.v_points.editingStarted.connect(self.Started) self.v_points.editingStopped.connect(self.Stopped) def createVector(self): # name of shape file equals object type self.display_name = self.obj_type # create temporary shape file tmplayer = QgsVectorLayer("Point", self.display_name, "memory") provider = tmplayer.dataProvider() # Enter editing mode tmplayer.startEditing() # add attribute fields to shape provider.addAttributes([ QgsField("INVID", QVariant.String), QgsField("SHORTNAME", QVariant.String), QgsField("LONGNAME", QVariant.String), QgsField("XCOORD", QVariant.Double), QgsField("YCOORD", QVariant.Double), QgsField("DBTYPE", QVariant.String), QgsField("DATABASE", QVariant.String), QgsField("PRJNAME", QVariant.String), QgsField("PRJID", QVariant.String), QgsField("OBJECTTYPE", QVariant.String) ]) tmplayer.commitChanges() # get file name to be saved outName = QFileDialog.getSaveFileName( self, "Save Vector Layer", self.saveFileFolder + self.display_name.replace(" ", "_"), "Shape (*.shp)") if not outName: return self.saveFileFolder = os.path.dirname(outName) + "/" # declare options for temporary shape layer QgsVectorFileWriter.writeAsVectorFormat(tmplayer, outName, "CP1250", None, "ESRI Shapefile") # turn temporary layer into QGIS vector layer self.v_points = QgsVectorLayer(outName, self.display_name, "ogr") # add vector file to QGIS layer registry QgsMapLayerRegistry.instance().addMapLayer(self.v_points) # find layer ID's of all layer in layer registry ids = self.root.findLayerIds() # if layer registry is empty, return if not ids: return # if layer registry is not empty, take top level layer ID else: self.layerID = ids[0] # exeute if layer has been removed self.root.removedChildren.connect(self.onremovedChildren) # toggle editing modes self.v_points.editingStarted.connect(self.Started) self.v_points.editingStopped.connect(self.Stopped) def shortNameChoose(self, shortname): self.shortname = shortname self.insertItem(True) def eastingChoose(self, easting): self.easting = easting self.insertItem(True) def northingChoose(self, northing): self.northing = northing self.insertItem(True) def insertItem(self, chooseField=False): #print shortname, easting, northing # create empty coordinate and ID lists self.x_list = [] self.y_list = [] self.id_list = [] self.short_list = [] # touch vector file and get feature information features = self.v_points.getFeatures() fields = self.v_points.pendingFields() # map over features (row in attribute table, object/point in canvas) for f in features: fid = str(f.id()) geom = f.geometry() #print f.attributes() # get feature coordinates from the map x = str(round(geom.asPoint().x(), self.dp)) y = str(round(geom.asPoint().y(), self.dp)) attrs = f.attributes() # a = attrs[1] # build lists with feature information if self.easting: if fields[fields.fieldNameIndex(self.easting)].type() == 6: self.x_list.append(f[self.easting]) else: self.x_list.append('') else: self.x_list.append(x) if self.northing: if fields[fields.fieldNameIndex(self.northing)].type() == 6: self.y_list.append(f[self.northing]) else: self.y_list.append('') else: self.y_list.append(y) self.id_list.append(fid) # short name is None, if nothing was selected, 1st column will be empty # if short name exists, append to list to write into table if self.shortname and not f[self.shortname] == None: self.short_list.append(f[self.shortname]) else: self.short_list.append('') self.coord_tab.setRowCount(len(self.x_list)) try: # insert short name into table for i, row in enumerate(self.short_list): short_input = QTableWidgetItem(row) self.coord_tab.setItem(i, 0, short_input) # insert x-coordinate into table for j, row in enumerate(self.x_list): x_input = QTableWidgetItem(str(row)) self.coord_tab.setItem(j, 1, x_input) # insert y-coordinate into table for k, row in enumerate(self.y_list): y_input = QTableWidgetItem(str(row)) self.coord_tab.setItem(k, 2, y_input) except TabError as te: msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText(str(te)) msg.exec_() except Exception as ex: msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText(str(ex)) msg.exec_() # touch vector file again and update attribute table # important if information had been changed in coordinate table # need to be in editing mode # features = self.v_points.getFeatures() if not chooseField: caps = self.v_points.dataProvider().capabilities() for i, f in enumerate(features): fid = f.id() # get coordinates from coordinate table x = self.coord_tab.item(i, 1).text() y = self.coord_tab.item(i, 2).text() # enter information into attribute table if caps & QgsVectorDataProvider.ChangeAttributeValues: attrs = { 3: x, 4: y, 5: self.dbtype, 6: self.path, 7: self.project_names, 8: self.proj_ID, 9: self.obj_type } self.v_points.dataProvider().changeAttributeValues( {fid: attrs}) def keyPressEvent(self, event): #Did the user press the Enter key? if event.key() == Qt.Key_Return or event.key( ) == Qt.Key_Enter or event.key( ) == Qt.Key_Tab: #QtCore.Qt.Key_Escape is a value that equates to what the operating system passes to python from the keyboard when the escape key is pressed. #Yes: Close the window print("key pressed") #No: Do nothing. def clicked(self, currentRow): print("clicked") # write list with indices of all selected rows line = self.coord_tab.selectionModel().selectedRows() self.btn_desel.setEnabled(True) # new empty list # loop over lines and add to rowlist # sort reversed self.rows = [] for idx in line: self.rows.append(idx.row()) self.rows.sort(reverse=True) if len(self.rows) == 1: self.btn_geodin.setEnabled(True) self.sel_x = [] self.sel_y = [] self.sel_id = [] self.sel_attrs = [] # get coordinates from selection self.coord_x = self.coord_tab.item(self.rows[0], 1).text() self.coord_y = self.coord_tab.item(self.rows[0], 2).text() self.name = self.coord_tab.item(self.rows[0], 0).text() for i in self.rows: id = self.id_list[i] self.sel_id.append(id) x_coord = self.x_list[i] self.sel_x.append(x_coord) y_coord = self.y_list[i] self.sel_y.append(y_coord) # self.le_east.clear() # self.le_north.clear() # self.le_east.insert(self.coord_x) # self.le_north.insert(self.coord_y) if len(self.rows) != 1: # self.le_east.clear() # self.le_north.clear() self.btn_geodin.setEnabled(False) if self.editMode: self.btn_del.setEnabled(True) def geodin(self): #self.lgr.warning('GeODin COM') # connect to GeODin COM functions for cell in self.coord_tab.selectedItems(): shortname = cell.text() break FieldValues = "" features = self.v_points.getFeatures() for feature in features: if feature[self.shortname] == shortname: for field in feature.fields(): #print field.name().lower() #if field.name() != self.shortname and field.name() != self.easting and field.name() != self.northing and field.name().lower() != 'invid' and field.name().lower() != 'objecttype': if not str(feature[field.name()]) == 'NULL' and not str( feature[field.name()]) == '': FieldValues += field.name() + "=" + str( feature[field.name()]) + "\n" try: GeODin = win32com.client.Dispatch("GeODin.GeODinApplication") # x = self.le_east.text() # y = self.le_north.text() short = "NAME=B101" if len(self.coord_x) == 0: QMessageBox.information( None, self.lang_dict.getWord(self.lang, "Selection Error"), self.lang_dict.getWord( self.lang, "Nothing to read. Please select the row to be written into GeODin." )) else: # select object type in GeODin obeject manager Params = "[Params]\n" Database = "Database=" Username = "******" Password = "******" Objecttype = "\nObjectType=1" Parentnode = "\nParentNode=ProjectQueries" Object_ID = "\nObjectID=" Expand = "\nExpand=true" params = Params + Database + self.alias + Username + Password + Objecttype + Parentnode + Object_ID + self.proj_ID + Expand print(params) #self.lgr.warning(params) # execute method GeODin.SelectObject(params) # set parameters to create a new object Params = "[Params]\n" ApplyFieldValues = "ApplyFieldValues=True" XCOORDS = "\nXCOORD=" YCOORDS = "\nYCOORD=" OBJECTTYPE = "\nOBJECTTYPE=" NAME = "\nNAME=" PRJID = "\nPRJID=" FieldValueSection = "\n[FieldValues]\n" params = Params + ApplyFieldValues + XCOORDS + self.coord_x + YCOORDS + self.coord_y + OBJECTTYPE + self.loctype + NAME + self.name + PRJID + self.proj_ID + FieldValueSection + FieldValues print(params) #self.lgr.warning(params) # execute method to create new object error = GeODin.ExecuteMethodParams(39, params) if error: #print "Error ID:"+ str(GeODin.ExceptionValue) self.lgr.info("Error ID: " + str(GeODin.ExceptionValue)) #print "Error Message:"+GeODin.ExceptionMsg self.lgr.info("Error Message: " + GeODin.ExceptionMsg) time.sleep(3) except: print("Unexpected error:", sys.exc_info()[0]) GeODin = None def deselect(self): self.rows = [] self.sel_x = [] self.sel_y = [] selected = self.coord_tab.selectedRanges() for i in range(len(selected)): self.coord_tab.setRangeSelected(selected[i], False) # self.le_east.clear() # self.le_north.clear() self.btn_desel.setEnabled(False)
class ReorderProcess(): """Along line point reordering according to given destination""" def __init__(self, exutoire, point_reseau): """Set all informations needed to order the network""" self.exutoire_layer = exutoire self.point_reseau_layer = point_reseau self.crs = QgsCoordinateReferenceSystem( self.point_reseau_layer.crs().authid()) # Create ouput self.output = QgsVectorLayer("Point", "point", "memory") self.output.setCrs(self.crs) # Add fields name_T_id = "T_id" name_L_id = "L_id" name_P_id = "P_id" name_nat = "nature" provider = self.output.dataProvider() caps = provider.capabilities() if caps & QgsVectorDataProvider.AddAttributes: res = provider.addAttributes([ QgsField(name_T_id, QVariant.String), QgsField(name_L_id, QVariant.String), QgsField(name_P_id, QVariant.String), QgsField(name_nat, QVariant.String) ]) self.output.updateFields() # Save field index self.index_nat = self.point_reseau_layer.fieldNameIndex('nature') self.index_pid = self.point_reseau_layer.fieldNameIndex('P_id') self.index_order = self.point_reseau_layer.fieldNameIndex('order') self.l_done = [] def reorder(self, pt, count_order): feat = QgsFeature(self.output.pendingFields()) pt_geom = pt.geometry() feat.setGeometry(pt_geom) tid = pt.attribute("T_id") lid = pt.attribute("L_id") ppid = pt.attribute("P_id") nat = pt.attribute("nature") if nat == 'start': self.output.startEditing() feat.setAttributes([tid, str(count_order), ppid, nat]) print 'reorder: %s' % ([tid, lid, ppid, nat, str(count_order)]) self.output.dataProvider().addFeatures([feat]) self.output.commitChanges() self.output.updateExtents() while nat != 'end': expr = QgsExpression('L_id = %s and P_id = %s' % (lid, str(int(ppid) + 1))) req = QgsFeatureRequest(expr) n_pt_it = self.point_reseau_layer.getFeatures(req) n_pt = n_pt_it.next() n_pt_it = None feat = QgsFeature(self.output.pendingFields()) n_pt_geom = n_pt.geometry() feat.setGeometry(n_pt_geom) tid = n_pt.attribute("T_id") lid = n_pt.attribute("L_id") ppid = n_pt.attribute("P_id") nat = n_pt.attribute("nature") self.output.startEditing() feat.setAttributes([tid, str(count_order), ppid, nat]) print[tid, lid, ppid, nat, str(count_order)] self.output.dataProvider().addFeatures([feat]) self.output.commitChanges() self.output.updateExtents() else: pid = 0 self.output.startEditing() feat.setAttributes([tid, str(count_order), str(pid), 'start']) print[tid, lid, str(pid), 'start', str(count_order)] self.output.dataProvider().addFeatures([feat]) self.output.commitChanges() self.output.updateExtents() nat = None feat = None while nat != 'start': ppid = str(int(ppid) - 1) expr = QgsExpression('L_id = %s and P_id = %s' % (lid, ppid)) req = QgsFeatureRequest(expr) n_pt_it = self.point_reseau_layer.getFeatures(req) n_pt = n_pt_it.next() n_pt_it = None feat = QgsFeature(self.output.pendingFields()) n_pt_geom = n_pt.geometry() feat.setGeometry(n_pt_geom) tid = n_pt.attribute("T_id") nat = n_pt.attribute("nature") if nat != 'start': pid += 1 self.output.startEditing() feat.setAttributes([tid, str(count_order), str(pid), nat]) print[tid, lid, str(pid), nat, str(count_order)] self.output.dataProvider().addFeatures([feat]) self.output.commitChanges() self.output.updateExtents() feat = None else: pid += 1 self.output.startEditing() feat.setAttributes( [tid, str(count_order), str(pid), 'end']) print[tid, lid, str(pid), 'end', str(count_order)] self.output.dataProvider().addFeatures([feat]) self.output.commitChanges() self.output.updateExtents() feat = None def executeReorder(self): count_order = 0 # loop over exutoire features to process several network for exutoire in self.exutoire_layer.getFeatures(): exutoire_geom = exutoire.geometry().buffer(1, 4).boundingBox() # Select the start point that intersects the outlet req = QgsFeatureRequest().setFilterRect(exutoire_geom) pts_reseau_sortie = self.point_reseau_layer.getFeatures(req) for pt_sortie in pts_reseau_sortie: count_order += 1 L_id = pt_sortie.attribute("L_id") # Reorder the points of the first line of the network self.reorder(pt_sortie, count_order) nat = 'end' string = "L_id = %s AND nature = '%s'" % (count_order, nat) print string expr = QgsExpression(string) reque = QgsFeatureRequest(expr) # Select the last point of the first line pt_end_it = self.output.getFeatures(reque) pt_end = pt_end_it.next() pt_end_it = None # Make a buffer around the point to define a boundingBox pt_end_geom = pt_end.geometry().buffer(1, 4).boundingBox() req = QgsFeatureRequest( QgsExpression("L_id != %s" % (str(L_id)))).setFilterRect(pt_end_geom) # Select the next points next_ls = self.point_reseau_layer.getFeatures(req) self.l_done.append(L_id) list_next = [] # Fill next_ls list with the next features for next_l in next_ls: list_next.append(next_l) # While there is features in list_next, reorder process continues while len(list_next) != 0: current_list = list_next list_next = [] # Loop over the next features for next_pt in current_list: # Get line id L_id = next_pt.attribute("L_id") print L_id # if the line has not been already reorder if L_id not in self.l_done: count_order += 1 #then reorder self.reorder(next_pt, count_order) string = "L_id = %s AND nature='%s'" % ( count_order, nat) print string expr = QgsExpression(string) req = QgsFeatureRequest(QgsExpression(expr)) pt_end_it = self.output.getFeatures(req) pt_end = pt_end_it.next() pt_end_it = None pt_end_geom = pt_end.geometry().buffer( 1, 4).boundingBox() # Find the next feature reque = QgsFeatureRequest( QgsExpression( "L_id != %s" % (L_id))).setFilterRect(pt_end_geom) next_ls = self.point_reseau_layer.getFeatures( reque) self.l_done.append(L_id) # Fill next_ls list again and loop for next_l in next_ls: list_next.append(next_l) print len(list_next) expr = QgsExpression("nature = 'end'") req = QgsFeatureRequest(expr) end_pts = self.output.getFeatures(req) change_dict = {} change_list = [] rm_ids = [] #clean lines that aren't a cross border anymore because a small part has been removed for end_pt in end_pts: end_pt_geom = end_pt.geometry().buffer(1, 4).boundingBox() end_pt_id = end_pt.id() end_lid = end_pt.attribute("L_id") end_pid = end_pt.attribute("P_id") expr = QgsExpression("L_id != '%s'" % (end_lid)) req = QgsFeatureRequest(expr).setFilterRect(end_pt_geom) int_pts = [] for int_pt in self.output.getFeatures(req): lid_int_pt = int_pt.attribute("L_id") int_pts.append(int_pt) if len(int_pts) == 1: rm_ids.append(end_pt_id) if int(end_lid) in change_dict: change_dict[int(lid_int_pt)] = change_dict[int(end_lid)] else: change_dict[int(lid_int_pt)] = int(end_lid) print change_dict change_dict = sorted(change_dict.items(), key=lambda t: t[0]) for ch_tuple in change_dict: print ch_tuple[0] end_lid = str(ch_tuple[1]) end_pid = None for end_pt in self.output.getFeatures( QgsFeatureRequest( QgsExpression("L_id = '%s' and nature = '%s'" % (end_lid, "end")))): if end_pid is None: end_pid = end_pt.attribute("P_id") elif int(end_pid) < int(end_pt.attribute("P_id")): end_pid = end_pt.attribute("P_id") expr = QgsExpression("L_id = '%s'" % (str(ch_tuple[0]))) req = QgsFeatureRequest(expr) for ch_pt in self.output.getFeatures(req): ch_pt_id = ch_pt.id() if ch_pt.attribute("nature") == "start": rm_ids.append(ch_pt_id) else: ch_tid = ch_pt.attribute("T_id") ch_nature = ch_pt.attribute("nature") self.output.startEditing() self.output.changeAttributeValue(ch_pt_id, 1, end_lid) self.output.changeAttributeValue(ch_pt_id, 2, end_pid) self.output.commitChanges() end_pid = int(end_pid) + 1 self.output.startEditing() self.output.deleteFeatures(rm_ids) self.output.commitChanges() return self.output, self.crs