def zoomtosel( self ):
codcom =""
fpath =os.getenv("HOME")+'/.qgis2/python/plugins/Cxf_in/CTCOMCAT.txt'
in_file = open(fpath,"r")
testo= in_file.readlines()
comune=""
if (self.ui.cat_com.currentText()) !=comune:
for ctcom in testo:
line=ctcom.split(",")
if line[3].strip()==self.ui.cat_com.currentText():
print line[0].strip()
codcom=line[0].strip()
layer = QgsMapLayerRegistry.instance().mapLayersByName("Particelle") [0]
iface.setActiveLayer(layer)
iter= layer.getFeatures()
nfile = layer.fieldNameIndex('Nomefile')
map = layer.fieldNameIndex('Mappale')
layer.removeSelection ()
foglio=codcom+"_"+self.ui.cat_fg.currentText().replace ('_','')
for feature in iter:
if feature.attributes()[nfile]==codcom+"_"+self.ui.cat_fg.currentText().replace ('_','') and feature.attributes()[map]==self.ui.cat_mapp.currentText() :
layer.select( feature.id())
iface.actionZoomToSelected().trigger()
def addTiles(self, layer, files):
count = 0
layers = []
QApplication.setOverrideCursor( Qt.WaitCursor )
iface.mapCanvas().freeze(True)
for fileName in files:
print("TileIndex plugin : loading raster file %s" % fileName)
fileInfo = QFileInfo(fileName)
rlayer = QgsRasterLayer(fileName, fileInfo.baseName())
if rlayer is None:
print("TileIndex plugin : raster file %s could not be loaded..." % fileName)
continue
layers.append(rlayer)
count = count + 1
print("TileIndex plugin : adding %d layers to map registry" % count)
QgsMapLayerRegistry.instance().addMapLayers(layers)
iface.mapCanvas().freeze(False)
iface.mapCanvas().refresh()
print("TileIndex plugin : done adding layers")
QApplication.restoreOverrideCursor()
# restore active layer if qgis >= 1.9
if count > 0:
if QGis.QGIS_VERSION_INT >= 10900:
iface.legendInterface().setCurrentLayer(layer)
else:
iface.setActiveLayer(layer)
return count
def __init__(self, edit_dialog):
"""Constructor."""
# setup
self.edit_dialog = edit_dialog
self.parent_frame = self.edit_dialog.parent_frame
self.editing_layer = self.edit_dialog.editing_layer
iface.setActiveLayer(self.editing_layer)
def nodeSetActive(node):
if oeq_global.isStringOrUnicode(node):
node = nodeByName(node)
if len(node) == 0:
return None
node = node[0]
iface.setActiveLayer(node.layer())
def createCentroidsLayer(self, layer, filt, name):
#Dato un layer di tipo poligonale, ne crea una copia utilizzandone i centroidi;
#In base al filtro scelto utilizza solo le features selezionate (o tutte le features se non esiste un filtro):
#aggiunge i campi prob, ruolo e probRuolo
if filt:
QueryLayer().selectionByExpr(layer, filt)
else:
layer.selectAll()
context = dataobjects.createContext()
context.setInvalidGeometryCheck(QgsFeatureRequest.GeometryNoCheck)
params = {
'INPUT': QgsProcessingFeatureSourceDefinition(layer.id(), True),
'ALL_PARTS': False,
'OUTPUT': 'memory:'
}
newLayer = processing.run("native:centroids", params, context=context)
layerOutput = newLayer['OUTPUT']
data_provider = layerOutput.dataProvider()
data_provider.addAttributes([QgsField('prob', QVariant.Int)])
data_provider.addAttributes([QgsField('ruolo', QVariant.String)])
data_provider.addAttributes([QgsField('probRuolo', QVariant.String)])
layerOutput.updateFields()
layerOutput.setName(name)
QgsProject.instance().addMapLayer(layerOutput)
QgsProject.instance().layerTreeRoot().findLayer(
layerOutput.id()).setItemVisibilityChecked(False)
layer.removeSelection()
iface.setActiveLayer(layerOutput)
return layerOutput
def add_ext_layer(self, geom_str, idx):
crs = QgsCoordinateReferenceSystem('EPSG:4326').toWkt()
vlayer = self._init_ext_layer(geom_str, idx, crs)
self._add_layer(geom_str, vlayer, idx)
dom = QDomDocument()
dom.setContent(LAYER_QML, True) # xyz_id non editable
vlayer.importNamedStyle(dom)
QgsProject.instance().addMapLayer(vlayer, False)
group = self.add_empty_group()
geom = self._group_geom_name(geom_str)
order = self.GEOM_ORDER.get(geom)
group_geom = self.qgroups.get(geom)
group_geom = group_geom or (
group.insertGroup(order,geom)
if order is not None else
group.addGroup(geom)
)
self.qgroups[geom] = group_geom
group_geom.addLayer(vlayer)
if iface: iface.setActiveLayer(vlayer)
return vlayer
def display_pipe(self, pipe_id):
"""Show the pipe_id attributes on the pipe-tab"""
pipe = self.pipes.getFeatures(QgsFeatureRequest(pipe_id)).next()
hestelmaatregel = self.field_combobox_pipes.findText(
str(pipe["Herstelmaa"]))
if hestelmaatregel:
self.field_combobox_pipes.setCurrentIndex(hestelmaatregel)
else:
self.field_combobox_pipes.setCurrentIndex(0)
opmerking = pipe['Opmerking']
if opmerking:
self.value_plaintextedit_pipes.setPlainText(opmerking)
else:
self.value_plaintextedit_pipes.setPlainText("")
for index, field in enumerate(PIPE_FIELDS):
value = pipe[field] if type(
pipe[field]) is not QPyNullVariant else ""
self.tablewidget_pipes.setItem(0, index, QTableWidgetItem(value))
iface.setActiveLayer(self.pipes)
self.pipes.triggerRepaint()
# Go to the pipe tab
self.tabWidget.setCurrentIndex(2)
self.selected_pipe_id = pipe.id()
def show_measuring_point(self):
"""Show the measuring point that belongs to a certain pipe."""
if not self.measuring_points:
iface.messageBar().pushMessage(
"Error",
"There is no measuring points layer.",
level=QgsMessageBar.CRITICAL,
duration=0)
return
expr = QgsExpression("\"PIPE_ID\" IS '{}'".format(
self.selected_pipe_id))
measuring_points = self.measuring_points.getFeatures(
QgsFeatureRequest(expr))
ids = [measuring_point.id() for measuring_point in measuring_points]
if len(ids) == 0:
iface.messageBar().pushMessage(
"Warning",
"There are no measuring points connected to this pipe.",
level=QgsMessageBar.WARNING,
duration=0)
return
# Setting the selected measure points causes the measure_points onchange to trigger
# which calls get_selected_measuring_point() to display the measure point.
self.measuring_points.setSelectedFeatures(ids)
iface.setActiveLayer(self.measuring_points)
self.measuring_points.triggerRepaint()
# Go to measuring points tab
self.tabWidget.setCurrentIndex(3)
def create_count(self):
layer = self.layers['section']
selected_count = layer.selectedFeatureCount()
if selected_count == 0:
push_info("Veuillez sélectionner un tronçon")
return
elif selected_count > 1:
push_info("Veuillez ne sélectionner qu'un tronçon")
return
else:
selected_feature = next(layer.getSelectedFeatures())
lanes = self.get_lanes_of_section(selected_feature.attribute('id'))
installation = self.get_installation_of_lane(
next(lanes).attribute('id'))
# Save the id of the installation related to the selected section
# so we can use in the count form to automatically select the
# installation in the combobox
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'selected_installation',
installation.attribute('id'))
self.layers['count'].startEditing()
iface.setActiveLayer(self.layers['count'])
iface.actionAddFeature().trigger()
def show_shapefile_layers(directory):
"""
Show the manholes, pipes and measuring points layer.
Set the manholes layer as active layer to be the same layer as the active
tab.
Arguments:
(string) directory: Directory where the shapefiles are.
These shapefiles are shown as layers.
"""
# Manholes
manholes_filename = "{}.shp".format(SHP_NAME_MANHOLES)
manholes_path = os.path.join(directory, manholes_filename)
manholes_layer = iface.addVectorLayer(manholes_path, SHP_NAME_MANHOLES,
"ogr")
# Pipes
pipes_filename = "{}.shp".format(SHP_NAME_PIPES)
pipes_path = os.path.join(directory, pipes_filename)
pipes_layer = iface.addVectorLayer(pipes_path, SHP_NAME_PIPES, "ogr")
# Measuring stations
measuring_points_filename = "{}.shp".format(SHP_NAME_MEASURING_POINTS)
measuring_points_path = os.path.join(directory, measuring_points_filename)
measuring_points_layer = iface.addVectorLayer(measuring_points_path,
SHP_NAME_MEASURING_POINTS,
"ogr")
# Set manholes layer as active layer
iface.setActiveLayer(manholes_layer)
def run_delete_action(self):
self.layer_selector()
assert self.link_layer != None, "self.link_layer != None"
if self.delete_link_action.isChecked() == True:
self.changeTool(self.delete_link_action)
print("link 삭제 작업이 시작되었습니다.")
# deselect all
self.deselectAll()
# selection 버튼 call
iface.actionSelect().trigger()
#link_layer 활성화
iface.setActiveLayer(self.link_layer)
# # delete a feature with specified ID
# layer.deleteFeature(fid)
# selection 이벤트 함수 연결
self.link_layer.selectionChanged.connect(self.deleteLink)
else:
self.link_layer.selectionChanged.disconnect(self.deleteLink)
print("link 삭제 작업이 종료되었습니다.")
def run_add_action(self):
# layer 설정
self.layer_selector()
# assert문으로 layer가 설정되었는지 검증
assert self.node_layer != None, "self.node_layer != None"
# checked 상태 확인
# print("self.add_link_action.isChecked()=", self.add_link_action.isChecked())
# checked 상태이면 node레이어에 selectionChanged 이벤트를 connect
if self.add_link_action.isChecked() == True:
# 버튼 change
self.changeTool(self.add_link_action)
print("Link 추가 작업이 시작되었습니다.")
# 기존에 선택됐던 피쳐 선택 취소하기 위해 deselect action trigger
self.deselectAll()
# selection 버튼 call
iface.actionSelect().trigger()
# node_layer 활성화
iface.setActiveLayer(self.node_layer)
# selectionChanged 이벤트함수 연결
self.node_layer.selectionChanged.connect(self.onNodeSelected)
# checked 아니면 disconnect
else:
self.node_layer.selectionChanged.disconnect(self.onNodeSelected)
print("Link 추가 작업이 종료되었습니다.")
def add_ext_layer(self, geom_str, idx):
"""Add layer group structure
qgroups: dict["main"] = group
dict[geom] = list([vlayer1, vlayer2,...])
map_vlayer: dict[geom_str] = list([vlayer1, vlayer2,...])
vlayer order in list shall always be fixed, deleted vlayer hall be set to None
map_fields: dict[geom_str] = list([fields1, fields2,...])
fields order in list shall always be fixed and not be deleted
geom_str: QgsWkbTypes.displayString (detailed geometry, e.g. Multi-)
geom: QgsWkbTypes.geometryDisplayString (generic geometry,)
"""
group = self.add_empty_group()
geom = self._group_geom_name(geom_str)
order = self.GEOM_ORDER.get(geom)
group_geom = group.findGroup(geom) or (group.insertGroup(
order, geom) if order is not None else group.addGroup(geom))
crs = QgsCoordinateReferenceSystem("EPSG:4326").toWkt()
vlayer = self._init_ext_layer(geom_str, idx, crs)
self._add_layer(geom_str, vlayer, idx)
self._connect_cb_vlayer(vlayer, geom_str, idx)
dom = QDomDocument()
dom.setContent(LAYER_QML, True) # xyz_id non editable
vlayer.importNamedStyle(dom)
QgsProject.instance().addMapLayer(vlayer, False)
group_geom.addLayer(vlayer)
if iface:
iface.setActiveLayer(vlayer)
return vlayer
def run(self):
"""Run method that loads and starts the plugin"""
manholes_layerList = QgsMapLayerRegistry.instance().mapLayersByName(
SHP_NAME_MANHOLES)
pipes_layerList = QgsMapLayerRegistry.instance().mapLayersByName(
SHP_NAME_PIPES)
measuring_points_layerList = QgsMapLayerRegistry.instance(
).mapLayersByName(SHP_NAME_MEASURING_POINTS)
if not self.pluginIsActive:
#print "** STARTING Beoordelingstool"
# dockwidget may not exist if:
# first run of plugin
# removed on close (see self.onClosePlugin method)
# Check if the layers manholes, pipes and measuring_points are active
if not manholes_layerList or not pipes_layerList or not measuring_points_layerList:
iface.messageBar().pushMessage(
"Warning",
"You don't have a manholes, pipes and measuring_points layer. \n Upload a json.",
level=QgsMessageBar.WARNING,
duration=20)
self.download_dialog = BeoordelingstoolDownloadDialog()
self.download_dialog.show()
else:
# Create the dockwidget (after translation) and keep reference
self.dockwidget = BeoordelingstoolDockWidget(
manhole_layer=manholes_layerList[0],
pipe_layer=pipes_layerList[0],
measuring_point_layer=measuring_points_layerList[0])
# DOWNLOAD
# connect to provide cleanup on closing of dockwidget
self.dockwidget.closingPlugin.connect(self.onClosePlugin)
# show the dockwidget
# TODO: fix to allow choice of dock location
self.iface.addDockWidget(Qt.RightDockWidgetArea,
self.dockwidget)
self.dockwidget.show()
self.pluginIsActive = True
# Set the active layer to the manholes layer to be in
# compliance with the Manholes tab of the dockwidget.
iface.setActiveLayer(manholes_layerList[0])
# Show a message if not all layers are active
elif self.pluginIsActive:
if not manholes_layerList or not pipes_layerList or not measuring_points_layerList:
self.iface.removeDockWidget(self.dockwidget)
self.dockwidget = None
self.pluginIsActive = False
iface.messageBar().pushMessage(
"Warning",
"You don't have a manholes, pipes and measuring_points layer. \n Upload a json.",
level=QgsMessageBar.WARNING,
duration=20)
self.download_dialog = BeoordelingstoolDownloadDialog()
self.download_dialog.show()
def set_active_layer(self):
layer = tools_qt.get_combo_value(self.dlg, self.dlg.cmb_layers, 0)
if type(layer) != QgsVectorLayer:
msg = "Invalid layer"
tools_gw.show_warning(msg)
return
iface.setActiveLayer(layer)
def initLayerNavigation(self):
self.layerName = str(self.ui.layersCombo.currentText())
self.layer = layer_helper.get_layer(self.layerName)
iface.setActiveLayer(self.layer)
self.features = []
for f in self.layer.getFeatures():
self.features.append(f)
self.ui.maxLabel.setText(" of " + str(len(self.features)))
self.currentFeatureIdx = 0
def createArea(self):
l = self.proj.mapLayersByName('Beräkningsområde')
if l:
l = l[0]
iface.setActiveLayer(l)
iface.actionToggleEditing().trigger()
iface.actionAddFeature().trigger()
#l.featureAdded.connect(lambda fid: self.areaAdded(fid, l))
l.featureAdded.connect(lambda fid: self.showSaveDialog(fid, l))
def testImportFeature(self):
'''Simulate user moves and check results.'''
# Open python console
iface.actionShowPythonDialog().trigger()
# Get map tool action that is activated
previousActivatedMapToolActionName = iface.mapCanvas().mapTool().action().text()
#Add test layers to map registry
layerDest = self.addTestVectorLayer()
layerSource = self.addTestVectorLayer('test/data/segment2.shp')
iface.setActiveLayer(layerDest)
# Simulate click on edit mode button
self.clickOnWidgetByActionName(iface.actionToggleEditing().text())
# Simulate click on plugin fusion button
self.clickOnWidgetByActionName('Import Feature')
# Move and click on the feature to import
self.clickOnMapPoint(QgsPoint(785519,6528705))
# Feature must have been added
if not self.printTest(38, self.featuresCount(layerDest), 'Import feature', 'Features count'):
return
# End of test ?
if self.TESTS_TO_CHECK == 'up_to_import_feature':
return
# Test undo action
self.ctrlZ()
if not self.printTest(37, self.featuresCount(layerDest), 'Undo Import feature(Ctrl + z)', 'Features count'):
return
# End of test ?
if self.TESTS_TO_CHECK == 'up_to_undo_import_feat':
return
# Quit edit mode
self.clickOnWidgetByActionName(iface.actionToggleEditing().text())
# Fusion button must be enabled
if not self.printTest(False, self.findButtonByActionName('Import Feature').isEnabled(), 'Disable fusion button', 'Fusion button status'):
return
# Previous map tool button must be re-checked
if not self.printTest(True, self.findButtonByActionName(previousActivatedMapToolActionName).isChecked(), 'Check previous map tool button ('+previousActivatedMapToolActionName+')', 'Previous map tool button ('+previousActivatedMapToolActionName+') status'):
return
# End of test ?
if self.TESTS_TO_CHECK == 'up_to_quit_edit_import_feat':
return
# Clear layers
#QgsMapLayerRegistry.instance().removeAllMapLayers()
iface.mapCanvas().refresh()
def restore_user_layer(layer_name, user_current_layer=None):
""" Set active layer, preferably @user_current_layer else @layer_name """
if user_current_layer:
iface.setActiveLayer(user_current_layer)
else:
layer = get_layer_by_tablename(layer_name)
if layer:
iface.setActiveLayer(layer)
def set_active_layer(self):
print("activar seleccion sobre la capa seleccionada")
layer = tools_qt.get_combo_value(self.dlg_btn1,
self.dlg_btn1.cmb_layers, 0)
if type(layer) != QgsVectorLayer:
msg = "Invalid layer"
tools_gw.show_warning(msg)
return
iface.setActiveLayer(layer)
def updateLink(self, fid, new_geom):
# print("fid: ", fid, "geom: ", new_geom, "노드가 변경되었습니다.")
## link_layer 수정, node 따라서 geometry만 수정
# changeGeometry 함수가 적용되기 위해 레이어의 edit 모드가 활성화 되어야 한다.
iface.setActiveLayer(self.link_layer)
# self.link_layer.startEditing()
# link_layer의 모든 feature 확인
for feat in self.link_layer.getFeatures():
# 이동한 node와 같은 id의 fr, to 노드를 가진 link 찾기
# from 노드가 수정된 경우
if fid == feat["node_fr"]:
link_id = feat["link_id"]
# to 노드는 기존에 있는 값 그대로 사용
toPoint = self.node_layer.getFeature(feat["node_to"])
# frGeom, toGeom = new_geom, feat.geometry().get()[-1] # feature의 geometry에 바로 접근하는 방법
frGeom, toGeom = new_geom, toPoint.geometry()
new_link_geom = QgsGeometry.fromPolyline(
[QgsPoint(frGeom.asPoint()),
QgsPoint(toGeom.asPoint())])
# link geometry 수정
try:
with edit(self.link_layer):
ok = self.link_layer.changeGeometry(
link_id, new_link_geom)
# feat.setGeometry(new_link_geom)
# 결과 출력
print("Changed?: ", ok, "link id: ", link_id)
except Exception as err:
print(repr(err))
# to 노드가 수정된 경우
if fid == feat["node_to"]:
link_id = feat["link_id"]
frPoint = self.node_layer.getFeature(feat["node_fr"])
frGeom, toGeom = frPoint.geometry(), new_geom
new_link_geom = QgsGeometry.fromPolyline(
[QgsPoint(frGeom.asPoint()),
QgsPoint(toGeom.asPoint())])
try:
with edit(self.link_layer):
ok = self.link_layer.changeGeometry(
link_id, new_link_geom)
print("Changed?: ", ok, "link id: ", link_id)
except Exception as err:
print(repr(err))
## node수정작업 연속으로 하기위해 다시 node_layer 활성화
self.moveNode()
def moveNode(self):
self.deselectAll()
## node_layer 활성화
iface.setActiveLayer(self.node_layer)
## edit mode 시작
self.node_layer.startEditing()
# move feature 버튼 call
# https://gis.stackexchange.com/questions/141371/implementing-add-feature-action-using-pyqgis?rq=1
iface.actionMoveFeature().trigger()
def move_active_vector_layer_to_top():
layer = iface.activeLayer()
if isinstance(layer, QgsVectorLayer):
root = QgsProject.instance().layerTreeRoot()
my_layer = root.findLayer(layer)
clone = my_layer.clone()
parent = my_layer.parent()
parent.insertChildNode(0, clone)
parent.removeChildNode(my_layer)
layer = QgsProject.instance().mapLayersByName(layer.name())[0]
iface.setActiveLayer(layer)
def selectArea(self):
for a in iface.attributesToolBar().actions():
if a.objectName() == 'mActionDeselectAll':
a.trigger()
break
l = self.proj.mapLayersByName('Beräkningsområde')
if l:
l = l[0]
iface.setActiveLayer(l)
iface.actionSelect().trigger()
def add_capture_source_area_layer(self):
"""Called on opening of frame to add capture source area layer"""
path = os.path.join(os.path.dirname(os.path.dirname(__file__)),
"styles/")
# add layer
self.capture_source_area = self.layer_registry.add_postgres_layer(
"capture_source_area", "capture_source_area", "shape",
"buildings_reference", "", "")
# set style
self.capture_source_area.loadNamedStyle(path + "capture_source.qml")
# make capture source area the active layer
iface.setActiveLayer(self.capture_source_area)
def load_layers(self):
settings = Settings()
group_comptages = QgsProject.instance().layerTreeRoot().findGroup(
'Comptages')
group_extra = QgsProject.instance().layerTreeRoot().findGroup('Extra')
if group_comptages is None:
group_comptages = QgsProject.instance().layerTreeRoot().addGroup(
'Comptages')
if group_extra is None and settings.value("extra_layers"):
group_extra = group_comptages.addGroup('Extra')
for key in LAYER_DEFINITIONS:
layer_definition = LAYER_DEFINITIONS[key]
if not QgsProject.instance().mapLayersByName(
layer_definition['display_name']):
layer = self.load_layer(
'comptages', # Schema
layer_definition['table'],
layer_definition['geometry'],
layer_definition['sql'],
layer_definition['display_name'],
layer_definition['id'],
layer_definition['epsg'],
)
if layer_definition['legend']:
group_comptages.addLayer(layer)
elif settings.value("extra_layers"):
group_extra.addLayer(layer)
self.layers[key] = layer
self.apply_qml_styles()
self.add_layer_actions()
self.create_virtual_fields()
self.create_joins()
self.create_relations()
iface.setActiveLayer(self.layers['section'])
self.populate_list_of_highlighted_sections()
self.layers['count'].featureAdded.connect(self.on_count_added)
from qgis.core import QgsExpressionContextUtils
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'highlighted_installation', '')
def currentRowChanged(self, selected, deselected):
indexes = self.annotationView.selectedIndexes()
if len(indexes) == 0:
return
rowIndex = indexes[0].row()
targetLayer = None
for node in QgsProject.instance().layerTreeRoot().findLayers():
layer = node.layer()
if isinstance(layer, QgsRasterLayer) and layer.dataProvider(
).dataSourceUri() == self.model.item(rowIndex, 2).text():
targetLayer = layer
break
root = QgsProject.instance().layerTreeRoot()
if targetLayer is None:
file = QFileInfo(self.model.item(rowIndex, 2).text())
path = file.filePath()
base = file.baseName()
targetLayer = QgsRasterLayer(path, base)
QgsProject.instance().addMapLayer(targetLayer, False)
root.insertLayer(0, targetLayer)
else:
clonedLayer = targetLayer.clone()
QgsProject.instance().removeMapLayer(targetLayer.id())
QgsProject.instance().addMapLayer(clonedLayer)
targetLayer = clonedLayer
iface.setActiveLayer(targetLayer)
crs = QgsCoordinateReferenceSystem(self.model.item(rowIndex, 3).text())
QgsProject.instance().setCrs(crs)
iface.mapCanvas().setExtent(targetLayer.extent())
point1 = QgsPointXY(float(self.model.item(rowIndex, 8).text()),
float(self.model.item(rowIndex, 9).text()))
point2 = QgsPointXY(float(self.model.item(rowIndex, 8).text()),
float(self.model.item(rowIndex, 11).text()))
point3 = QgsPointXY(float(self.model.item(rowIndex, 10).text()),
float(self.model.item(rowIndex, 11).text()))
point4 = QgsPointXY(float(self.model.item(rowIndex, 10).text()),
float(self.model.item(rowIndex, 9).text()))
self.resetSelectionBand()
self.selectionBand.addPoint(point1, False)
self.selectionBand.addPoint(point2, False)
self.selectionBand.addPoint(point3, False)
self.selectionBand.addPoint(point4, True)
self.selectionBand.setOpacity(0.5)
self.selectionBand.show()
def run(self):
"""Run method that performs all the real work"""
from qgis.core import QgsMarkerSymbol, QgsProject, QgsSymbol
from qgis.utils import iface
import pandas as pd
import time
data = pd.read_pickle('C:\\projectData\\blackforest\\data.pickle')
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
self.dlg = FloatingWasteDialog()
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
stationLayer = QgsProject.instance().mapLayersByName("SensorStations")[0]
stationLayer.setAutoRefreshInterval(500)
stationLayer.setAutoRefreshEnabled(True)
iface.setActiveLayer(stationLayer)
FloatingWaste.setRenderer(layer = stationLayer)
iface.layerTreeView().refreshLayerSymbology(stationLayer.id())
stationLayer.startEditing()
for i in range(len(data)):
print(i)
for c in data.columns:
index = c - 1
value = data.loc[i,c]
wlevel = FloatingWaste.getWasteClass(value)
# (ID, 0=id; 1=wlevel; 2=wastecount, value)
stationLayer.changeAttributeValue(index, 1, wlevel)
stationLayer.changeAttributeValue(index, 2, str(value))
print(f"Station:{index}, Vaule:{value}, Class:{wlevel}")
#iface.layerTreeView().refreshLayerSymbology(iface.activeLayer().id())
#iface.layerTreeView().refreshLayerSymbology(stationLayer.id())
FloatingWaste.spin(3)
def populateProject(self, _feedback=None):
"""Populates the project."""
project = QgsProject.instance()
root = project.layerTreeRoot()
layersToAdd = self._config.layers
savedICAO = project.metadata().keywords().get('icao')
# Clear the project if a ICAO if is present and it's not the apt being loaded
if savedICAO is not None and savedICAO[0] != self._airport.getIcao():
project.clear()
airportGroup = root.findGroup(
LayerName.Airport.value) or self.addGroup(LayerName.Airport.value)
mapsGroup = root.findGroup(LayerName.Maps.value) or self.addGroup(
LayerName.Maps.value)
terrainGroup = root.findGroup(
LayerName.Terrain.value) or self.addGroup(LayerName.Terrain.value)
airspaceGroup = root.findGroup(
LayerName.Airspace.value) or self.addGroup(
LayerName.Airspace.value)
airspace = None
if LayerType.Fixes in layersToAdd:
self._generateFixes(airportGroup)
if LayerType.Restricted in layersToAdd:
self._generateRestricted(airportGroup)
if LayerType.Airspace in layersToAdd:
airspace = self._generateAirspace(airspaceGroup)
if LayerType.AirspaceHidden in layersToAdd:
self._generateAirspace(airspaceGroup, True)
if LayerType.Maps in layersToAdd:
self._generateMaps(mapsGroup)
if LayerType.ExistingTerrain in layersToAdd:
self.loadExistingTerrain(terrainGroup)
if not project.mapLayersByName('OpenStreetMap'):
osm = QgsRasterLayer(_XYZ_OSM, 'OpenStreetMap', 'wms')
self.addLayerToGroup(osm, root)
if airspace:
iface.setActiveLayer(airspace)
self.zoomToGroup(airspaceGroup)
def zoomToSelectedFeature(self, layer):
#Dato un layer lo attiva e zoomma sulle features attive
#In base al numero di features attive setta la scala per lo zoom
iface.setActiveLayer(layer)
iface.mapCanvas().zoomToSelected()
scale = iface.mapCanvas().scale()
if len(layer.selectedFeatures()) > 5:
newScale = scale + 0.5 * scale
if len(layer.selectedFeatures()) <= 5:
newScale = scale + 1.5 * scale
if len(layer.selectedFeatures()) <= 3:
newScale = scale + 2 * scale
if len(layer.selectedFeatures()) == 1:
newScale = scale + 10 * scale
iface.mapCanvas().zoomScale(newScale)
def selectLinePushButton_clicked(self):
#self.hide()
vectorDraftLyr = QgsVectorLayer('LineString?crs=epsg:4326',
'Please Draw A Line for Planning',
"memory")
QgsProject().instance().addMapLayer(vectorDraftLyr)
# set layer active
self.hide()
iface.setActiveLayer(vectorDraftLyr)
# start edit
iface.actionToggleEditing().trigger()
# enable tool
iface.actionAddFeature().trigger()
#self.show()
iface.actionToggleEditing().triggered.connect(self.endDrawLine)
def show_feature(self, nr):
'''Show selected feature on map'''
try:
featureID = eval('self.featureID' + str(nr))
feature_data = featureID.text().split('\n')
layer_name = feature_data[0]
layer = QgsProject.instance().mapLayersByName(layer_name)[0]
iface.setActiveLayer(layer)
layer.removeSelection()
# if result contains features id select it
if len(feature_data) == 2:
layer.select(int(feature_data[1]))
box = layer.boundingBoxOfSelected()
iface.mapCanvas().setExtent(box)
iface.mapCanvas().refresh()
except Exception as e:
print('Something happened at delete_rule [%s]' % (e))
def add_outlines(self):
"""
Add building outlines to canvas
"""
path = os.path.join(os.path.dirname(os.path.dirname(__file__)),
"styles/")
self.layer_registry.remove_layer(self.building_layer)
self.building_historic = self.layer_registry.add_postgres_layer(
"historic_outlines", "building_outlines", "shape", "buildings", "",
"end_lifespan is not NULL")
self.building_historic.loadNamedStyle(path + "building_historic.qml")
self.building_layer = None
self.building_layer = self.layer_registry.add_postgres_layer(
"building_outlines", "building_outlines", "shape", "buildings", "",
"end_lifespan is NULL")
self.building_layer.loadNamedStyle(path + "building_blue.qml")
iface.setActiveLayer(self.building_layer)
def addToMap(csvfile, selectedLayer):
# A little windows path trickery
if csvfile[0] is not "/":
csvfile = "/" + csvfile
uri = "file://{0}?delimiter={1}&crs={2}&wktField={3}".format(
csvfile, ",",
selectedLayer.crs().authid(), "Wkt")
rOutput = QgsVectorLayer(uri,
"ProfileLayer_{}".format(selectedLayer.name()),
"delimitedtext")
symbolize(rOutput, selectedLayer)
QgsMapLayerRegistry.instance().addMapLayer(rOutput)
# Make sure this doesn't change the active layer selection
iface.setActiveLayer(selectedLayer)
def setActiveLayer(*args):
"""Makes layer with the given name active.
NOTE: layer should be loaded into project.
"""
layer = layerFromName(args[0])
iface.setActiveLayer(layer)
def set_active_layer(layer):
"""
Set the active layer in the current session
"""
layer = layer_by_name(layer)
iface.setActiveLayer(layer)
def _selectLayer():
layer = layerFromName("points")
iface.setActiveLayer(layer)
for dRange in rangeList:
canvas = iface.mapCanvas()
myLayer=NULL #note: take all this out of loop
myPolyLayer=NULL
#set current layer to the main malnutrition one, edit it
for layer in canvas.layers():
if NAMEOFPOINTLAYER.lower() in layer.name().lower():
myLayer=layer
if NAMEOFPOLYLAYER.lower() in layer.name().lower():
myPolyLayer=layer
if myLayer==NULL:
print 'point layer name has changed'
if myPolyLayer==NULL:
print 'polygon layer has changed'
iface.setActiveLayer(myLayer)
layer=myLayer
#dRange in form [min,max] of date objects
[city_dict]=malHat.getCityDict(dRange,visitKey,cityKey,inQgis=True)
#city dict in form {city:(mild,moderate,severe)}
#now place malnut values into QGIS for map export
layer.startEditing()
if not ruleBased: #renders all city points
symbol= QgsSymbolV2.defaultSymbol(layer.geometryType()) #make the points all just green
renderer = QgsSingleSymbolRendererV2(symbol)
# create a new simple marker symbol layer, a green circle with a black border
properties = {'color': 'green', 'color_border': 'black','scale_method':'Map unit','size':'2'}
