def getmap(self): if self.canvas: settings = self.canvas.mapSettings() layers = settings.layers() if GPS.isConnected: try: gpslayer = QgsMapLayerRegistry.instance().mapLayersByName( "__gps_layer")[0] except IndexError: gpslayer = QgsVectorLayer("Point", "__gps_layer", "memory") symbol = QgsMarkerSymbolV2.createSimple({ 'name': 'circle', 'color': 'blue', "size": '5' }) gpslayer.rendererV2().setSymbol(symbol) QgsMapLayerRegistry.instance().addMapLayer(gpslayer, False) layers.append(gpslayer.id()) settings.setLayers(layers) map_pos = QgsPoint(GPS.gpsinfo("longitude"), GPS.gpsinfo("latitude")) # map_pos = QgsPoint(115.72589,-32.29597) geom = QgsGeometry.fromPoint(map_pos) feature = QgsFeature() feature.setGeometry(geom) gpslayer.startEditing() gpslayer.addFeature(feature) # gpslayer.commitChanges() self.renderjob = QgsMapRendererParallelJob(settings) self.renderjob.finished.connect(self.rendermap) self.renderjob.start()
def geraMapaBacia(self, cotrecho, cobacia, dist): # manda gerar a tabela montante_jusante.area_mont_x na base de dados (x é o código do trecho) # gera o string sql string_sql = 'SELECT gera_tabela_topologica(\'area_mont\', ' + str(cotrecho) + ', \'' + cobacia + '\', ' + '{0:.6f}'.format(dist) + ')' # estabelece uma conexão com a base de dados PostGIS com dados da conexao da camada hidrografia armazenados em self.uri_ex conn = psycopg2.connect(host=self.uri_ex.host(), port=self.uri_ex.port(), database=self.uri_ex.database(), user=self.uri_ex.username(), password=self.uri_ex.password()) # executa o comando sql, que gera a tabela montante_jusante.area_montante_xxx, onde xxx é o id do trecho cur = conn.cursor() cur.execute(string_sql) # se assegura que as alterações da base de dados foram feitas e fecha o cursor e a conexão conn.commit() cur.close() conn.close() # seleciona a tabela montante_jusante.area_mont_xxx - coluna geomproj self.uri.setDataSource('montante_jusante', 'area_mont_' + str(cotrecho) , 'geomproj') #gera o titulo do mapa titulo = 'Area a montante de ' + str(cotrecho) #gera o mapa e acrescenta ao projeto mapa = QgsVectorLayer(self.uri.uri(), titulo, 'postgres') if not mapa.isValid(): raise ErroMapaInvalido QgsMapLayerRegistry.instance().addMapLayer(mapa) # faz com que a cor das bordas das areas de contribuicao seja a do interior e refresca o mapa propriedades = mapa.rendererV2().symbol().symbolLayers()[0].properties() propriedades['outline_color'] = propriedades['color'] mapa.rendererV2().setSymbol(QgsFillSymbolV2.createSimple(propriedades))
def geraMapaBacia(self, cotrecho, cobacia, dist): # manda gerar a tabela montante_jusante.area_mont_x na base de dados (x é o código do trecho) # gera o string sql string_sql = 'SELECT gera_tabela_topologica(\'area_mont\', ' + str( cotrecho) + ', \'' + cobacia + '\', ' + '{0:.6f}'.format( dist) + ')' # estabelece uma conexão com a base de dados PostGIS com dados da conexao da camada hidrografia armazenados em self.uri_ex conn = psycopg2.connect(host=self.uri_ex.host(), port=self.uri_ex.port(), database=self.uri_ex.database(), user=self.uri_ex.username(), password=self.uri_ex.password()) # executa o comando sql, que gera a tabela montante_jusante.area_montante_xxx, onde xxx é o id do trecho cur = conn.cursor() cur.execute(string_sql) # se assegura que as alterações da base de dados foram feitas e fecha o cursor e a conexão conn.commit() cur.close() conn.close() # seleciona a tabela montante_jusante.area_mont_xxx - coluna geomproj self.uri.setDataSource('montante_jusante', 'area_mont_' + str(cotrecho), 'geomproj') #gera o titulo do mapa titulo = 'Area a montante de ' + str(cotrecho) #gera o mapa e acrescenta ao projeto mapa = QgsVectorLayer(self.uri.uri(), titulo, 'postgres') if not mapa.isValid(): raise ErroMapaInvalido QgsMapLayerRegistry.instance().addMapLayer(mapa) # faz com que a cor das bordas das areas de contribuicao seja a do interior e refresca o mapa propriedades = mapa.rendererV2().symbol().symbolLayers()[0].properties( ) propriedades['outline_color'] = propriedades['color'] mapa.rendererV2().setSymbol(QgsFillSymbolV2.createSimple(propriedades))
def getmap(self): if self.canvas: settings = self.canvas.mapSettings() layers = settings.layers() if GPS.isConnected: try: gpslayer = QgsMapLayerRegistry.instance().mapLayersByName("__gps_layer")[0] except IndexError: gpslayer = QgsVectorLayer("Point", "__gps_layer", "memory") symbol = QgsMarkerSymbolV2.createSimple({'name': 'circle', 'color': 'blue', "size": '5'}) gpslayer.rendererV2().setSymbol(symbol) QgsMapLayerRegistry.instance().addMapLayer(gpslayer, False) layers.append(gpslayer.id()) settings.setLayers(layers) map_pos = QgsPoint(GPS.gpsinfo("longitude"), GPS.gpsinfo("latitude")) # map_pos = QgsPoint(115.72589,-32.29597) geom = QgsGeometry.fromPoint(map_pos) feature = QgsFeature() feature.setGeometry(geom) gpslayer.startEditing() gpslayer.addFeature(feature) # gpslayer.commitChanges() self.renderjob = QgsMapRendererParallelJob(settings) self.renderjob.finished.connect(self.rendermap) self.renderjob.start()
def create_qlayer(self): layer=QgsVectorLayer("Polygon"+self.crs,self.prefix+"-cells","memory") # transparent red, no border # but this is the wrong class... symbol = QgsFillSymbolV2.createSimple({'outline_style':'no', 'style':'solid', 'color': '249,0,0,78'}) layer.rendererV2().setSymbol(symbol) return layer
class TestQgsArrowSymbolLayer(unittest.TestCase): def setUp(self): self.iface = get_iface() lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp') self.lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(self.lines_layer) # Create style sym2 = QgsLineSymbolV2.createSimple({'color': '#fdbf6f'}) self.lines_layer.setRendererV2(QgsSingleSymbolRendererV2(sym2)) self.mapsettings = self.iface.mapCanvas().mapSettings() self.mapsettings.setOutputSize(QSize(400, 400)) self.mapsettings.setOutputDpi(96) self.mapsettings.setExtent(QgsRectangle(-113, 28, -91, 40)) self.mapsettings.setBackgroundColor(QColor("white")) def tearDown(self): QgsMapLayerRegistry.instance().removeAllMapLayers() def test_1(self): sym = self.lines_layer.rendererV2().symbol() sym_layer = QgsArrowSymbolLayer.create({'head_size': '6.5'}) dd = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("arrow_width", dd) dd2 = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("head_size", dd2) fill_sym = QgsFillSymbolV2.createSimple({'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1'}) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_arrowsymbollayer_1') self.assertTrue(renderchecker.runTest('arrowsymbollayer_1')) def test_2(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({'arrow_width': '5', 'head_size': '6.5', 'head_type': '2'}) fill_sym = QgsFillSymbolV2.createSimple({'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1'}) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_arrowsymbollayer_2') self.assertTrue(renderchecker.runTest('arrowsymbollayer_2'))
def create_qlayer(self): layer= QgsVectorLayer("Point"+self.crs, self.prefix+"-nodes", "memory") # nice clean black dot symbol = QgsMarkerSymbolV2.createSimple({'outline_style':'no', 'name': 'circle', 'size_unit':'MM', 'size':'1', 'color': 'black'}) layer.rendererV2().setSymbol(symbol) return layer
def addParcelleMap(self): ''' Add content in the first page with a map and basic information ''' # First add headers for key, item in self.composerTemplates.items(): if 'sticky' in item: self.buildComposerLabel(key, item, 0) # Get feature extent exp = QgsExpression('"geo_parcelle" = \'%s\'' % self.geo_parcelle) request = QgsFeatureRequest(exp) extent = None features = self.layer.getFeatures(request) for feature in features: geom = feature.geometry() peri = geom.length() buf = peri / 20 extent = geom.buffer(buf, 5).boundingBox() # Add memory layer to highlight parcelle if extent: if self.redlineLayer: QgsMapLayerRegistry.instance().removeMapLayer( self.redlineLayer.id()) crs = self.layer.crs().authid() vl = QgsVectorLayer("Polygon?crs=" + crs, "temporary", "memory") pr = vl.dataProvider() vl.startEditing() pr.addFeatures([f for f in self.layer.getFeatures(request)]) vl.commitChanges() vl.updateExtents() props = vl.rendererV2().symbol().symbolLayer(0).properties() props['outline_width'] = u'1' props['outline_color'] = u'0,85,255,255' props['outline_style'] = u'solid' props['style'] = u'no' vl.rendererV2().setSymbol(QgsFillSymbolV2.createSimple(props)) QgsMapLayerRegistry.instance().addMapLayer(vl) self.redlineLayer = vl # Add composer map & to parcelle miLayers = self.mInstance.layers() miLayers.insert(0, vl.id()) self.mInstance.setLayers(miLayers) cm = QgsComposerMap(self.currentComposition, 6, 15, 286, 190) if extent: cm.zoomToExtent(extent) cm.setFrameEnabled(True) cm.setBackgroundEnabled(True) self.currentComposition.addItem(cm)
def addLayer(self): uri = QgsDataSourceURI() # set host name, port, database name, username and password #uri.setConnection("localhost", "5432", "jguelat", "jguelat", "") uri.setConnection("local_jguelat", "", "", "") # set database schema, table name, geometry column and optionally subset (WHERE clause) uri.setDataSource("public", self.tableCombo.currentText(), "geom", "species_id = " + self.speciesCombo.currentText()) #vlayer = self.iface.addVectorLayer(uri.uri(), "Species " + self.speciesCombo.currentText(), "postgres") vlayer = QgsVectorLayer(uri.uri(), "Species " + self.speciesCombo.currentText(), "postgres") props = vlayer.rendererV2().symbol().symbolLayer(0).properties() props['size'] = '3' props['color'] = 'blue' vlayer.rendererV2().setSymbol(QgsMarkerSymbolV2.createSimple(props)) QgsMapLayerRegistry.instance().addMapLayer(vlayer) QgsMessageLog.logMessage("Tout est OK", 'BirdChooser', QgsMessageLog.INFO)
def drawLimits2 (self): self.dlg.listWidget.clear() #comprobate if the layer already exists and delete it for lyr in QgsMapLayerRegistry.instance().mapLayers().values(): if lyr.name() == "Limites": QgsMapLayerRegistry.instance().removeMapLayer( lyr.id() ) break #crete a vector layer with a expecific name and color v_layer = QgsVectorLayer("Polygon", "Limites", "memory") v_layer.setLayerTransparency(70) symbols =v_layer.rendererV2().symbols() symbol=symbols[0] symbol.setColor(QColor('green')) #create the provider and add the layer pr = v_layer.dataProvider() poly = QgsFeature() #draw the lines between the buttons in order points = self.tool.polygon #print points[0].x() poly.setGeometry(QgsGeometry.fromPolygon([self.tool.polygon])) #add the lines to the provider and update the layer pr.addFeatures([poly]) v_layer.updateExtents() QgsMapLayerRegistry.instance().addMapLayers([v_layer]) #add the points to the QlistWidget for i in range (len(self.tool.polygon)): self.addItem(i)
def drawLimits (self): self.dlg.listWidget.clear() #comprobate if the layer already exists and delete it for lyr in QgsMapLayerRegistry.instance().mapLayers().values(): if lyr.name() == "Limites": QgsMapLayerRegistry.instance().removeMapLayer( lyr.id() ) break #crete a vector layer with a expecific name and color v_layer = QgsVectorLayer("LineString", "Limites", "memory") symbols =v_layer.rendererV2().symbols() symbol=symbols[0] symbol.setColor(QColor('magenta')) #create the provider and add the layer pr = v_layer.dataProvider() QgsMapLayerRegistry.instance().addMapLayers([v_layer]) seg = QgsFeature() iterations=len(self.tool.polygon) #draw the lines between the buttons in order for i in range (iterations): if i== iterations-1: seg.setGeometry(QgsGeometry.fromPolyline([self.tool.polygon[i], self.tool.polygon[0]])) else: seg.setGeometry(QgsGeometry.fromPolyline([self.tool.polygon[i], self.tool.polygon[i+1]])) #add the lines to the provider and update the layer pr.addFeatures( [ seg ] ) v_layer.updateExtents() v_layer.triggerRepaint() #add the points to the QlistWidget for i in range (len(self.tool.polygon)): self.addItem(i)
def load_vector_layer(path, name, color=(0, 0, 0)): """Carga una capa vectorizada. :param path: Ruta de la capa que se va a cargar. :type path: str :param name: Nombre de la capa que se va a cargar, este nombre será el identificador de la capa. :param color: Color que se la va a asignar a la capa :type color: Tupla de 3 elementos r, g, b :returns: Capa vectorizada en caso de que sea valida, de lo contrario se retorna None :rtype: QgsVectorLayer """ layer = QgsVectorLayer(path, name, 'ogr') if not layer.isValid(): return None # Cambiar el color del layer r, g, b = color symbol_layer = layer.rendererV2().symbols()[0].symbolLayer(0) symbol_layer.setColor(QColor(r, g, b)) return layer
def createLayerControle(proj): layerStopLine = QgsVectorLayer("Point?crs=" + proj, CONST_NOM_LAYER_PT_CONTROLE, "memory") # Style # Symbologie des stations symbolPoint = QgsMarkerSymbolV2.createSimple({ 'name': 'square', 'color_border': '255,216,0' }) symbolPoint.setColor(QColor.fromRgb(255, 216, 0)) #F 216,7,96 symbolPoint.setSize(2) layerStopLine.rendererV2().setSymbol(symbolPoint) return layerStopLine
def __init__(self, ui): super(RiskTabPresenter, self).__init__(ui) # Load layers shape_files = [ os.path.join(BG_LAYER_PATH, shp_file) for shp_file in BG_LAYER_FILES ] layers = [] for shp_file, color in zip(shape_files, LAYER_COLORS): self.logger.info('Loading {}'.format(shp_file)) path = os.path.abspath(os.path.join(shp_file)) layer = QgsVectorLayer(path, 'shp_file', 'ogr') if not layer.isValid(): self.logger.info('Layer at {} failed to load!'.format(path)) else: symbols = layer.rendererV2().symbols() symbol = symbols[0] symbol.setColor(color) layers.append(layer) QgsMapLayerRegistry.instance().addMapLayer(layer) # Commented out for testing without QGIS initialization #self.loss_layer = RamsisLossPoeLayer('Loss') #layers.append(self.loss_layer) # Set layers canvas_layers = [QgsMapCanvasLayer(l) for l in layers] self.ui.mapWidget.setExtent(QgsRectangle(5.6, 45.6, 10.8, 47.5)) self.ui.mapWidget.setLayerSet(canvas_layers)
def geraMapaBacia(self, cotrecho, cobacia, dist, id_trecho): # seleciona a tabela area_contrib_eq - coluna geomproj self.uri.setDataSource('public', 'area_contrib', 'geomproj') # gera o string sql string_sql = '"cotrecho" IN (SELECT * FROM tr_md(\'' + cobacia + '\', ' + '{0:f}'.format(dist) + '))' self.uri.setSql(string_sql) #gera o titulo do mapa titulo = 'Area a montante de ' + str(cotrecho) #gera o mapa e acrescenta ao projeto mapa = QgsVectorLayer(self.uri.uri(), titulo, 'postgres') if not mapa.isValid(): raise ErroMapaInvalido QgsMapLayerRegistry.instance().addMapLayer(mapa) # faz com que a cor das bordas das areas de contribuicao seja a do interior e refresca o mapa propriedades = mapa.rendererV2().symbol().symbolLayers()[0].properties() propriedades['outline_color'] = propriedades['color'] mapa.rendererV2().setSymbol(QgsFillSymbolV2.createSimple(propriedades))
def geraMapaBacia(self, cotrecho, cobacia, dist, id_trecho): # seleciona a tabela area_contrib_eq - coluna geomproj self.uri.setDataSource('public', 'area_contrib', 'geomproj') # gera o string sql string_sql = '"cotrecho" IN (SELECT * FROM tr_md(\'' + cobacia + '\', ' + '{0:f}'.format( dist) + '))' self.uri.setSql(string_sql) #gera o titulo do mapa titulo = 'Area a montante de ' + str(cotrecho) #gera o mapa e acrescenta ao projeto mapa = QgsVectorLayer(self.uri.uri(), titulo, 'postgres') if not mapa.isValid(): raise ErroMapaInvalido QgsMapLayerRegistry.instance().addMapLayer(mapa) # faz com que a cor das bordas das areas de contribuicao seja a do interior e refresca o mapa propriedades = mapa.rendererV2().symbol().symbolLayers()[0].properties( ) propriedades['outline_color'] = propriedades['color'] mapa.rendererV2().setSymbol(QgsFillSymbolV2.createSimple(propriedades))
def create_qlayer(self): qlayer=QgsVectorLayer("LineString"+self.crs,self.prefix+"-edges","memory") pr = qlayer.dataProvider() # add fields - eventually would be tied in with g.edge_dtype e_attrs=[QgsField("edge_id",QVariant.Int)] for fidx,fdesc in enumerate(self.grid.edge_dtype.descr): # descr gives string reprs of the types, use dtype # to get back to an object. fname=fdesc[0] ; ftype=np.dtype(fdesc[1]) if len(fdesc)>2: fshape=fdesc[2] else: fshape=None if fname=='nodes': continue elif fname=='cells': e_attrs += [QgsField("c0", QVariant.Int), QgsField("c1", QVariant.Int)] else: if np.issubdtype(ftype,np.int): e_attrs.append( QgsField(fname,QVariant.Int) ) elif np.issubdtype(ftype,np.float): e_attrs.append( QgsField(fname,QVariant.Double) ) else: self.log.info("Not ready for other datatypes") self.e_attrs=e_attrs # violates functional nature ... pr.addAttributes(e_attrs) qlayer.updateFields() # tell the vector layer to fetch changes from the provider # clean, thin black style symbol = QgsLineSymbolV2.createSimple({'line_style':'solid', 'line_width':'0.2', 'line_width_unit':'MM', 'line_color': 'black'}) qlayer.rendererV2().setSymbol(symbol) return qlayer
def show_clicked_point(point, name, iface, vl=None): """ Displays the extent from the listeOfPoints Keyword arguments: listPoints -- list of point to draw the extent name -- name of the layer to display the extent name_extent indexGroupProduct -- index of the product group in qgis where to move the layers """ # set True to set a define color to the extent and the world setColor = False # create layer # if vl == None : vl = QgsVectorLayer("Point?crs=epsg:4326", name, "memory") pr = vl.data_provider() # add fields pr.addAttributes([QgsField("spectral_angle", QVariant.String)]) # add a feature fet = QgsFeature() geometry = QgsGeometry.fromPoint(point) # fet.setGeometry( qgis.core.QgsGeometry.fromPolygon( qgis.core.QgsGeometry.\ # QgsPolygon(4.45 43.95, 4.45 44.400433068, 5.000403625 44.400433068,5.000403625 43.95) ) ) fet.setGeometry(geometry) # ( 4.45, 43.95 ) to (5.000403625, 44.400433068 ) pr.addFeatures([fet]) # set color to the extent if setColor: if vl.isUsingRendererV2(): # new symbology - subclass of qgis.core.QgsFeatureRendererV2 class rendererV2 = vl.rendererV2() symbol = rendererV2.symbol() for i in xrange(symbol.symbolLayerCount()): symbol.symbolLayer(i).setColor(QColor(168, 255, 0)) # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer vl.updateExtents() QgsMapLayerRegistry.instance().addMapLayers([vl]) return vl
def addVectorLayer(self, path, name): """Agrega una capa vectorizada a self.layers :param path: Ruta de la capa que se va a cargar. :type path: str :param name: Nombre de la capa que se va a cargar, este nombre será el identificador de la capa. :type name: str """ layer = QgsVectorLayer(path, name, 'ogr') if not layer.isValid(): return # Cambiar el color del layer symbol_layer = layer.rendererV2().symbols()[0].symbolLayer(0) if name == 'ejes' or name == 'secciones': symbol_layer.setColor(QColor(0, 0, 0)) else: symbol_layer.setColor(QColor(randint(0, 50), randint(0, 255), 163)) self.layers.append(layer)
def envelope2layer(self, envelope): """Transform metadata envelope into a QGIS layer.""" # layer md_lyr = QgsVectorLayer("Polygon?crs=epsg:4326", "Metadata envelope", "memory") md_lyr.setLayerTransparency(75) symbols = md_lyr.rendererV2().symbols() symbol = symbols[0] symbol.setColor(QColor.fromRgb(255,20,147)) if envelope.get("type") == "Polygon": # parse coordinates coords = envelope.get("coordinates")[0] poly_pts = [QgsPoint(round(i[0], 3), round(i[1], 3)) for i in coords] # add geometry to layer poly = QgsFeature() poly.setGeometry(QgsGeometry.fromPolygon([poly_pts])) md_lyr.dataProvider().addFeatures([poly]) md_lyr.updateExtents() elif envelope.get("type") == "MultiPolygon": coords = envelope.get("bbox") bbox = QgsRectangle(round(coords[0], 3), round(coords[1], 3), round(coords[2], 3), round(coords[3], 3),) poly = QgsFeature() poly.setGeometry(QgsGeometry.fromWkt(bbox.asWktPolygon())) md_lyr.dataProvider().addFeatures([poly]) md_lyr.updateExtents() elif envelope.get("type") == "Point": return md_lyr else: pass # method ending return md_lyr
def addLayer(self): layerPath = QFileDialog.getOpenFileName(self, u'Abrir shapefile', '.', 'Shapefiles (*.shp)') layerInfo = QFileInfo(layerPath) layerProvider = 'ogr' # name = '/home/cbdavide/Documentos/Projects/shape-viewer/Colombia/Colombia.shp' # layer = QgsVectorLayer(name, 'ejje', layerProvider) layer = QgsVectorLayer(layerPath, layerInfo.fileName(), layerProvider) if not layer.isValid(): return # Cambiar el color del layer symbol_layer = layer.rendererV2().symbols()[0].symbolLayer(0) symbol_layer.setColor(QColor(176, 251, 163)) QgsMapLayerRegistry.instance().addMapLayer(layer) if self.canvas.layerCount() == 0: self.canvas.setExtent(layer.extent()) self.layers.insert(0, QgsMapCanvasLayer(layer)) self.canvas.setLayerSet(self.layers)
class FlyingTrackerDialog(QtGui.QDockWidget, FORM_CLASS): def __init__(self, iface, parent=None): """Constructor.""" super(FlyingTrackerDialog, self).__init__(parent) self.setupUi(self) self.iface = iface self.course_comboBox.clear() self.lcdNumberWpt.display(1) self.GpsFixlcdNumber.display(0) self.SatelliteslcdNumber.display(0) self.pushButtonDisconnect.hide() self.pushButtonConnect.clicked.connect(self.Connect) self.pushButtonDisconnect.clicked.connect(self.Disconnect) self.pushCloseButton.clicked.connect(self.Close) self.LoadtoolButton.clicked.connect(self.FillComboBox) self.wptplus_toolButton.clicked.connect(self.NextWpt) self.wptmin_toolButton.clicked.connect(self.BackWpt) QtCore.QObject.connect(self.wptplus_toolButton, QtCore.SIGNAL("valueChanged(int)"), self.AdjNxtWpt) QtCore.QObject.connect(self.wptmin_toolButton, QtCore.SIGNAL("valueChanged(int)"), self.AdjNxtWpt) self.ZoomIntoolButton.clicked.connect(self.ZoomIn) self.ZoomOuttoolButton.clicked.connect(self.ZoomOut) shortcut = QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_S), self.iface.mainWindow()) shortcut.setContext(QtCore.Qt.ApplicationShortcut) shortcut.activated.connect(self.ZoomIn) shortcut2 = QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_A), self.iface.mainWindow()) shortcut2.setContext(QtCore.Qt.ApplicationShortcut) shortcut2.activated.connect(self.ZoomOut) shortcut3 = QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_X), self.iface.mainWindow()) shortcut3.setContext(QtCore.Qt.ApplicationShortcut) shortcut3.activated.connect(self.NextWpt) shortcut4 = QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_Z), self.iface.mainWindow()) shortcut4.setContext(QtCore.Qt.ApplicationShortcut) shortcut4.activated.connect(self.BackWpt) self.timer = QtCore.QTimer() QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"), self.SendSerial) self.NxtWptRubber = False self.PositionMarker = False self.RubberBand = False self.WptVertexSignal = False self.trackCounter = 4 def AdjNxtWpt(self): if self.WptVertexSignal == True: self.iface.mapCanvas().scene().removeItem(self.WptVertex) del self.WptVertex self.WptVertexSignal = False if self.NxtWptRubber == True: self.iface.mapCanvas().scene().removeItem(self.rdue) del self.rdue self.iface.mapCanvas().scene().removeItem(self.rtre) del self.rtre self.NxtWptRubber = False canvas = self.iface.mapCanvas() mapRenderer = canvas.mapRenderer() crsSrc = QgsCoordinateReferenceSystem(4326) # NMEA is in WGS 84 crsDest = mapRenderer.destinationCrs() xform = QgsCoordinateTransform(crsSrc, crsDest) WptValue = int(self.lcdNumberWpt.value()) try: Wpt = self.pts[WptValue - 1] except IndexError: return self.WptVertex = QgsVertexMarker(self.iface.mapCanvas()) self.WptVertex.setIconSize(20) self.WptVertex.setIconType(QgsVertexMarker.ICON_X) self.WptVertex.setPenWidth(20) self.WptVertex.setCenter(xform.transform(Wpt)) self.WptVertexSignal = True if WptValue != 1: Wpt2 = self.pts[WptValue - 2] self.rdue = QgsRubberBand(self.iface.mapCanvas(), False) # False = not a polygon pointsdue = [xform.transform(Wpt), xform.transform(Wpt2)] self.rdue.setColor(QtGui.QColor(255, 0, 0)) self.rdue.setWidth(8) self.rdue.setLineStyle(QtCore.Qt.PenStyle(QtCore.Qt.DotLine)) self.rdue.setToGeometry(QgsGeometry.fromPolyline(pointsdue), None) #creation of NextWayPoint rubberband self.rtre = QgsRubberBand(self.iface.mapCanvas(), False) pointstre = self.pts[0:WptValue - 1] for i in xrange(len(pointstre)): pointstre[i] = xform.transform(pointstre[i]) self.rtre.setColor(QtGui.QColor(127, 0, 255)) self.rtre.setWidth(8) self.rtre.setLineStyle(QtCore.Qt.PenStyle(QtCore.Qt.DotLine)) self.rtre.setToGeometry(QgsGeometry.fromPolyline(pointstre), None) self.NxtWptRubber = True def Connect(self): try: self.positionMarker = PositionMarker(self.iface.mapCanvas()) self.PositionMarker = True portName = self.comboBox.currentText() self.ser = serial.Serial(portName, 38400) layername = self.course_comboBox.itemData( self.course_comboBox.currentIndex()) RouteLayer = QgsMapLayerRegistry.instance().mapLayer(layername) RouteLayer.selectAll() feats = RouteLayer.selectedFeatures() RouteLayer.removeSelection() feat = feats[0] geom = feat.geometry() self.pts = geom.asPolyline() SourceIntCRS = int(RouteLayer.crs().authid().split(':')[1]) if SourceIntCRS != 4326: SourceIntCRS = int(RouteLayer.crs().authid().split(':')[1]) SourceCRS = QgsCoordinateReferenceSystem(SourceIntCRS) DestCRS = QgsCoordinateReferenceSystem(4326) xformRouteLayer = QgsCoordinateTransform(SourceCRS, DestCRS) for i in xrange(len(self.pts)): x = self.pts[i][0] y = self.pts[i][ 1] #if track layer is not in WGS84 Geographic every coordinate is transformed TmpPoint = QgsPoint(x, y) Tmp2Point = xformRouteLayer.transform(TmpPoint) self.pts[i] = Tmp2Point self.TrackLayer = QgsVectorLayer("Point?crs=epsg:4326&index=yes", "Flight_track", "memory") self.TrackLayerProvider = self.TrackLayer.dataProvider() self.TrackLayerProvider.addAttributes([ QgsField("id", QtCore.QVariant.Int), QgsField('Time', QtCore.QVariant.String), QgsField('Ele', QtCore.QVariant.String), ]) QgsMapLayerRegistry.instance().addMapLayer(self.TrackLayer) symbols = self.TrackLayer.rendererV2().symbols() symbol = symbols[0] symbol.setColor(QtGui.QColor(0, 255, 0)) self.iface.legendInterface().refreshLayerSymbology(self.TrackLayer) if self.lcdNumberWpt.value() == 0: self.lcdNumberWpt.display(1) elif self.lcdNumberWpt.value() > len(self.pts): self.lcdNumberWpt.display(1) self.InRouteTolerance = float( self.DTrack_spinBox.value() ) #if we are distant from route less than this value path become green, otherwise red self.CompassTolerance = self.DCompass_spinBox.value( ) #if compass to next wpt confront to actual compass diverge less than this value projection of direction become green, otherwise red self.WptArrivedTolerance = float( self.DWpt_spinBox.value() ) #if we pass near a wpt less than this value (in meters) the program will set the next wpt self.EleTolerance = float( self.DHeightspinBox.value() ) #if our elevation diverge from planned elevation more than this value our cursor will be red, otherwise green canvas = self.iface.mapCanvas() mapRenderer = canvas.mapRenderer() crsSrc = QgsCoordinateReferenceSystem(4326) # NMEA is in WGS 84 crsDest = mapRenderer.destinationCrs() self.backxform = QgsCoordinateTransform(crsDest, crsSrc) self.xform = QgsCoordinateTransform( crsSrc, crsDest) #usage: xform.transform(QgsPoint) self.AdjNxtWpt() self.timer.start(1000) except: pass def SendSerial(self): thread = Thread(target=self.ReadSerial) thread.start() thread.join() def Disconnect(self, serialPort): self.timer.stop() self.lcdNumberSpeed.display(0) self.lcdNumberCompass.display(0) try: self.iface.mapCanvas().scene().removeItem(self.WptVertex) self.ser.close() self.iface.mapCanvas().scene().removeItem(self.r) self.iface.mapCanvas().scene().removeItem(self.runo) self.iface.mapCanvas().scene().removeItem(self.positionMarker) del self.WptVertex del self.r del self.runo except: pass self.iface.mapCanvas().setRotation(0) self.RubberBand = False if self.NxtWptRubber == True: self.iface.mapCanvas().scene().removeItem(self.rdue) self.iface.mapCanvas().scene().removeItem(self.rtre) del self.rdue del self.rtre self.NxtWptRubber = False else: pass self.WptVertexSignal = False self.lcdNumberHeights.display(0) self.lcdNumberSpeed.display(0) self.lcdNumberCompass.display(0) self.lcdCompassWpt.display(0) self.GpsFixlcdNumber.display(0) self.SatelliteslcdNumber.display(0) def FillComboBox(self): try: self.comboBox.clear() portlist = [] system_name = platform.system() if system_name == "Windows": # Scan for available ports. available = [] for i in range(256): try: s = serial.Serial(i) available.append(i) s.close() except serial.SerialException: #Search for active serial port pass #print available list1 = available elif system_name == "Darwin": # Mac #print glob.glob('/dev/tty*') + glob.glob('/dev/cu*') list1 = glob.glob('/dev/tty*') + glob.glob('/dev/cu*') else: # Assume Linux or something else #print glob.glob('/dev/ttyS*') + glob.glob('/dev/ttyUSB*') list1 = glob.glob('/dev/ttyS*') + glob.glob('/dev/ttyUSB*') for i in list1: try: serial.Serial(i).close() portlist.append(i) except IOError: pass for x in portlist: self.comboBox.addItem(x) self.course_comboBox.clear() LayerRegistryItem = QgsMapLayerRegistry.instance().mapLayers() for id, layer in LayerRegistryItem.iteritems(): if layer.type() == QgsMapLayer.VectorLayer: self.course_comboBox.addItem(layer.name(), id) layername = self.course_comboBox.itemData( self.course_comboBox.currentIndex()) RouteLayer = QgsMapLayerRegistry.instance().mapLayer(layername) RouteLayer.selectAll() RouteLayer.featureCount() feats = RouteLayer.selectedFeatures() RouteLayer.removeSelection() feat = feats[0] geom = feat.geometry() self.pts = geom.asPolyline() SourceIntCRS = int(RouteLayer.crs().authid().split(':')[1]) if SourceIntCRS != 4326: SourceIntCRS = int(RouteLayer.crs().authid().split(':')[1]) SourceCRS = QgsCoordinateReferenceSystem(SourceIntCRS) DestCRS = QgsCoordinateReferenceSystem(4326) xformRouteLayer = QgsCoordinateTransform(SourceCRS, DestCRS) for i in xrange(len(self.pts)): x = self.pts[i][0] y = self.pts[i][ 1] #if track layer is not in WGS84 Geographic every coordinate is transformed TmpPoint = QgsPoint(x, y) Tmp2Point = xformRouteLayer.transform(TmpPoint) self.pts[i] = Tmp2Point self.AdjNxtWpt() except: pass def Close(self): self.timer.stop() self.lcdNumberHeights.display(0) self.lcdNumberSpeed.display(0) self.lcdNumberCompass.display(0) self.lcdCompassWpt.display(0) self.course_comboBox.clear() if self.PositionMarker == True: self.iface.mapCanvas().scene().removeItem(self.positionMarker) if self.NxtWptRubber == True: self.iface.mapCanvas().scene().removeItem(self.rdue) self.iface.mapCanvas().scene().removeItem(self.rtre) del self.rdue del self.rtre self.NxtWptRubber = False else: pass if self.WptVertexSignal == True: self.iface.mapCanvas().scene().removeItem(self.WptVertex) del self.WptVertex self.WptVertexSignal = False self.close() def ZoomIn(self): self.iface.mapCanvas().zoomIn() def ZoomOut(self): self.iface.mapCanvas().zoomOut() def NextWpt(self): try: currentValue = self.lcdNumberWpt.value() if currentValue == len(self.pts): pass else: self.lcdNumberWpt.display(currentValue + 1) self.AdjNxtWpt() except: pass def BackWpt(self): try: currentValue = self.lcdNumberWpt.value() if currentValue >= 2: self.lcdNumberWpt.display(currentValue - 1) self.AdjNxtWpt() except: pass def ReadSerial(self): if self.trackCounter > 5: self.trackCounter = 4 self.trackCounter = self.trackCounter + 1 # when it arrive to 5 a gps point is painted (default is 4) GPGGA = 0 GPVTG = 0 data = self.ser.read(1) n = self.ser.inWaiting() if n: data = data + self.ser.read(n) if re.search("\r\n", data): # Since we found a CRLF, split it out data2 = data.split("\r\n") for i in range(len(data2)): if data2[i][0:6] == '$GPGGA': GPGGA = data2[i].split(',') #print GPGGA elif data2[i][0:6] == '$GPVTG': GPVTG = data2[i].split(',') #print GPRMC if GPGGA == 0: #print 'mancato' return elif GPVTG == 0: #print 'mancato' return else: decimalsLat = (float(GPGGA[2][2:])) / 60 degreeLat = float(GPGGA[2][0:2]) decimalsLon = (float(GPGGA[4][3:])) / 60 degreeLon = float(GPGGA[4][0:3]) Lat = degreeLat + decimalsLat Lon = degreeLon + decimalsLon if GPGGA[5] == 'W': Lon = -Lon if GPGGA[3] == 'S': Lat = -Lat Ele = float(GPGGA[9]) Compass = float(GPVTG[1]) Speed = (float(GPVTG[7])) # in Km/h GpsFix = int(GPGGA[6]) GpsSatellites = int(GPGGA[7]) self.ser.flushInput() self.ser.flushOutput() self.GpsFixlcdNumber.display(GpsFix) self.SatelliteslcdNumber.display(GpsSatellites) if self.RubberBand == True: self.iface.mapCanvas().scene().removeItem(self.r) del self.r self.RubberBand = False Point = QgsPoint() Point.set(Lon, Lat) TransfPoint = self.xform.transform(Point) canvas = self.iface.mapCanvas() if Compass <= 180: #canvas.setRotation(-(Compass-self.rotation)) canvas.setRotation( -Compass ) # set canvas rotation according to: UP of the map = Compass Direction else: Compass = 360 - Compass canvas.setRotation(Compass) canvas.setCenter(TransfPoint) self.positionMarker.newCoords( TransfPoint) # Put the arrow on screen #self.positionMarker.angle = 0.0 WptValue = int(self.lcdNumberWpt.value()) WptE = self.pts[WptValue - 1][0] WptN = self.pts[WptValue - 1][1] GeodesicAircraftToWpt = Geodesic.WGS84.Inverse( Lat, Lon, WptN, WptE) distance = GeodesicAircraftToWpt['s12'] azim = GeodesicAircraftToWpt[ 'azi1'] #determine azimuth from next wpt if azim < 0: azim += 360 if distance <= self.WptArrivedTolerance: # tolerance in meter for next wpt self.NextWpt() #feetEle = Ele * 3.2808399 #meters to feet if self.comboBox_2.currentText() == 'ft.': feetEle = Ele * 3.2808399 #Convert if needed self.lcdNumberHeights.display(feetEle) else: self.lcdNumberHeights.display(Ele) if self.comboBox_3.currentText() != 'km/h': Speed = Speed * 0.53995694 #Convert if needed self.lcdNumberSpeed.display(float(Speed)) else: self.lcdNumberSpeed.display(float(Speed)) self.lcdNumberCompass.display(float(Compass)) self.lcdCompassWpt.display(azim) canvasInPixel = canvas.getCoordinateTransform() ExtentHeightInPixel = canvasInPixel.mapHeight() ExtentWidthInPixel = canvasInPixel.mapWidth() LocateCompassProjectionEndInMapUnit = canvasInPixel.toMapPoint( ExtentWidthInPixel / 2.0, ExtentHeightInPixel - (ExtentHeightInPixel * 0.95)) self.r = QgsRubberBand(self.iface.mapCanvas(), False) # False = not a polygon #points = [TransfPoint, QgsPoint(x,y)] #creazione della proiezione della prua su mappa points = [TransfPoint, LocateCompassProjectionEndInMapUnit] self.r.setWidth(8) self.r.setToGeometry(QgsGeometry.fromPolyline(points), None) if abs(Compass - azim) <= self.CompassTolerance: #Compass tolerance self.r.setColor(QtGui.QColor(0, 255, 0)) else: self.r.setColor(QtGui.QColor(255, 0, 0)) self.RubberBand = True try: self.iface.mapCanvas().scene().removeItem( self.runo) # remove track for first waypoint except: pass if WptValue != 1: #DistanceFromLineTolerance = 100 #meter set distance from route BackwardLat = self.rdue.asGeometry().asPolyline()[1][ 1] #start to design a QgsRectangle buffer around current route to confront to Point BackwardLon = self.rdue.asGeometry().asPolyline()[1][0] BackwardPoint = QgsPoint(BackwardLon, BackwardLat) BackwardPointTransformed = self.backxform.transform( BackwardPoint) GeodesicWptWpt = Geodesic.WGS84.Inverse( BackwardPointTransformed.y(), BackwardPointTransformed.x(), WptN, WptE) #GeodesicWptWpt = Geodesic.WGS84.Inverse(BackwardLat, BackwardLon, WptN, WptE) WptWptCompass = GeodesicWptWpt['azi1'] if WptWptCompass < 0: WptWptCompass += 360 #print WptWptCompass WptWptCompassRight = WptWptCompass + 90 if WptWptCompassRight > 360: WptWptCompassRight = WptWptCompassRight - 360 #print WptWptCompassRight WptWptCompassLeft = WptWptCompass - 90 if WptWptCompassLeft < 0: WptWptCompassLeft += 360 #print WptWptCompassLeft origin = geopy.Point(WptN, WptE) URBufferVertex = vincenty( meters=self.InRouteTolerance).destination( origin, WptWptCompassRight) URBufferVertexPoint = QgsPoint(URBufferVertex.longitude, URBufferVertex.latitude) ULBufferVertex = vincenty( meters=self.InRouteTolerance).destination( origin, WptWptCompassLeft) ULBufferVertexPoint = QgsPoint(ULBufferVertex.longitude, ULBufferVertex.latitude) del origin origin = geopy.Point(BackwardPointTransformed.y(), BackwardPointTransformed.x()) DRBufferVertex = vincenty( meters=self.InRouteTolerance).destination( origin, WptWptCompassRight) DRBufferVertexPoint = QgsPoint(DRBufferVertex.longitude, DRBufferVertex.latitude) DLBufferVertex = vincenty( meters=self.InRouteTolerance).destination( origin, WptWptCompassLeft) DLBufferVertexPoint = QgsPoint(DLBufferVertex.longitude, DLBufferVertex.latitude) del origin gPolygon = QgsGeometry.fromPolygon([[ URBufferVertexPoint, ULBufferVertexPoint, DLBufferVertexPoint, DRBufferVertexPoint ]]) if not gPolygon.contains(Point): self.rdue.setColor(QtGui.QColor(255, 0, 0)) #print 'noncontiene' else: self.rdue.setColor(QtGui.QColor(0, 255, 0)) #print 'contiene' else: self.runo = QgsRubberBand(self.iface.mapCanvas(), False) points = [TransfPoint, self.xform.transform(self.pts[0]) ] # draw track for first waypoint self.runo.setColor(QtGui.QColor(255, 0, 0)) self.runo.setWidth(6) self.runo.setLineStyle( QtCore.Qt.PenStyle(QtCore.Qt.DotLine)) self.runo.setToGeometry(QgsGeometry.fromPolyline(points), None) #if abs(float((self.fixedHeightspinBox.value()/ 3.2808399)) - (feetEle/ 3.2808399)) <= self.EleTolerance: #ele tolerance expressed in meters if abs(self.fixedHeightspinBox.value() - Ele) <= self.EleTolerance: self.positionMarker.setHasPosition( True) #True or False to change color else: self.positionMarker.setHasPosition(False) if self.trackCounter == 5: #pass fc = int(self.TrackLayerProvider.featureCount()) time = str(GPGGA[1])[0:2] + ':' + str( GPGGA[1])[2:4] + ':' + str( GPGGA[1])[4:6] # timestamp for GPX layer feature = QgsFeature() feature.setGeometry(QgsGeometry.fromPoint(Point)) feature.setAttributes([fc, time, Ele]) self.TrackLayer.startEditing() self.TrackLayer.addFeature(feature, True) self.TrackLayer.commitChanges() self.TrackLayer.setCacheImage(None) self.TrackLayer.triggerRepaint() self.trackCounter = 0 return
class TestQgsArrowSymbolLayer(unittest.TestCase): def setUp(self): self.iface = get_iface() lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp') self.lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(self.lines_layer) # Create style sym2 = QgsLineSymbolV2.createSimple({'color': '#fdbf6f'}) self.lines_layer.setRendererV2(QgsSingleSymbolRendererV2(sym2)) self.mapsettings = self.iface.mapCanvas().mapSettings() self.mapsettings.setOutputSize(QSize(400, 400)) self.mapsettings.setOutputDpi(96) self.mapsettings.setExtent(QgsRectangle(-113, 28, -91, 40)) self.mapsettings.setBackgroundColor(QColor("white")) def tearDown(self): QgsMapLayerRegistry.instance().removeAllMapLayers() def test_1(self): sym = self.lines_layer.rendererV2().symbol() sym_layer = QgsArrowSymbolLayer.create({'head_length': '6.5', 'head_thickness': '6.5'}) dd = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("arrow_width", dd) dd2 = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("head_length", dd2) dd3 = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("head_thickness", dd3) fill_sym = QgsFillSymbolV2.createSimple({'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1'}) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_arrowsymbollayer_1') self.assertTrue(renderchecker.runTest('arrowsymbollayer_1')) def test_2(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({'arrow_width': '5', 'head_length': '4', 'head_thickness': '6', 'head_type': '2'}) fill_sym = QgsFillSymbolV2.createSimple({'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1'}) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_arrowsymbollayer_2') self.assertTrue(renderchecker.runTest('arrowsymbollayer_2')) def test_3(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({'arrow_width': '7', 'head_length': '6', 'head_thickness': '8', 'head_type': '0', 'arrow_type': '1', 'is_curved': '0'}) fill_sym = QgsFillSymbolV2.createSimple({'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1'}) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() ms = self.mapsettings ms.setExtent(QgsRectangle(-101, 35, -99, 37)) renderchecker.setMapSettings(ms) renderchecker.setControlName('expected_arrowsymbollayer_3') self.assertTrue(renderchecker.runTest('arrowsymbollayer_3')) def test_unrepeated(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({'arrow_width': '7', 'head_length': '6', 'head_thickness': '8', 'head_type': '0', 'arrow_type': '0'}) # no repetition sym_layer.setIsRepeated(False) fill_sym = QgsFillSymbolV2.createSimple({'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1'}) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() ms = self.mapsettings ms.setExtent(QgsRectangle(-119, 17, -82, 50)) renderchecker.setMapSettings(ms) renderchecker.setControlName('expected_arrowsymbollayer_4') self.assertTrue(renderchecker.runTest('arrowsymbollayer_4')) def testColors(self): """ Test colors, need to make sure colors are passed/retrieved from subsymbol """ sym_layer = QgsArrowSymbolLayer.create() sym_layer.setColor(QColor(150, 50, 100)) self.assertEqual(sym_layer.color(), QColor(150, 50, 100)) self.assertEqual(sym_layer.subSymbol().color(), QColor(150, 50, 100)) sym_layer.subSymbol().setColor(QColor(250, 150, 200)) self.assertEqual(sym_layer.subSymbol().color(), QColor(250, 150, 200)) self.assertEqual(sym_layer.color(), QColor(250, 150, 200))
def plugin_code_by_anshul_iitb(trip_number): trip_number = trip_number.upper() import pandas import psycopg2 import pandas.io.sql as psql QgsMessageLog.logMessage(trip_number) try: conn = psycopg2.connect( "dbname='MTP_transportation' user='******' host='localhost' password='******'" ) print "DB connected" except Exception as e: QMessageBox.information(None, "Error", "Database not connected") return print(e) try: cur = conn.cursor() sql = 'DROP TABLE IF EXISTS output;' cur.execute(sql) sql = """ CREATE TABLE output AS ( SELECT * FROM public.abc_july_final where trip_numbe = '""" + trip_number + "')" cur.execute(sql) conn.commit() cur.close() except Exception as e: print(e) #Removing all layer if any present QgsMapLayerRegistry.instance().removeAllMapLayers() #loading BaseLayer as OSM uri = "url=http://a.tile.openstreetmap.org/{z}/{x}/{y}.png&zmax=19&zmin=0&type=xyz" osm_layer = QgsRasterLayer(uri, 'OSM', 'wms') if not osm_layer.isValid(): print("Layer failed to load!") QgsMapLayerRegistry.instance().addMapLayer(osm_layer) print 'Finished' uri = QgsDataSourceURI() uri.setConnection("localhost", "5432", "MTP_transportation", "postgres", "anshuL@iitb") uri.setDataSource("public", "output", "geom") vlayer = QgsVectorLayer(uri.uri(False), 'output', "postgres") QgsMapLayerRegistry.instance().addMapLayer(vlayer) #setting the color of output layer named 'vlayer' vlayer.selectAll() iface.mapCanvas().setSelectionColor(QColor("blue")) iface.mapCanvas().zoomToSelected() print 'color changed' #setting line width of output layer named 'vlayer' symbols = vlayer.rendererV2().symbols() for symbol in symbols: symbol.setWidth(1) print 'Linewidth changed' # Refresh in order the see the changes iface.mapCanvas().refreshAllLayers() print 'Linewidth and color changed' # iface.zoomToActiveLayer() canvas = iface.mapCanvas() extent = vlayer.extent() canvas.setExtent(extent)
class WGS84Layer(object): "..." def __init__(self, iface, layer_name, layer_type, visible, group=None, show_count=True): "..." self.iface = iface self.layer_name = layer_name self.visible = visible self.layer = QgsVectorLayer(layer_type + "?crs=EPSG:4326", layer_name, "memory") self.provider = self.layer.dataProvider() self.layer = QgsMapLayerRegistry.instance().addMapLayer(self.layer) self.canvas = iface.mapCanvas() if group is not None: # move layer to group self.iface.legendInterface().moveLayer(self.layer, group) # collapse groups for child in QgsProject.instance().layerTreeRoot().children(): if isinstance(child, QgsLayerTreeGroup): child.setExpanded(False) if show_count: root = QgsProject.instance().layerTreeRoot() leaf = root.findLayer(self.layer.id()) leaf.setCustomProperty("showFeatureCount", True) def show(self, show_it): "..." legend = self.iface.legendInterface() legend.setLayerVisible(self.layer, show_it) def remove(self): "..." # It seems QGis does already delete the layers # Ensure that the layer is still in the registry before calling removeMapLayer if self.layer is not None and len( QgsMapLayerRegistry.instance().mapLayersByName( self.layer_name)) > 0: QgsMapLayerRegistry.instance().removeMapLayer(self.layer) self.layer = None def refresh(self): "..." if not self.canvas.isDrawing(): self.layer.setCacheImage(None) self.layer.triggerRepaint() self.canvas.refresh() def refresh_legend(self): "..." self.iface.legendInterface().refreshLayerSymbology(self.layer) self.iface.mapCanvas().refresh() def poly_marker(self, placement, qcolor, width): "..." marker = QgsMarkerLineSymbolLayerV2() marker.setColor(qcolor) marker.setPlacement(placement) marker.setWidth(width) self.layer.rendererV2().symbol().appendSymbolLayer(marker) def poly_markers(self, qcolor, width): "..." self.poly_marker(QgsMarkerLineSymbolLayerV2.Vertex, qcolor, width * 1.33) self.poly_marker(QgsMarkerLineSymbolLayerV2.FirstVertex, qcolor, width * 2.25) self.poly_marker(QgsMarkerLineSymbolLayerV2.LastVertex, qcolor, width * 2.25) def set_attributes(self, attributes): "..." self.provider.addAttributes(attributes) self.layer.updateFields() def add_feature(self, geometry, attributes): "..." added_feature = QgsFeature() added_feature.setGeometry(geometry) added_feature.setAttributes(attributes) success, feat = self.provider.addFeatures([added_feature]) if success: self.layer.updateExtents() return feat[0] return None def remove_feature(self, feature): "..." self.provider.deleteFeatures([feature.id()]) def remove_all_features(self): "..." for feature in self.layer.getFeatures(): self.remove_feature(feature) def enable_labeling(self, field, font="Arial", size=10, weight=50, rgb=(0, 0, 0), placement=1): "..." self.layer.setCustomProperty("labeling", "pal") self.layer.setCustomProperty("labeling/enabled", "true") self.layer.setCustomProperty("labeling/fontFamily", font) self.layer.setCustomProperty("labeling/fontSize", str(size)) self.layer.setCustomProperty("labeling/fontWeight", str(weight)) self.layer.setCustomProperty("labeling/textColorR", str(rgb[0])) self.layer.setCustomProperty("labeling/textColorG", str(rgb[1])) self.layer.setCustomProperty("labeling/textColorB", str(rgb[2])) self.layer.setCustomProperty("labeling/placement", str(placement)) self.layer.setCustomProperty("labeling/fieldName", field)
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 TestQgsArrowSymbolLayer(unittest.TestCase): def setUp(self): self.iface = get_iface() lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp') self.lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(self.lines_layer) # Create style sym2 = QgsLineSymbolV2.createSimple({'color': '#fdbf6f'}) self.lines_layer.setRendererV2(QgsSingleSymbolRendererV2(sym2)) self.mapsettings = self.iface.mapCanvas().mapSettings() self.mapsettings.setOutputSize(QSize(400, 400)) self.mapsettings.setOutputDpi(96) self.mapsettings.setExtent(QgsRectangle(-113, 28, -91, 40)) self.mapsettings.setBackgroundColor(QColor("white")) def tearDown(self): QgsMapLayerRegistry.instance().removeAllMapLayers() def test_1(self): sym = self.lines_layer.rendererV2().symbol() sym_layer = QgsArrowSymbolLayer.create({ 'head_length': '6.5', 'head_thickness': '6.5' }) dd = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("arrow_width", dd) dd2 = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("head_length", dd2) dd3 = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("head_thickness", dd3) fill_sym = QgsFillSymbolV2.createSimple({ 'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1' }) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_arrowsymbollayer_1') self.assertTrue(renderchecker.runTest('arrowsymbollayer_1')) def test_2(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({ 'arrow_width': '5', 'head_length': '4', 'head_thickness': '6', 'head_type': '2' }) fill_sym = QgsFillSymbolV2.createSimple({ 'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1' }) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_arrowsymbollayer_2') self.assertTrue(renderchecker.runTest('arrowsymbollayer_2')) def test_3(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({ 'arrow_width': '7', 'head_length': '6', 'head_thickness': '8', 'head_type': '0', 'arrow_type': '1', 'is_curved': '0' }) fill_sym = QgsFillSymbolV2.createSimple({ 'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1' }) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() ms = self.mapsettings ms.setExtent(QgsRectangle(-101, 35, -99, 37)) renderchecker.setMapSettings(ms) renderchecker.setControlName('expected_arrowsymbollayer_3') self.assertTrue(renderchecker.runTest('arrowsymbollayer_3')) def test_unrepeated(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({ 'arrow_width': '7', 'head_length': '6', 'head_thickness': '8', 'head_type': '0', 'arrow_type': '0' }) # no repetition sym_layer.setIsRepeated(False) fill_sym = QgsFillSymbolV2.createSimple({ 'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1' }) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() ms = self.mapsettings ms.setExtent(QgsRectangle(-119, 17, -82, 50)) renderchecker.setMapSettings(ms) renderchecker.setControlName('expected_arrowsymbollayer_4') self.assertTrue(renderchecker.runTest('arrowsymbollayer_4')) def testColors(self): """ Test colors, need to make sure colors are passed/retrieved from subsymbol """ sym_layer = QgsArrowSymbolLayer.create() sym_layer.setColor(QColor(150, 50, 100)) self.assertEqual(sym_layer.color(), QColor(150, 50, 100)) self.assertEqual(sym_layer.subSymbol().color(), QColor(150, 50, 100)) sym_layer.subSymbol().setColor(QColor(250, 150, 200)) self.assertEqual(sym_layer.subSymbol().color(), QColor(250, 150, 200)) self.assertEqual(sym_layer.color(), QColor(250, 150, 200))
def actuate(self,option,direction,onOff): # comprobate if the layers of each cow exist v_layer=None for lyr in QgsMapLayerRegistry.instance().mapLayers().values(): if option==1: if lyr.name() == "Vaca_1": v_layer = lyr break elif option==2: if lyr.name() == "Vaca_2": v_layer = lyr break elif option==3: if lyr.name() == "Vaca_3": v_layer = lyr break #create the layer with the name and the color if v_layer==None: if option==1: v_layer = QgsVectorLayer("Point", "Vaca_1", "memory") elif option==2: v_layer = QgsVectorLayer("Point", "Vaca_2", "memory") elif option==3: v_layer = QgsVectorLayer("Point", "Vaca_3", "memory") symbols =v_layer.rendererV2().symbols() symbol=symbols[0] if option==1: symbol.setColor(QColor('red')) elif option==2: symbol.setColor(QColor('yellow')) elif option==3: symbol.setColor(QColor('cyan')) # pr = v_layer.dataProvider() # QgsMapLayerRegistry.instance().addMapLayers([v_layer]) # seg = QgsFeature() url=direction+'/hola='+str(onOff) #perform the request using pycurl try: buf = cStringIO.StringIO() c = pycurl.Curl() c.setopt(pycurl.URL, url) c.setopt(pycurl.CONNECTTIMEOUT, 3) c.setopt(pycurl.TIMEOUT, 3) c.setopt(pycurl.WRITEFUNCTION, buf.write) c.perform() texto=buf.getvalue() buf.close() self.dlg.label_4.setText("Conexion correcta") print "OK" except: texto= "Latitud: 91.0000000 Longitud: 181.0000000" print "Connection error" self.dlg.label_4.setText("Conexion incorrecta") #xtract the coordinates from the obtanied message Latitud=(texto[texto.find("Latitud: ")+9:texto.find("Longitud: ")-1]) Longitud=(texto[texto.find("Longitud: ")+10:]) if onOff==0: self.draw_position(Latitud,Longitud,v_layer,option)
def plugin_code_by_anshul_iitb(BusStopFrom, BusStopTo, TimeFrom, TimeTo, Day): #QMessageBox.information(None,"Plugin function by Anshul the great","\nSource: "+ BusStopFrom+"\nDestination: "+ BusStopTo+ "\nTime: " +TimeFrom+" to "+ TimeTo+"\nDay"+ Day) import pandas import psycopg2 import pandas.io.sql as psql QgsMessageLog.logMessage( "\nUser_Input_Source-"+ BusStopFrom+\ "\nUser_Input_Destination-"+ BusStopTo+\ "\nUser_Input_From-"+ TimeFrom+\ "\nUser_Input_To-"+ TimeTo +\ "\nUser_Input_Day-"+ Day ) try: conn = psycopg2.connect( "dbname='MTP_transportation' user='******' host='localhost' password='******'" ) #QMessageBox.information(None,"Plugin stage process","DB connected") print "DB connected" except Exception as e: QMessageBox.information(None, "Error", "Database not connected") return print(e) #The mentioned below file contained the Nashik Bus stop Route Sequence with respective Route no.. This file has been derieved from Nashik All route Master file recieved RouteSequenceFile = psql.read_sql("SELECT * FROM route_seq", conn) #The mentioned below file contains Route no. to Trip No. Mapping. This file has been derieved by Sinnar August 2019 ETIM data with Following query "Select distinct Trip_no, Route_no from ETIM_File" RouteNoToTripNoFile = psql.read_sql('SELECT * FROM route_to_trip', conn) #ABC data of Sinner recieved of July month # ABCSinnarJul19File=pandas.read_csv('/home/anshulgoel031gmailcom/Desktop/MTP2/MTP/ABCJuly19_filtered.csv') ABCSinnarJul19File = psql.read_sql('SELECT * FROM ABCJuly19_filtered', conn) #This mentioned below file contains the Nashik Bus stop Route sequences Master file as recieved by Nashik depot # RouteSequenceMasterFile= pandas.read_csv('/home/anshulgoel031gmailcom/Desktop/MTP2/MTP/All_Routes_Stops_Master_of_Nashik_Division.csv') RouteSequenceMasterFile = psql.read_sql( 'SELECT * FROM All_Routes_Stops_Master_of_Nashik_Division', conn) #Closing the databse conn.close() #Converting Bus Stop code to upper case so that we can comapre with database values with considering case sensitivity BusStopFrom = BusStopFrom.upper() BusStopTo = BusStopTo.upper() #Assuming bus speed to be 30km/hour, We dont have Bus arrrival time and departure time on a particular bus stop, so based on route length and average speed expected time has been calculated Bus_speed = 30 def abc(BusStopFrom, BusStopTo, TimeFrom, TimeTo): #print (BusStopFrom) #print (BusStopTo) Required_Route_Sequence = [] Required_From_KM = [] for i in range(0, len(RouteSequenceFile)): if (RouteSequenceFile['Route_seq'][i].find(BusStopFrom) > -1 and RouteSequenceFile['Route_seq'][i].find(BusStopTo) > -1 and RouteSequenceFile['Route_seq'][i].find(BusStopFrom) < RouteSequenceFile['Route_seq'][i].find(BusStopTo)): Required_Route_Sequence.append( RouteSequenceFile['Route_no'][i]) # Required_From_KM.append(RouteSequenceFile['KM'][i]) print len(Required_Route_Sequence) print Required_Route_Sequence QMessageBox.information( None, "All Possible Routes", "Total No.of all possible routes are " + str(len(Required_Route_Sequence)) + '\n\n Routes are ' + str(Required_Route_Sequence)) return Required_Route_Sequence # In[4]: Required_Route_Sequence = abc(BusStopFrom, BusStopTo, TimeFrom, TimeTo) # In[5]: # This functions return a DataFrame which contains Trip Numbers and Respective Route Numbers which have routes NSKCBS to SNNR without considering time # This Functions required inputs a 'list' which contains all route no. having routes from NSKCBS to SNNR irrespective of time def Route_to_trip(Required_Route_Sequence): Required_Trips = [] Required_Routes = [] for i in range(0, len(Required_Route_Sequence)): for j in range(0, len(RouteNoToTripNoFile)): if (Required_Route_Sequence[i] == RouteNoToTripNoFile['Route_no'][j]): Required_Trips.append(RouteNoToTripNoFile['trip_no'][j]) Required_Routes.append(RouteNoToTripNoFile['Route_no'][j]) # This 'dict' variable contains Trip Numbers and Respective Route Numbers which have routes NSKCBS to SNNR dict = {'Trips': Required_Trips, 'Routes': Required_Routes} # print(len(Required_Trip_Sequence)) # Converting this Dict into DataFrame and returning via function df = pandas.DataFrame(dict) print(len(df)) print(df) QMessageBox.information( None, "All possible Trips", "Total number of all possible Trips are " + str(len(df['Trips'].tolist())) + "\n\nTrips are " + str([str(i) for i in df['Trips'].tolist()])) return df # return Required_Trip_Sequence # In[6]: # This Required_Trip_Route is the 'Dataframe' which contain Trip_no and Route_no having Bus Stops from NSKCBS to SNNR Required_Trip_Route = Route_to_trip(Required_Route_Sequence) # In[7]: # This function return the list containinf "trip no." under Sinnar jurisdiction in month Oct 19 which provide NSKCBS to SNNR irrespective of time #Input of the function are two Dataframe one contians ABC Analysis of Sinnar Taluka For month Oct 2019 #Second Dataframe contains all the (Trips, Route No.) pair under Nashik Jurisdiction which provide NSKCBS TO SNNR Service def ReturnABCTripsIrrespectiveTime(Required_Trip_Route, ABCSinnarJul19File): Trips = [] Routes = [] Trip_start_time = [] for i in Required_Trip_Route.index: for j in ABCSinnarJul19File.index: if (Required_Trip_Route['Trips'][i] == ABCSinnarJul19File['Trip'][j]): Trips.append(Required_Trip_Route['Trips'][i]) Routes.append(Required_Trip_Route['Routes'][i]) Trip_start_time.append(ABCSinnarJul19File['Dept Time'][j]) dict = { 'Trips': Trips, 'Routes': Routes, 'Trip Start Time': Trip_start_time } # for i in Trips: # for j in ABCSinnarJul19File.index: df = pandas.DataFrame(dict) # print len(df) # print df return df # In[8]: ABCTripsIrrespectiveTime = ReturnABCTripsIrrespectiveTime( Required_Trip_Route, ABCSinnarJul19File) print ABCTripsIrrespectiveTime # In[9]: list_Route_no = list( dict.fromkeys(ABCTripsIrrespectiveTime['Routes'].tolist())) print list_Route_no list_Route_KM = [] # for i in ABCTripsIrrespectiveTime.index: # for j in ABCSinnarJul19File.index: # if ABCTripsIrrespectiveTime['Trips'][i].upper()==ABCSinnarJul19File['Trip'][j].upper(): # for k in RouteSequenceMasterFile.index: # if ABCTripsIrrespectiveTime['Routes'][i]==RouteSequenceMasterFile['ROUTE_NO'][k] and RouteSequenceMasterFile['BUS_STOP_CD'][k]==BusStopFrom: # print RouteSequenceMasterFile['KM'][k] # break list_Route_KM2 = [] for i in list_Route_no: for j in RouteSequenceMasterFile.index: if i == RouteSequenceMasterFile['ROUTE_NO'][ j] and RouteSequenceMasterFile['BUS_STOP_CD'][ j] == BusStopFrom: print i, RouteSequenceMasterFile['KM'][j] list_Route_KM.append(RouteSequenceMasterFile['KM'][j]) # break if i == RouteSequenceMasterFile['ROUTE_NO'][ j] and RouteSequenceMasterFile['BUS_STOP_CD'][ j] == BusStopTo: print i, RouteSequenceMasterFile['KM'][j] list_Route_KM2.append(RouteSequenceMasterFile['KM'][j]) break # df_Final=pandas.DataFrame() print list_Route_KM list_km = [] list_km2 = [] for i in ABCTripsIrrespectiveTime['Routes'].tolist(): for j in list_Route_no: if i == j: # df_final=df_final.append({'Route no.':ABCTripsIrrespectiveTime['Routes'][i],'Trip Start time':ABCTripsIrrespectiveTime['Trip Start time '][i],'Trips':ABCTripsIrrespectiveTime['Trips'][i] }) list_km.append(list_Route_KM[list_Route_no.index(j)]) list_km2.append(list_Route_KM2[list_Route_no.index(j)]) print list_km ABCTripsIrrespectiveTime['Start KM'] = list_km ABCTripsIrrespectiveTime['End KM'] = list_km2 ABCTripsIrrespectiveTime['Expected Time in hour'] = ( ABCTripsIrrespectiveTime['End KM'] - ABCTripsIrrespectiveTime['Start KM']) / Bus_speed ABCTripsIrrespectiveTime.sort_values(by='Trip Start Time', ascending=True, inplace=True) ABCTripsIrrespectiveTime.reset_index(drop=True, inplace=True) print ABCTripsIrrespectiveTime # In[10]: #this function has been used to compare time def time_in_hour(t): return float(t.split(':')[0]) + float(t.split(':')[1]) / 60 list_Final_output_index = [] for i in ABCTripsIrrespectiveTime.index: # print i #converting time into hours and then comparing if time_in_hour(ABCTripsIrrespectiveTime['Trip Start Time'] [i]) >= time_in_hour(TimeFrom) and time_in_hour( ABCTripsIrrespectiveTime['Trip Start Time'] [i]) <= time_in_hour(TimeTo): list_Final_output_index.append(i) # In[11]: ABCTripsIrrespectiveTime.iloc[list_Final_output_index] # In[12]: l = ABCTripsIrrespectiveTime['Trips'][list_Final_output_index].tolist() l = str([str(r) for r in l]) l = '(' + l[1:len(l) - 1] + ')' print l ABCTripsIrrespectiveTime['Trips'][list_Final_output_index].tolist() # QMessageBox.information(None,"Final output","No. of Bus Trips are "+str(len(ABCTripsIrrespectiveTime['Trips'][list_Final_output_index].tolist()))+"\n Final Trips betweeen provided bus stops and Time are :"+ l[1:len(l)-1]) try: conn = psycopg2.connect( "dbname='MTP_transportation' user='******' host='localhost' password='******'" ) #QMessageBox.information(None,"Final output","DB connected") print "DB connected" except: QMessageBox.information(None, "Error", "Database not connected") print 'DB Not connected' str1 = '' for i in ABCTripsIrrespectiveTime['Trips'][list_Final_output_index].tolist( ): cur = conn.cursor() sql = "select distinct abc_status from abc_july_final where trip_numbe='" + i + "'" cur.execute(sql) temp = str(cur.fetchone()) str1 = str1 + i + ' , ' + temp[2:len(temp) - 1] + '\n' msg = QMessageBox() msg.setText("Final Number of Bus Trips are " + str( len(ABCTripsIrrespectiveTime['Trips'] [list_Final_output_index].tolist())) + "\n Final Trips betweeen provided bus stops and Time are :" + l[1:len(l) - 1]) msg.setInformativeText("ABC Details of trips") msg.setWindowTitle("Final Output") msg.setDetailedText("ABC details:\n" + str1) retval = msg.exec_() # In[13]: try: conn = psycopg2.connect( "dbname='MTP_transportation' user='******' host='localhost' password='******'" ) #QMessageBox.information(None,"Final output","DB connected") print "DB connected" except: QMessageBox.information(None, "Error", "Database not connected") print 'DB Not connected' try: cur = conn.cursor() sql = 'DROP TABLE IF EXISTS output;' cur.execute(sql) sql = """ CREATE TABLE output AS ( SELECT * FROM public.abc_july_final where trip_numbe in """ + l + ')' # Here variable 'l' above in the above SQL query is the list containing all the required bus trips to be displayed if len(ABCTripsIrrespectiveTime['Trips'] [list_Final_output_index].tolist()) != 0: cur.execute(sql) conn.commit() cur.close() except Exception as e: print(e) #Removing all layer if any present QgsMapLayerRegistry.instance().removeAllMapLayers() #loading BaseLayer as OSM uri = "url=http://a.tile.openstreetmap.org/{z}/{x}/{y}.png&zmax=19&zmin=0&type=xyz" osm_layer = QgsRasterLayer(uri, 'OSM', 'wms') if not osm_layer.isValid(): print("Layer failed to load!") QgsMapLayerRegistry.instance().addMapLayer(osm_layer) print 'Finished' #if len(ABCTripsIrrespectiveTime['Trips'][list_Final_output_index].tolist())!=0: uri = QgsDataSourceURI() uri.setConnection("localhost", "5432", "MTP_transportation", "postgres", "anshuL@iitb") uri.setDataSource("public", "output", "geom") vlayer = QgsVectorLayer(uri.uri(False), 'output', "postgres") QgsMapLayerRegistry.instance().addMapLayer(vlayer) #zooming to the output layer vlayer.selectAll() mCanvas = iface.mapCanvas() mCanvas.zoomToSelected() vlayer.removeSelection() iface.mapCanvas().refreshAllLayers() print 'Linewidth and color changed' #setting the color of output layer named 'vlayer' vlayer.selectAll() iface.mapCanvas().setSelectionColor(QColor("blue")) print 'color changed' #setting line width of output layer named 'vlayer' symbols = vlayer.rendererV2().symbols() for symbol in symbols: symbol.setWidth(1) print 'Linewidth changed' # Refresh in order the see the changes iface.mapCanvas().refreshAllLayers() print 'Linewidth and color changed'
class TestQgsGeometryGeneratorSymbolLayerV2(TestCase): def setUp(self): polys_shp = os.path.join(TEST_DATA_DIR, 'polys.shp') points_shp = os.path.join(TEST_DATA_DIR, 'points.shp') lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp') self.polys_layer = QgsVectorLayer(polys_shp, 'Polygons', 'ogr') self.points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr') self.lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(self.polys_layer) QgsMapLayerRegistry.instance().addMapLayer(self.lines_layer) QgsMapLayerRegistry.instance().addMapLayer(self.points_layer) # Create style sym1 = QgsFillSymbolV2.createSimple({'color': '#fdbf6f'}) sym2 = QgsLineSymbolV2.createSimple({'color': '#fdbf6f'}) sym3 = QgsMarkerSymbolV2.createSimple({'color': '#fdbf6f'}) self.polys_layer.setRendererV2(QgsSingleSymbolRendererV2(sym1)) self.lines_layer.setRendererV2(QgsSingleSymbolRendererV2(sym2)) self.points_layer.setRendererV2(QgsSingleSymbolRendererV2(sym3)) self.mapsettings = CANVAS.mapSettings() self.mapsettings.setOutputSize(QSize(400, 400)) self.mapsettings.setOutputDpi(96) self.mapsettings.setExtent(QgsRectangle(-133, 22, -70, 52)) def tearDown(self): QgsMapLayerRegistry.instance().removeAllMapLayers() def test_marker(self): sym = self.polys_layer.rendererV2().symbol() sym_layer = QgsGeometryGeneratorSymbolLayerV2.create({'geometryModifier': 'centroid($geometry)'}) sym_layer.setSymbolType(QgsSymbolV2.Marker) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.polys_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_geometrygenerator_marker') self.assertTrue(renderchecker.runTest('geometrygenerator_marker')) def test_mixed(self): sym = self.polys_layer.rendererV2().symbol() buffer_layer = QgsGeometryGeneratorSymbolLayerV2.create({'geometryModifier': 'buffer($geometry, "value"/15)'}) buffer_layer.setSymbolType(QgsSymbolV2.Fill) self.assertIsNotNone(buffer_layer.subSymbol()) sym.appendSymbolLayer(buffer_layer) marker_layer = QgsGeometryGeneratorSymbolLayerV2.create({'geometryModifier': 'centroid($geometry)'}) marker_layer.setSymbolType(QgsSymbolV2.Marker) sym.appendSymbolLayer(marker_layer) rendered_layers = [self.polys_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_geometrygenerator_mixed') self.assertTrue(renderchecker.runTest('geometrygenerator_mixed')) def test_buffer_lines(self): sym = self.lines_layer.rendererV2().symbol() buffer_layer = QgsGeometryGeneratorSymbolLayerV2.create({'geometryModifier': 'buffer($geometry, "value"/15)'}) buffer_layer.setSymbolType(QgsSymbolV2.Fill) self.assertIsNotNone(buffer_layer.subSymbol()) sym.appendSymbolLayer(buffer_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_geometrygenerator_buffer_lines') self.assertTrue(renderchecker.runTest('geometrygenerator_buffer_lines')) def test_buffer_points(self): sym = self.points_layer.rendererV2().symbol() buffer_layer = QgsGeometryGeneratorSymbolLayerV2.create({'geometryModifier': 'buffer($geometry, "staff"/15)'}) buffer_layer.setSymbolType(QgsSymbolV2.Fill) self.assertIsNotNone(buffer_layer.subSymbol()) sym.appendSymbolLayer(buffer_layer) rendered_layers = [self.points_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_geometrygenerator_buffer_points') self.assertTrue(renderchecker.runTest('geometrygenerator_buffer_points'))
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()