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'))
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()
