def db_view_change_style():
in_file =open(os.getenv("HOME")+'/.qgis2/python/plugins/Cxf_in/setting.sty', 'r')
for line in in_file:
if line[:4]=="att:":
dirstili=line.split (":",2)[2].replace("\n","")
if(os.path.exists(dirstili) ==False):
dirstili= os.getenv("HOME")+'/.qgis2/python/plugins/Cxf_in/QML_Default'
in_file.close()
layers = iface.legendInterface().layers()
for layer in layers:
if layer.name() == "Particelle":
layer.loadNamedStyle(dirstili+'/part.qml')
elif layer.name() == "Fabbricati":
layer.loadNamedStyle(dirstili+'/fab.qml')
elif layer.name() == "Strade":
layer.loadNamedStyle(dirstili+'/strade.qml')
elif layer.name() == "Confine":
layer.loadNamedStyle(dirstili+'/conf.qml')
elif layer.name() == "Acque":
layer.loadNamedStyle(dirstili+'/acque.qml')
elif layer.name() == "Linee":
layer.loadNamedStyle(dirstili+'/linee.qml')
elif layer.name() == "Simboli":
layer.loadNamedStyle(dirstili+'/Simboli.qml')
elif layer.name() == "Testi":
layer.loadNamedStyle(dirstili+'/testo.qml')
elif layer.name() == "Fiduciali":
layer.loadNamedStyle(dirstili+'/fidu.qml')
iface.mapCanvas().refresh()
def processAlgorithm(self, feedback):
fileName = self.getParameterValue(self.INPUT)
layer = dataobjects.getObjectFromUri(fileName)
crs = QgsCoordinateReferenceSystem(self.getParameterValue(self.CRS))
provider = layer.dataProvider()
ds = provider.dataSourceUri()
p = re.compile("\|.*")
dsPath = p.sub("", ds)
if dsPath.lower().endswith(".shp"):
dsPath = dsPath[:-4]
wkt = crs.toWkt()
with open(dsPath + ".prj", "w") as f:
f.write(wkt)
qpjFile = dsPath + ".qpj"
if os.path.exists(qpjFile):
with open(qpjFile, "w") as f:
f.write(wkt)
layer.setCrs(crs)
iface.mapCanvas().refresh()
self.setOutputValue(self.OUTPUT, fileName)
def viewsel( self ):
#ocon = sqlite3.connect(globals.dbName)
ocur = globals.ocon.cursor()
ocur.execute("select distinct Nomefile,Sel from " + globals.schema + "selezione order by Nomefile")
lista="("
for d in ocur:
if d[1] == "1":
lista+="'"+d[0]+"',"
lista=lista[:-1]+")"
if lista!=")":
lista="Nomefile IN "+lista
if self.ui.singolfg.isChecked() :
lista = lista + " AND ((EXT='') or (Ext is Null))"
db_view_sel(self,lista)
else:
lista="Nomefile=='9999'"
db_view_sel(self,lista)
iface.mapCanvas().zoomToFullExtent()
def picker_clicked(self):
if iface.mapCanvas().mapTool() != self.tool:
self.pick_mode = self.PICK_MAP
iface.mapCanvas().setMapTool(self.tool)
self.clear_plot()
else:
self.stop_picking()
def get_bounding_box(self):
"""
Get the geometry of the bbox in WGS84
@rtype: QGsRectangle in WGS84
@return: the extent of the map canvas
"""
# If mapCanvas is checked
if self.radioButton_extentMapCanvas.isChecked():
geom_extent = iface.mapCanvas().extent()
if hasattr(iface.mapCanvas(), "mapSettings"):
source_crs = iface.mapCanvas().mapSettings().destinationCrs()
else:
source_crs = iface.mapCanvas().mapRenderer().destinationCrs()
else:
# Else if a layer is checked
layer = self.comboBox_extentLayer.currentLayer()
geom_extent = layer.extent()
source_crs = layer.crs()
geom_extent = QgsGeometry.fromRect(geom_extent)
epsg_4326 = QgsCoordinateReferenceSystem('EPSG:4326')
crs_transform = QgsCoordinateTransform(source_crs, epsg_4326)
geom_extent.transform(crs_transform)
return geom_extent.boundingBox()
def manageFinished(self, success, reason):
''' Do action after notify that alg is finished. These are the postprocessing steps
1) merge result to the output layer
2) add the layer to canvas in case it is new
3) notify edn of processing
4) terminate the thread
'''
# finish the thread
self.thread.quit()
# check result
if not success:
QgsMessageLog.logMessage('Failed execution: {}'.format(reason), 'QTraffic', QgsMessageLog.CRITICAL)
iface.messageBar().pushCritical('QTraffic', self.tr("Error executing the algorithm: {}".format(reason)))
return
# prepare result
try:
self.alg.addResultToLayer(self.outLayer)
except Exception as ex:
traceback.print_exc()
QgsMessageLog.logMessage('Cannot add result to layer: {}'.format(str(ex)), 'QTraffic', QgsMessageLog.CRITICAL)
iface.messageBar().pushCritical('QTraffic', self.tr("Cannot add result to layer"))
return
# add or refresh rsult vector layer
addToInputLayer = self.gui.addToOriginaLayer_RButton.isChecked()
if not addToInputLayer:
QgsMapLayerRegistry.instance().addMapLayer(self.outLayer)
iface.mapCanvas().refresh()
# notify the user the end of process
iface.messageBar().pushSuccess('QTraffic', self.tr('Alg terminated successfully'))
def change_color():
active_layer = iface.activeLayer()
renderer = active_layer.rendererV2()
symbol = renderer.symbol()
symbol.setColor(QColor(Qt.red))
iface.mapCanvas().refresh()
iface.legendInterface().refreshLayerSymbology(active_layer)
def show_neighbors(skip):
layer_neighbors = get_layer(LAYER_NEIGHBORS)
layer_vols = get_layer(LAYER_VOLUMES)
features = load_feature_dict_id(layer_neighbors)
features_uuid = load_feature_dict_UUID(layer_vols)
idx = 0
for f in features.values():
# Skip first elements.
if idx < skip:
idx += 1
continue
neighbors = f[FIELD_NEIGHBORS_UUID].split(",")
selection = []
for x in neighbors:
selection.append(features_uuid[x].id())
layer_vols.setSelectedFeatures(selection)
box = layer_vols.boundingBoxOfSelected()
iface.mapCanvas().setExtent(box)
iface.mapCanvas().refresh()
reply = QMessageBox.question(
None, "Message", "Continue?\n (seeing feature " + str(idx) + ")", QMessageBox.No, QMessageBox.Yes
)
if reply == QMessageBox.No:
break
idx += 1
def dms (lat, lon):
"""
Add a point at the lat and lon for the current layer using DMS notation
"""
lat,lon = lat, lon
l_lat = lat.upper().split()
l_lon = lon.upper().split()
# need to add validation tests
if l_lat[3] == 'N':
ddlat = float(l_lat[0])+(float(l_lat[1])/60)+float(l_lat[2])/3600
elif l_lat[3] == 'S':
ddlat = (float(l_lat[0])+float(l_lat[1])/60+float(l_lat[2])/3600)*-1
else:
ddlat = '0'
if l_lon [3] == 'E':
ddlon = float(l_lon[0])+float(l_lon[1])/60+float(l_lon[2])/3600
elif l_lon[3] == 'W':
ddlon = (float(l_lon[0])+float(l_lon[1])/60+float(l_lon[2])/3600)*-1
else:
ddlon = '0'
layer = iface.activeLayer()
f = QgsFeature(layer.pendingFields())
geom = QgsGeometry.fromPoint(QgsPoint(ddlon,ddlat))
f.setGeometry(geom)
layer.addFeature(f)
iface.mapCanvas().refresh()
def setExpressionObj(self):
#set expression calculator if not empty
self.expA = dict()
self.expB = dict()
if bool(self.expressionLayerA) or bool(self.expressionLayerB):
if bool(self.expressionLayerA):
for field in self.expressionLayerA.keys():
tempDict = {'exp':None,'val':None}
tempDict['exp'] = QgsExpression(self.expressionLayerA[field])
da = QgsDistanceArea()
da.setSourceCrs(self.vproviderA.crs().srsid())
canvas = iface.mapCanvas()
da.setEllipsoidalMode(canvas.mapRenderer().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry('Measure',
'/Ellipsoid',
GEO_NONE)[0])
tempDict['exp'].setGeomCalculator(da)
self.expA[field] = tempDict
else:
for field in self.expressionLayerB.keys():
tempDict = {'exp':None,'val':None}
tempDict['exp'] = QgsExpression(self.expressionLayerB[field])
da = QgsDistanceArea()
da.setSourceCrs(self.vproviderA.crs().srsid())
canvas = iface.mapCanvas()
da.setEllipsoidalMode(canvas.mapRenderer().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry('Measure',
'/Ellipsoid',
GEO_NONE)[0])
tempDict['exp'].setGeomCalculator(da)
self.expB[self.mapBFields[field]] = tempDict
def processAlgorithm(self, parameters, context, feedback):
fileName = self.getParameterValue(self.INPUT)
layer = QgsProcessingUtils.mapLayerFromString(fileName, context)
crs = QgsCoordinateReferenceSystem(self.getParameterValue(self.CRS))
provider = layer.dataProvider()
ds = provider.dataSourceUri()
p = re.compile('\|.*')
dsPath = p.sub('', ds)
if dsPath.lower().endswith('.shp'):
dsPath = dsPath[:-4]
wkt = crs.toWkt()
with open(dsPath + '.prj', 'w') as f:
f.write(wkt)
qpjFile = dsPath + '.qpj'
if os.path.exists(qpjFile):
with open(qpjFile, 'w') as f:
f.write(wkt)
layer.setCrs(crs)
iface.mapCanvas().refresh()
self.setOutputValue(self.OUTPUT, fileName)
def get_bounding_box(self):
"""
Get the geometry of the bbox in WGS84
@rtype: QGsRectangle in WGS84
@return: the extent of the map canvas
"""
# If mapCanvas is checked
if self.radioButton_extentMapCanvas.isChecked():
geom_extent = iface.mapCanvas().extent()
if hasattr(iface.mapCanvas(), "mapSettings"):
source_crs = iface.mapCanvas().mapSettings().destinationCrs()
else:
source_crs = iface.mapCanvas().mapRenderer().destinationCrs()
else:
# Else if a layer is checked
index = self.comboBox_extentLayer.currentIndex()
layer_id = self.comboBox_extentLayer.itemData(index)
layers = iface.legendInterface().layers()
for layer in layers:
if layer.id() == layer_id:
geom_extent = layer.extent()
source_crs = layer.crs()
break
else:
# the layer could be deleted before
layer_name = self.comboBox_extentLayer.itemText(index)
raise NoLayerException(suffix=layer_name)
geom_extent = QgsGeometry.fromRect(geom_extent)
epsg_4326 = QgsCoordinateReferenceSystem('EPSG:4326')
crs_transform = QgsCoordinateTransform(source_crs, epsg_4326)
geom_extent.transform(crs_transform)
return geom_extent.boundingBox()
def checkSettings(self):
s = QSettings()
# pixmap preview width
self.previewWidth = s.value('TileIndexPlugin/previewWidth', 1000, type=int)
# activate/deactivate map canvas event filter
self.transparentFix = ( s.value('TileIndexPlugin/transparentFix', True, type=bool ) == True )
# activate/deactivate map canvas event filter
if s.value('TileIndexPlugin/contextMenu', True, type=bool):
if not self.filterActive:
iface.mapCanvas().installEventFilter(self)
self.filterActive = True
else:
if self.filterActive:
iface.mapCanvas().removeEventFilter(self)
self.filterActive = False
# which attribute(s) should we look for to get raster file names?
self.locationAttr=['location']
if s.value('TileIndexPlugin/attribute', False, type=bool):
# TODO change this
attr=s.value('TileIndexPlugin/attributeStr', '', type=str).split(' ') #,QString.SkipEmptyParts)
for a in attr:
self.locationAttr.append(a)
def stop_picking(self):
if self.pick_mode == self.PICK_MAP:
iface.mapCanvas().unsetMapTool(self.tool)
elif self.pick_mode == self.PICK_LAYER:
self.pick_layer.selectionChanged.disconnect(self.on_pick_selection_changed)
self.pick_layer = None
self.pick_mode = self.PICK_NO
def useLayerExtent(self):
CANVAS_KEY = "Use canvas extent"
extentsDict = {}
extentsDict[CANVAS_KEY] = {
"extent": iface.mapCanvas().extent(),
"authid": iface.mapCanvas().mapSettings().destinationCrs().authid(),
}
extents = [CANVAS_KEY]
layers = dataobjects.getAllLayers()
for layer in layers:
authid = layer.crs().authid()
if ProcessingConfig.getSetting(ProcessingConfig.SHOW_CRS_DEF) and authid is not None:
layerName = u"{} [{}]".format(layer.name(), authid)
else:
layerName = layer.name()
extents.append(layerName)
extentsDict[layerName] = {"extent": layer.extent(), "authid": authid}
(item, ok) = QInputDialog.getItem(self, self.tr("Select extent"), self.tr("Use extent from"), extents, False)
if ok:
self.setValueFromRect(extentsDict[item]["extent"])
if extentsDict[item]["authid"] != iface.mapCanvas().mapSettings().destinationCrs().authid():
iface.messageBar().pushMessage(
self.tr("Warning"),
self.tr(
"The projection of the chosen layer is not the same as canvas projection! The selected extent might not be what was intended."
),
QgsMessageBar.WARNING,
8,
)
def loadLayerTable(self, carhabLayer, tableName):
# Retrieve layer from provider.
uri = QgsDataSourceURI()
uri.setDatabase(carhabLayer.dbPath)
schema = ''
geom_column = 'the_geom'
uri.setDataSource(schema, tableName, geom_column)
display_name = carhabLayer.getName()+'_'+tableName
layer = QgsVectorLayer(uri.uri(), display_name, 'spatialite')
crsType = QgsCoordinateReferenceSystem.EpsgCrsId
crsVal = 2154
crs = QgsCoordinateReferenceSystem(crsVal, crsType)
layer.setCrs(crs)
# "Bind" layer to carhab layer.
if self.getCarhabLayerByDbPath(carhabLayer.dbPath):
layer.setCustomProperty('carhabLayer', carhabLayer.id)
# Add layer to map (False to add to group)
QgsMapLayerRegistry.instance().addMapLayer(layer, False)
iface.mapCanvas().setExtent(layer.extent())
return layer
def filterLayer(layerName, criteria):
lyrs = QgsMapLayerRegistry.instance().mapLayers()
schema = ''
for l in lyrs:
if QgsMapLayerRegistry.instance().mapLayer(l).name() == layerName:
desc=layers[layerName]
uri = QgsDataSourceURI()
uri.setDatabase(root+desc[0])
schema = ''
table = desc[1]
geom_column = desc[2]
uri.setDataSource(schema, table, geom_column, criteria)
layer=QgsMapLayerRegistry.instance().mapLayer(l)
print layer.dataProvider().dataSourceUri()
layer.dataProvider().setDataSourceUri(uri.uri())
layer.rendererV2().symbol().setAlpha(1)
QgsMapLayerRegistry.instance().reloadAllLayers()
layer.dataProvider().reloadData()
layer.dataProvider().forceReload()
layer.triggerRepaint()
QgsMapCanvas().refresh()
qgis.utils.iface.mapCanvas().refresh()
iface.mapCanvas().refresh()
#layer.setDataSource(uri.uri(), table, geom_column)
return
def on_scale_changed():
print(scale_widget.scale(),
QgsScaleWidget.toString(scale_widget.scale()))
print(scale_widget.scaleString(),
QgsScaleWidget.toDouble(scale_widget.scaleString()))
print(scale_widget.showCurrentScaleButton())
print("Scale changed")
iface.mapCanvas().zoomScale(1 / scale_widget.scale())
def closeClicked(self):
self.animating = False
if isinstance(self.layer, QgsVectorLayer):
self.layer.setSubsetString("")
else:
self.layer.dataProvider().setDataSourceUri(self.originalUri)
iface.mapCanvas().refresh()
self.setVisible(False)
def show_features(layer, features, neighbors):
selection = []
for x in neighbors:
selection.append(features[x].id())
layer.setSelectedFeatures(selection)
box = layer.boundingBoxOfSelected()
iface.mapCanvas().setExtent(box)
iface.mapCanvas().refresh()
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 screenShot(self, imgName = 'debugScreenshot'):
'''Shoot screen.
:param imgName: Text value of the action to click on.
:type imgName: QString
:default imgName: 'debugScreenshot.png'
'''
iface.mapCanvas().saveAsImage(imgName)
def clear_plot(self):
for m in self.markers:
iface.mapCanvas().scene().removeItem(m)
self.markers = []
for rb in self.rubberbands:
iface.mapCanvas().scene().removeItem(rb)
self.rubberbands = []
self.plot.clear()
self.clear_plot_legend()
def show_features(layer, features):
selection = []
for x in features:
selection.append(x.id())
layer.setSelectedFeatures(selection)
box = layer.boundingBoxOfSelected()
box.scale(1.1)
iface.mapCanvas().setExtent(box)
iface.mapCanvas().refresh()
def processAlgorithm(self, progress):
filename = self.getParameterValue(self.INPUT)
layer = dataobjects.getObjectFromUri(filename)
style = self.getParameterValue(self.STYLE)
layer.loadNamedStyle(style)
self.setOutputValue(self.OUTPUT, filename)
iface.mapCanvas().refresh()
iface.legendInterface().refreshLayerSymbology(layer)
def OeQ_wait_for_renderer(timeout=10000):
"""Block loop until signal emitted, or timeout (ms) elapses."""
from PyQt4.QtCore import QEventLoop,QTimer
#print 'wait for renderer...',
# function call if action timed out
def timed_out(render_result_flag):
render_result_flag[0]=False
loop.quit()
#define loop
loop = QEventLoop()
#define Timer
timer=QTimer()
#define render_result
render_result = [True]
OeQ_wait(2)
#check wether Canvas is drawing
if iface.mapCanvas().isDrawing():
#connect mapCanvasRefreshed and renderComplete events to quit loop
iface.mapCanvas().renderComplete.connect(loop.quit)
iface.mapCanvas().mapCanvasRefreshed.connect(loop.quit)
# if a timeout is defined and other than 0
if bool(timeout):
# start timer
timer.singleShot(timeout,lambda: timed_out(render_result))
#and jump into the loop
loop.exec_()
#disconnect after loop has quit
iface.mapCanvas().mapCanvasRefreshed.disconnect(loop.quit)
iface.mapCanvas().renderComplete.disconnect(loop.quit)
#print 'Done'
return render_result[0]
def submit_uvc(self, table_name, form_obj, id):
result_msg = self.submit(table_name, form_obj, id)
if not result_msg == 1:
popup(str(result_msg))
return
self.db.commit()
iface.mapCanvas().currentLayer().triggerRepaint()
self.close_db()
self.uvc_form.close()
def updateExtent(self):
self.setValue(self.tool.rectangle(),
iface.mapCanvas().mapSettings().destinationCrs().authid())
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
if self.dialog:
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def setSessionProjectionFromProject(self):
"""
Set the projection from the project.
We creates a PROJ4 definition which is transmitted to Grass
"""
if not Grass7Utils.projectionSet and iface:
self.destination_crs = iface.mapCanvas().mapSettings().destinationCrs()
proj4 = iface.mapCanvas().mapSettings().destinationCrs().toProj4()
command = 'g.proj -c proj4="{}"'.format(proj4)
self.commands.append(command)
Grass7Utils.projectionSet = True
def point_at(x, y):
"""
Add a point at the x and y for the current layer
"""
x, y = float(x), float(y)
layer = iface.activeLayer()
f = QgsFeature(layer.pendingFields())
geom = QgsGeometry.fromPoint(QgsPoint(x, y))
f.setGeometry(geom)
layer.addFeature(f)
iface.mapCanvas().refresh()
def initWidgets(self): # Heavy overload
# If there are advanced parameters — show corresponding groupbox
for param in self.alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.grpAdvanced.show()
break
#widget_context = QgsProcessingParameterWidgetContext()
#if iface is not None:
# widget_context.setMapCanvas(iface.mapCanvas())
# Create widgets and put them in layouts
for param in self.alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
print('initWidgets - param.name(): {}'.format(param.name()))
if param.isDestination(): # and param.name() != 'OUTPUT_ASC':
continue
else:
wrapper = WidgetWrapperFactory.create_wrapper(param, self.parent)
self.wrappers[param.name()] = wrapper
#widget = wrapper.widget
# For compatibility with 3.x API, we need to check whether the wrapper is
# the deprecated WidgetWrapper class. If not, it's the newer
# QgsAbstractProcessingParameterWidgetWrapper class
# TODO QGIS 4.0 - remove
is_python_wrapper = issubclass(wrapper.__class__, WidgetWrapper)
if not is_python_wrapper:
from qgis.gui import (QgsProcessingContextGenerator, QgsProcessingParameterWidgetContext)
widget_context = QgsProcessingParameterWidgetContext()
if iface is not None:
widget_context.setMapCanvas(iface.mapCanvas())
wrapper.setWidgetContext(widget_context)
widget = wrapper.createWrappedWidget(self.processing_context)
wrapper.registerProcessingContextGenerator(self.context_generator)
else:
widget = wrapper.widget
#if self.in_place and param.name() in ('INPUT', 'OUTPUT'):
# don't show the input/output parameter widgets in in-place mode
# we still need to CREATE them, because other wrappers may need to interact
# with them (e.g. those parameters which need the input layer for field
# selections/crs properties/etc)
# continue
if widget is not None:
if is_python_wrapper:
widget.setToolTip(param.toolTip())
if isinstance(param, QgsProcessingParameterFeatureSource):
layout = QHBoxLayout()
layout.setSpacing(6)
layout.setMargin(0)
layout.addWidget(widget)
button = QToolButton()
icon = QIcon(os.path.join(pluginPath, 'images', 'iterate.png'))
button.setIcon(icon)
button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
button.setToolTip(self.tr('Iterate over this layer, creating a separate output for every feature in the layer'))
button.setCheckable(True)
layout.addWidget(button)
layout.setAlignment(button, Qt.AlignTop)
self.iterateButtons[param.name()] = button
button.toggled.connect(self.buttonToggled)
widget = QWidget()
widget.setLayout(layout)
label = None
if not is_python_wrapper:
label = wrapper.createWrappedLabel()
else:
label = wrapper.label
if label is not None:
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.layoutAdvanced.addWidget(label)
else:
self.layoutMain.insertWidget(
self.layoutMain.count() - 2, label)
elif is_python_wrapper:
desc = param.description()
if isinstance(param, QgsProcessingParameterExtent):
desc += self.tr(' (xmin, xmax, ymin, ymax)')
if isinstance(param, QgsProcessingParameterPoint):
desc += self.tr(' (x, y)')
if param.flags() & QgsProcessingParameterDefinition.FlagOptional:
desc += self.tr(' [optional]')
widget.setText(desc)
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.layoutAdvanced.addWidget(widget)
else:
self.layoutMain.insertWidget(
self.layoutMain.count() - 2, widget)
for output in self.alg.destinationParameterDefinitions():
if output.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
#if self.in_place and param.name() in ('INPUT', 'OUTPUT'):
# continue
label = QLabel(output.description())
#print('initWidgets 2 - param.name(): {}'.format(param.name()))
widget = DestinationSelectionPanel(output, self.alg) # TODO, overload
self.layoutMain.insertWidget(self.layoutMain.count() - 1, label)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, widget)
if isinstance(output, (QgsProcessingParameterRasterDestination,
QgsProcessingParameterFeatureSink,
QgsProcessingParameterVectorDestination
# alk: checkboxes for Chloe handling
,ChloeCSVParameterFileDestination,
ChloeASCParameterFileDestination,
ChloeParameterFolderDestination)
):
check = QCheckBox()
check.setText(QCoreApplication.translate('ParametersPanel', 'Open output file(s) after running algorithm'))
def skipOutputChanged(checkbox, skipped):
checkbox.setEnabled(not skipped)
if skipped:
checkbox.setChecked(False)
check.setChecked(not widget.outputIsSkipped())
check.setEnabled(not widget.outputIsSkipped())
widget.skipOutputChanged.connect(partial(skipOutputChanged, check))
self.layoutMain.insertWidget(self.layoutMain.count() - 1, check)
self.checkBoxes[output.name()] = check
# initial state
if hasattr(output,'addToMapDefaultState'):
check.setChecked(output.addToMapDefaultState)
widget.setToolTip(param.toolTip())
self.outputWidgets[output.name()] = widget
for wrapper in list(self.wrappers.values()):
wrapper.postInitialize(list(self.wrappers.values()))
# # alk: checkboxes for Chloe handling
# for output in self.alg.destinationParameterDefinitions():
# if output.flags() & QgsProcessingParameterDefinition.FlagHidden:
# continue
# if isinstance(output, (ChloeCSVParameterFileDestination)) or isinstance(output, (ChloeASCParameterFileDestination)):
# check = QCheckBox()
# check.setText(QCoreApplication.translate('ParametersPanel', 'Open output file(s) after running algorithm'))
# def skipOutputChanged(checkbox, skipped):
# checkbox.setEnabled(not skipped)
# if skipped:
# checkbox.setChecked(False)
# check.setChecked(not widget.outputIsSkipped())
# check.setEnabled(not widget.outputIsSkipped())
# widget.skipOutputChanged.connect(partial(skipOutputChanged, check))
# print(str(self.layoutMain)+1)
# self.layoutMain.insertWidget(self.layoutMain.count() - 1, check)
# self.checkBoxes[output.name()] = check
# # connecting alg outputLoading info with checkbox state
# self.alg.outputLoading[output.name()] = check.isChecked()
# def updateOutputLoadingState(alg, outputName, checkbox, state):
# self.alg.outputLoading[outputName] = checkbox.isChecked()
# print( outputName + " " + str(checkbox.isChecked()) + " " + str(self.alg.outputLoading) + " " + str(self.alg))
# #print(str(self.alg.parameters))
# check.stateChanged.connect(partial(updateOutputLoadingState, self, output.name(), check))
# alk: addition of wrapper special config handling
# for dependancy between wrapper, i.e. changing the value
# of a FileSelectionPanel entails the update of another widget
for k in self.wrappers:
w = self.wrappers[k]
if hasattr(w,'getParentWidgetConfig'):
print(str(w) + " " + "getParentWidgetConfig")
config = w.getParentWidgetConfig()
if config != None:
p = self.wrappers[config['paramName']]
m = getattr(w, config['refreshMethod'])
if m!=None:
print(str(p) + " " + str(p.widget))
# todo generalize valueChanged handling
# to any type of widget componant
if isinstance(p.widget, FileSelectionPanel):
p.widget.leText.textChanged.connect(m)
elif isinstance(p, RasterWidgetWrapper):
try:
p.combo.valueChanged.connect(m) # QGIS 3.8 version
except:
p.combo.currentIndexChanged.connect(m) # QGIS LTR 3.4
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
method = self.getParameterValue(self.METHOD)
geometryType = layer.geometryType()
fields = layer.fields()
export_z = False
export_m = False
if geometryType == QgsWkbTypes.PolygonGeometry:
areaName = vector.createUniqueFieldName('area', fields)
fields.append(QgsField(areaName, QVariant.Double))
perimeterName = vector.createUniqueFieldName('perimeter', fields)
fields.append(QgsField(perimeterName, QVariant.Double))
elif geometryType == QgsWkbTypes.LineGeometry:
lengthName = vector.createUniqueFieldName('length', fields)
fields.append(QgsField(lengthName, QVariant.Double))
else:
xName = vector.createUniqueFieldName('xcoord', fields)
fields.append(QgsField(xName, QVariant.Double))
yName = vector.createUniqueFieldName('ycoord', fields)
fields.append(QgsField(yName, QVariant.Double))
if QgsWkbTypes.hasZ(layer.wkbType()):
export_z = True
zName = vector.createUniqueFieldName('zcoord', fields)
fields.append(QgsField(zName, QVariant.Double))
if QgsWkbTypes.hasM(layer.wkbType()):
export_m = True
zName = vector.createUniqueFieldName('mvalue', fields)
fields.append(QgsField(zName, QVariant.Double))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields.toList(), layer.wkbType(), layer.crs())
ellips = None
crs = None
coordTransform = None
# Calculate with:
# 0 - layer CRS
# 1 - project CRS
# 2 - ellipsoidal
if method == 2:
ellips = QgsProject.instance().readEntry('Measure', '/Ellipsoid',
'NONE')[0]
crs = layer.crs().srsid()
elif method == 1:
mapCRS = iface.mapCanvas().mapSettings().destinationCrs()
layCRS = layer.crs()
coordTransform = QgsCoordinateTransform(layCRS, mapCRS)
outFeat = QgsFeature()
inGeom = QgsGeometry()
outFeat.initAttributes(len(fields))
outFeat.setFields(fields)
features = vector.features(layer)
total = 100.0 / len(features)
for current, f in enumerate(features):
inGeom = f.geometry()
if method == 1:
inGeom.transform(coordTransform)
(attr1, attr2) = vector.simpleMeasure(inGeom, method, ellips, crs)
outFeat.setGeometry(inGeom)
attrs = f.attributes()
attrs.append(attr1)
if attr2 is not None:
attrs.append(attr2)
# add point z/m
if export_z:
attrs.append(inGeom.geometry().z())
if export_m:
attrs.append(inGeom.geometry().m())
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
progress.setPercentage(int(current * total))
del writer
from qgis.utils import iface
lyrPts = QgsVectorLayer(
"/home/abhishek/MSc.GIS/MSCities_Geo_Pts/MSCities_Geo_Pts.shp",
"MSCities_Geo_Pts", "ogr")
QgsProject.instance().addMapLayers([lyrPts])
selection = lyrPts.getFeatures(
QgsFeatureRequest().setFilterExpression(u'"PLACEFP10" = 81520'))
lyrPts.selectByIds([s.id() for s in selection])
iface.mapCanvas().zoomToSelected()
iface.mapCanvas().refresh()
def _changeSize():
layer = _layerFromName("2525")
r = layer.renderer()
r.size = 80
layer.triggerRepaint()
iface.mapCanvas().setExtent(layer.extent())
def showEvent(self, event):
# Cannot do that in the constructor. The project is not fully setup when
# it is called
if not self.srsSelectionWidget.crs().isValid():
self.srsSelectionWidget.setCrs(iface.mapCanvas().mapSettings().destinationCrs())
BASE.showEvent(self, event)
def executeAlgorithm(self):
config = {}
if self.in_place_mode:
config['IN_PLACE'] = True
alg = self.algorithmTree.selectedAlgorithm().create(
config) if self.algorithmTree.selectedAlgorithm(
) is not None else None
if alg is not None:
ok, message = alg.canExecute()
if not ok:
dlg = MessageDialog()
dlg.setTitle(self.tr('Error executing algorithm'))
dlg.setMessage(
self.tr('<h3>This algorithm cannot '
'be run :-( </h3>\n{0}').format(message))
dlg.exec_()
return
in_place_input_parameter_name = 'INPUT'
if hasattr(alg, 'inputParameterName'):
in_place_input_parameter_name = alg.inputParameterName()
if self.in_place_mode and not [
d for d in alg.parameterDefinitions() if d.name() not in
(in_place_input_parameter_name, 'OUTPUT')
]:
parameters = {}
feedback = MessageBarProgress(algname=alg.displayName())
ok, results = execute_in_place(alg,
parameters,
feedback=feedback)
if ok:
iface.messageBar().pushSuccess(
'',
self.tr(
'{algname} completed. %n feature(s) processed.',
n=results['__count']).format(
algname=alg.displayName()))
feedback.close()
# MessageBarProgress handles errors
return
if alg.countVisibleParameters() > 0:
dlg = alg.createCustomParametersWidget(self)
if not dlg:
dlg = AlgorithmDialog(alg, self.in_place_mode,
iface.mainWindow())
canvas = iface.mapCanvas()
prevMapTool = canvas.mapTool()
dlg.show()
dlg.exec_()
if canvas.mapTool() != prevMapTool:
try:
canvas.mapTool().reset()
except:
pass
canvas.setMapTool(prevMapTool)
else:
feedback = MessageBarProgress(algname=alg.displayName())
context = dataobjects.createContext(feedback)
parameters = {}
ret, results = execute(alg, parameters, context, feedback)
handleAlgorithmResults(alg, context, feedback)
feedback.close()
def initWidgets(self):
# If there are advanced parameters — show corresponding groupbox
for param in self.alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.grpAdvanced.show()
break
widget_context = QgsProcessingParameterWidgetContext()
if iface is not None:
widget_context.setMapCanvas(iface.mapCanvas())
# Create widgets and put them in layouts
for param in self.alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
if param.isDestination():
continue
else:
wrapper = WidgetWrapperFactory.create_wrapper(param, self.parent)
self.wrappers[param.name()] = wrapper
# For compatibility with 3.x API, we need to check whether the wrapper is
# the deprecated WidgetWrapper class. If not, it's the newer
# QgsAbstractProcessingParameterWidgetWrapper class
# TODO QGIS 4.0 - remove
is_python_wrapper = issubclass(wrapper.__class__, WidgetWrapper)
if not is_python_wrapper:
wrapper.setWidgetContext(widget_context)
widget = wrapper.createWrappedWidget(self.processing_context)
wrapper.registerProcessingContextGenerator(self.context_generator)
else:
widget = wrapper.widget
if self.in_place and param.name() in ('INPUT', 'OUTPUT'):
# don't show the input/output parameter widgets in in-place mode
# we still need to CREATE them, because other wrappers may need to interact
# with them (e.g. those parameters which need the input layer for field
# selections/crs properties/etc)
continue
if widget is not None:
if is_python_wrapper:
widget.setToolTip(param.toolTip())
if isinstance(param, QgsProcessingParameterFeatureSource):
layout = QHBoxLayout()
layout.setSpacing(6)
layout.setMargin(0)
layout.addWidget(widget)
button = QToolButton()
icon = QIcon(os.path.join(pluginPath, 'images', 'iterate.png'))
button.setIcon(icon)
button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
button.setToolTip(self.tr('Iterate over this layer, creating a separate output for every feature in the layer'))
button.setCheckable(True)
layout.addWidget(button)
layout.setAlignment(button, Qt.AlignTop)
self.iterateButtons[param.name()] = button
button.toggled.connect(self.buttonToggled)
widget = QWidget()
widget.setLayout(layout)
label = None
if not is_python_wrapper:
label = wrapper.createWrappedLabel()
else:
label = wrapper.label
if label is not None:
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.layoutAdvanced.addWidget(label)
else:
self.layoutMain.insertWidget(
self.layoutMain.count() - 2, label)
elif is_python_wrapper:
desc = param.description()
if isinstance(param, QgsProcessingParameterExtent):
desc += self.tr(' (xmin, xmax, ymin, ymax)')
if isinstance(param, QgsProcessingParameterPoint):
desc += self.tr(' (x, y)')
if param.flags() & QgsProcessingParameterDefinition.FlagOptional:
desc += self.tr(' [optional]')
widget.setText(desc)
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.layoutAdvanced.addWidget(widget)
else:
self.layoutMain.insertWidget(
self.layoutMain.count() - 2, widget)
for output in self.alg.destinationParameterDefinitions():
if output.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
if self.in_place and param.name() in ('INPUT', 'OUTPUT'):
continue
label = QLabel(output.description())
widget = DestinationSelectionPanel(output, self.alg)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, label)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, widget)
if isinstance(output, (QgsProcessingParameterRasterDestination, QgsProcessingParameterFeatureSink, QgsProcessingParameterVectorDestination)):
check = QCheckBox()
check.setText(QCoreApplication.translate('ParametersPanel', 'Open output file after running algorithm'))
def skipOutputChanged(checkbox, skipped):
checkbox.setEnabled(not skipped)
if skipped:
checkbox.setChecked(False)
check.setChecked(not widget.outputIsSkipped())
check.setEnabled(not widget.outputIsSkipped())
widget.skipOutputChanged.connect(partial(skipOutputChanged, check))
self.layoutMain.insertWidget(self.layoutMain.count() - 1, check)
self.checkBoxes[output.name()] = check
widget.setToolTip(param.toolTip())
self.outputWidgets[output.name()] = widget
for wrapper in list(self.wrappers.values()):
wrapper.postInitialize(list(self.wrappers.values()))
def pointPicked(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
fields = layer.fields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs())
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp.setGeomCalculator(da)
exp.setDistanceUnits(QgsProject.instance().distanceUnits())
exp.setAreaUnits(QgsProject.instance().areaUnits())
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
if not exp.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % exp.evalErrorString()))
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
features = vector.features(layer)
total = 100.0 / len(features)
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp_context.setFeature(f)
exp_context.lastScope().setVariable("row_number", rownum)
value = exp.evaluate(exp_context)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature)
progress.setPercentage(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation '
'string:\n%s' % error))
def executeAlgorithm(self, alg_id, parent, in_place=False, as_batch=False):
"""Executes a project model with GUI interaction if needed.
:param alg_id: algorithm id
:type alg_id: string
:param parent: parent widget
:type parent: QWidget
:param in_place: in place flag, defaults to False
:type in_place: bool, optional
:param as_batch: execute as batch flag, defaults to False
:type as_batch: bool, optional
"""
config = {}
if in_place:
config['IN_PLACE'] = True
alg = QgsApplication.instance().processingRegistry(
).createAlgorithmById(alg_id, config)
if alg is not None:
ok, message = alg.canExecute()
if not ok:
dlg = MessageDialog()
dlg.setTitle(self.tr('Error executing algorithm'))
dlg.setMessage(
self.tr('<h3>This algorithm cannot '
'be run :-( </h3>\n{0}').format(message))
dlg.exec_()
return
if as_batch:
dlg = BatchAlgorithmDialog(alg, iface.mainWindow())
dlg.setAttribute(Qt.WA_DeleteOnClose)
dlg.show()
dlg.exec_()
else:
in_place_input_parameter_name = 'INPUT'
if hasattr(alg, 'inputParameterName'):
in_place_input_parameter_name = alg.inputParameterName()
if in_place and not [
d
for d in alg.parameterDefinitions() if d.name() not in
(in_place_input_parameter_name, 'OUTPUT')
]:
parameters = {}
feedback = MessageBarProgress(algname=alg.displayName())
ok, results = execute_in_place(alg,
parameters,
feedback=feedback)
if ok:
iface.messageBar().pushSuccess(
'',
self.
tr('{algname} completed. %n feature(s) processed.',
n=results['__count']).format(
algname=alg.displayName()))
feedback.close()
# MessageBarProgress handles errors
return
if alg.countVisibleParameters() > 0:
dlg = alg.createCustomParametersWidget(parent)
if not dlg:
dlg = AlgorithmDialog(alg, in_place,
iface.mainWindow())
canvas = iface.mapCanvas()
prevMapTool = canvas.mapTool()
dlg.show()
dlg.exec_()
if canvas.mapTool() != prevMapTool:
try:
canvas.mapTool().reset()
except Exception:
pass
canvas.setMapTool(prevMapTool)
else:
feedback = MessageBarProgress(algname=alg.displayName())
context = dataobjects.createContext(feedback)
parameters = {}
ret, results = execute(alg, parameters, context, feedback)
handleAlgorithmResults(alg, context, feedback)
feedback.close()
def processAlgorithm(self, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(
self.getParameterValue(self.INPUT_VECTOR), context)
startPoint = self.getParameterValue(self.START_POINT)
endPoint = self.getParameterValue(self.END_POINT)
strategy = self.getParameterValue(self.STRATEGY)
directionFieldName = self.getParameterValue(self.DIRECTION_FIELD)
forwardValue = self.getParameterValue(self.VALUE_FORWARD)
backwardValue = self.getParameterValue(self.VALUE_BACKWARD)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
speedFieldName = self.getParameterValue(self.SPEED_FIELD)
defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED)
tolerance = self.getParameterValue(self.TOLERANCE)
fields = QgsFields()
fields.append(QgsField('start', QVariant.String, '', 254, 0))
fields.append(QgsField('end', QVariant.String, '', 254, 0))
fields.append(QgsField('cost', QVariant.Double, '', 20, 7))
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
fields, QgsWkbTypes.LineString, layer.crs(), context)
tmp = startPoint.split(',')
startPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
tmp = endPoint.split(',')
endPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
directionField = -1
if directionFieldName is not None:
directionField = layer.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName is not None:
speedField = layer.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(layer, directionField, forwardValue,
backwardValue, bothValue,
defaultDirection)
distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(
distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed,
multiplier * 1000.0 / 3600.0)
multiplier = 3600
director.addStrategy(strategy)
builder = QgsGraphBuilder(
iface.mapCanvas().mapSettings().destinationCrs(), True, tolerance)
feedback.pushInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, [startPoint, endPoint])
feedback.pushInfo(self.tr('Calculating shortest path...'))
graph = builder.graph()
idxStart = graph.findVertex(snappedPoints[0])
idxEnd = graph.findVertex(snappedPoints[1])
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
if tree[idxEnd] == -1:
raise GeoAlgorithmExecutionException(
self.tr('There is no route from start point to end point.'))
route = []
cost = 0.0
current = idxEnd
while current != idxStart:
cost += graph.edge(tree[current]).cost(0)
route.append(
graph.vertex(graph.edge(tree[current]).inVertex()).point())
current = graph.edge(tree[current]).outVertex()
route.append(snappedPoints[0])
route.reverse()
self.setOutputValue(self.TRAVEL_COST, cost / multiplier)
feedback.pushInfo(self.tr('Writing results...'))
geom = QgsGeometry.fromPolyline(route)
feat = QgsFeature()
feat.setFields(fields)
feat['start'] = startPoint.toString()
feat['end'] = endPoint.toString()
feat['cost'] = cost / multiplier
feat.setGeometry(geom)
writer.addFeature(feat)
del writer
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_VECTOR))
startPoints = dataobjects.getObjectFromUri(
self.getParameterValue(self.START_POINTS))
strategy = self.getParameterValue(self.STRATEGY)
travelCost = self.getParameterValue(self.TRAVEL_COST)
directionFieldName = self.getParameterValue(self.DIRECTION_FIELD)
forwardValue = self.getParameterValue(self.VALUE_FORWARD)
backwardValue = self.getParameterValue(self.VALUE_BACKWARD)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
speedFieldName = self.getParameterValue(self.SPEED_FIELD)
defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED)
tolerance = self.getParameterValue(self.TOLERANCE)
fields = QgsFields()
fields.append(QgsField('type', QVariant.String, '', 254, 0))
fields.append(QgsField('start', QVariant.String, '', 254, 0))
feat = QgsFeature()
feat.setFields(fields)
writerPoints = self.getOutputFromName(
self.OUTPUT_POINTS).getVectorWriter(fields, QgsWkbTypes.MultiPoint,
layer.crs())
writerPolygons = self.getOutputFromName(
self.OUTPUT_POLYGON).getVectorWriter(fields, QgsWkbTypes.Polygon,
layer.crs())
directionField = -1
if directionFieldName is not None:
directionField = layer.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName is not None:
speedField = layer.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(layer, directionField, forwardValue,
backwardValue, bothValue,
defaultDirection)
distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(
distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed,
multiplier * 1000.0 / 3600.0)
director.addStrategy(strategy)
builder = QgsGraphBuilder(
iface.mapCanvas().mapSettings().destinationCrs(),
iface.mapCanvas().hasCrsTransformEnabled(), tolerance)
progress.setInfo(self.tr('Loading start points...'))
request = QgsFeatureRequest()
request.setFlags(request.flags()
^ QgsFeatureRequest.SubsetOfAttributes)
features = vector.features(startPoints, request)
points = []
for f in features:
points.append(f.geometry().asPoint())
progress.setInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, points)
progress.setInfo(self.tr('Calculating service areas...'))
graph = builder.graph()
vertices = []
upperBoundary = []
lowerBoundary = []
total = 100.0 / len(snappedPoints)
for i, p in enumerate(snappedPoints):
idxStart = graph.findVertex(snappedPoints[i])
origPoint = points[i].toString()
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
for j, v in enumerate(cost):
if v > travelCost and tree[j] != -1:
vertexId = graph.edge(tree[j]).outVertex()
if cost[vertexId] <= travelCost:
vertices.append(j)
for j in vertices:
upperBoundary.append(
graph.vertex(graph.edge(tree[j]).inVertex()).point())
lowerBoundary.append(
graph.vertex(graph.edge(tree[j]).outVertex()).point())
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
feat.setGeometry(geomUpper)
feat['type'] = 'upper'
feat['start'] = origPoint
writerPoints.addFeature(feat)
feat.setGeometry(geomLower)
feat['type'] = 'lower'
feat['start'] = origPoint
writerPoints.addFeature(feat)
upperBoundary.append(startPoint)
lowerBoundary.append(startPoint)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
geom = geomUpper.convexHull()
feat.setGeometry(geom)
feat['type'] = 'upper'
feat['start'] = origPoint
writerPolygons.addFeature(feat)
geom = geomLower.convexHull()
feat.setGeometry(geom)
feat['type'] = 'lower'
feat['start'] = origPoint
writerPolygons.addFeature(feat)
vertices[:] = []
upperBoundary[:] = []
lowerBoundary[:] = []
progress.setPercentage(int(i * total))
del writerPoints
del writerPolygons
def initWidgets(self):
super().initWidgets()
widget_context = QgsProcessingParameterWidgetContext()
widget_context.setProject(QgsProject.instance())
if iface is not None:
widget_context.setMapCanvas(iface.mapCanvas())
widget_context.setBrowserModel(iface.browserModel())
widget_context.setActiveLayer(iface.activeLayer())
widget_context.setMessageBar(self.parent().messageBar())
if isinstance(self.algorithm(), QgsProcessingModelAlgorithm):
widget_context.setModel(self.algorithm())
# Create widgets and put them in layouts
for param in self.algorithm().parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
if param.isDestination():
continue
else:
wrapper = WidgetWrapperFactory.create_wrapper(
param, self.parent())
wrapper.setWidgetContext(widget_context)
wrapper.registerProcessingContextGenerator(
self.context_generator)
self.wrappers[param.name()] = wrapper
# For compatibility with 3.x API, we need to check whether the wrapper is
# the deprecated WidgetWrapper class. If not, it's the newer
# QgsAbstractProcessingParameterWidgetWrapper class
# TODO QGIS 4.0 - remove
is_python_wrapper = issubclass(wrapper.__class__,
WidgetWrapper)
if not is_python_wrapper:
widget = wrapper.createWrappedWidget(
self.processing_context)
else:
widget = wrapper.widget
if self.in_place and param.name() in ('INPUT', 'OUTPUT'):
# don't show the input/output parameter widgets in in-place mode
# we still need to CREATE them, because other wrappers may need to interact
# with them (e.g. those parameters which need the input layer for field
# selections/crs properties/etc)
continue
if widget is not None:
if is_python_wrapper:
widget.setToolTip(param.toolTip())
label = None
if not is_python_wrapper:
label = wrapper.createWrappedLabel()
else:
label = wrapper.label
if label is not None:
self.addParameterLabel(param, label)
elif is_python_wrapper:
desc = param.description()
if isinstance(param, QgsProcessingParameterExtent):
desc += self.tr(' (xmin, xmax, ymin, ymax)')
if param.flags(
) & QgsProcessingParameterDefinition.FlagOptional:
desc += self.tr(' [optional]')
widget.setText(desc)
self.addParameterWidget(param, widget)
for output in self.algorithm().destinationParameterDefinitions():
if output.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
if self.in_place and output.name() in ('INPUT', 'OUTPUT'):
continue
wrapper = QgsGui.processingGuiRegistry(
).createParameterWidgetWrapper(output, QgsProcessingGui.Standard)
wrapper.setWidgetContext(widget_context)
wrapper.registerProcessingContextGenerator(self.context_generator)
self.wrappers[output.name()] = wrapper
label = wrapper.createWrappedLabel()
if label is not None:
self.addOutputLabel(label)
widget = wrapper.createWrappedWidget(self.processing_context)
self.addOutputWidget(widget)
# def skipOutputChanged(widget, checkbox, skipped):
# TODO
# enabled = not skipped
#
# # Do not try to open formats that are write-only.
# value = widget.value()
# if value and isinstance(value, QgsProcessingOutputLayerDefinition) and isinstance(output, (
# QgsProcessingParameterFeatureSink, QgsProcessingParameterVectorDestination)):
# filename = value.sink.staticValue()
# if filename not in ('memory:', ''):
# path, ext = os.path.splitext(filename)
# format = QgsVectorFileWriter.driverForExtension(ext)
# drv = gdal.GetDriverByName(format)
# if drv:
# if drv.GetMetadataItem(gdal.DCAP_OPEN) is None:
# enabled = False
#
# checkbox.setEnabled(enabled)
# checkbox.setChecked(enabled)
for wrapper in list(self.wrappers.values()):
wrapper.postInitialize(list(self.wrappers.values()))
writer.addFeature(outFeat)
i += 1
del writer
layer = processing.getObject(morans_output)
print layer.name()
classes = [0, 1, 2, 3, 4]
labels = ["not. sig", "HH", "LH", "LL", "HL"]
colors = ["#FFFFFF", "#CC0000", "#66CCFF", "#000099", "#F5CCCC"]
quads = {}
for i in classes:
quads[i] = (colors[i], labels[i])
categories = []
for quad, (color, label) in quads.items():
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
symbol.setColor(QtGui.QColor(color))
category = QgsRendererCategoryV2(quad, symbol, label)
categories.append(category)
expression = "MORANS_C"
renderer = QgsCategorizedSymbolRendererV2(expression, categories)
layer.setRendererV2(renderer)
QgsMapLayerRegistry.instance().addMapLayer(layer)
iface.mapCanvas().refresh()
iface.legendInterface().refreshLayerSymbology(layer)
iface.mapCanvas().refresh()
def processAlgorithm(self, progress):
layer = self.getParameterValue(self.INPUT_LAYER)
mapping = self.getParameterValue(self.FIELDS_MAPPING)
output = self.getOutputFromName(self.OUTPUT_LAYER)
layer = dataobjects.getObjectFromUri(layer)
fields = []
expressions = []
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
for field_def in mapping:
fields.append(
QgsField(name=field_def['name'],
type=field_def['type'],
len=field_def['length'],
prec=field_def['precision']))
expression = QgsExpression(field_def['expression'])
expression.setGeomCalculator(da)
expression.setDistanceUnits(QgsProject.instance().distanceUnits())
expression.setAreaUnits(QgsProject.instance().areaUnits())
if expression.hasParserError():
raise GeoAlgorithmExecutionException(
self.tr(u'Parser error in expression "{}": {}').format(
str(field_def['expression']),
str(expression.parserErrorString())))
expression.prepare(exp_context)
if expression.hasEvalError():
raise GeoAlgorithmExecutionException(
self.tr(u'Evaluation error in expression "{}": {}').format(
str(field_def['expression']),
str(expression.evalErrorString())))
expressions.append(expression)
writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs())
# Create output vector layer with new attributes
error = ''
calculationSuccess = True
inFeat = QgsFeature()
outFeat = QgsFeature()
features = vector.features(layer)
total = 100.0 / len(features)
for current, inFeat in enumerate(features):
rownum = current + 1
geometry = inFeat.geometry()
outFeat.setGeometry(geometry)
attrs = []
for i in range(0, len(mapping)):
field_def = mapping[i]
expression = expressions[i]
exp_context.setFeature(inFeat)
exp_context.lastScope().setVariable("row_number", rownum)
value = expression.evaluate(exp_context)
if expression.hasEvalError():
calculationSuccess = False
error = expression.evalErrorString()
break
attrs.append(value)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
progress.setPercentage(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation'
' string:\n') + error)
def run(self):
"""Run method that loads and starts the plugin"""
if not iface.building_toolbar:
# Set up toolbar
iface.building_toolbar = QToolBar(u"Building Tools")
iface.addToolBar(iface.building_toolbar, Qt.RightToolBarArea)
# Create the dockwidget and dialog and keep reference
if not self.dockwidget:
self.dockwidget = BuildingsDockwidget()
# Connect with close
self.dockwidget.closed.connect(self.on_dockwidget_closed)
# Show the dockwidget as a tab
layerdock = iface.mainWindow().findChild(QDockWidget, "Layers")
iface.addDockWidget(Qt.LeftDockWidgetArea, self.dockwidget)
iface.mainWindow().tabifyDockWidget(layerdock, self.dockwidget)
self.setup_main_toolbar()
dw = self.dockwidget
# no base layers
self.menu_frame = MenuFrame(self.dockwidget)
dw.insert_into_frames("menu_frame", self.menu_frame)
home_dir = os.path.dirname(__file__)
if dw.lst_options.item(0) is None:
icon_path = os.path.join(home_dir, "icons",
"buildings_plugin.png")
item = QListWidgetItem("Buildings")
item.setIcon(QIcon(icon_path))
dw.lst_options.addItem(item)
dw.lst_options.setCurrentItem(item)
icon_path = os.path.join(home_dir, "icons", "capture_source.png")
item = QListWidgetItem("Capture Sources")
item.setIcon(QIcon(icon_path))
dw.lst_sub_menu.addItem(item)
icon_path = os.path.join(home_dir, "icons", "bulk_load.png")
item = QListWidgetItem("Bulk Load")
item.setIcon(QIcon(icon_path))
dw.lst_sub_menu.addItem(item)
icon_path = os.path.join(home_dir, "icons", "edit.png")
item = QListWidgetItem("Edit Outlines")
item.setIcon(QIcon(icon_path))
dw.lst_sub_menu.addItem(item)
icon_path = os.path.join(home_dir, "icons", "settings.png")
item = QListWidgetItem("Settings")
item.setIcon(QIcon(icon_path))
dw.lst_sub_menu.addItem(item)
icon_path = os.path.join(home_dir, "icons", "reference.png")
item = QListWidgetItem("Reference Data")
item.setIcon(QIcon(icon_path))
dw.lst_sub_menu.addItem(item)
canvas = iface.mapCanvas()
selectedcrs = "EPSG:2193"
target_crs = QgsCoordinateReferenceSystem()
target_crs.createFromUserInput(selectedcrs)
canvas.setDestinationCrs(target_crs)
self.on_click()
self.dockwidget.show()
self.dockwidget.raise_()
def processAlgorithm(self, parameters, context, feedback):
self.feature_source = self.parameterAsSource(parameters, self.INPUT,
context)
raster_lyr = self.parameterAsRasterLayer(parameters, self.RASTER_INPUT,
context)
all_rasters = self.parameterAsBool(parameters, self.ALL_ACTIVE_RASTERS,
context)
temp_path = self.parameterAsString(parameters, '', context)
self.dest_field = self.parameterAsString(parameters, self.FIELD,
context)
psm = self.parameterAsInt(parameters, 'PSM', context)
oem = self.parameterAsInt(parameters, 'OEM', context)
self.comma = self.parameterAsBool(parameters, 'Remove_comma', context)
(self.sink,
dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
self.feature_source.fields(),
self.feature_source.wkbType(),
self.feature_source.sourceCrs())
self.source_layer = self.feature_source.materialize(
QgsFeatureRequest())
feedback.pushInfo('Temporary files path: ' + str(temp_path))
self.source_encod = self.source_layer.dataProvider().encoding()
'''context.setDefaultEncoding(self.source_encod)
self.output_encod = context.defaultEncoding()
feedback.pushInfo('sys.getdefaultencoding(): ' + sys.getdefaultencoding())
feedback.pushInfo('in: ' + self.source_encod + ', out: ' + self.output_encod)'''
if self.source_layer == None:
list = QgsProject.instance().mapLayersByName(
self.feature_source.sourceName())
for lyr in list:
if self.feature_source.sourceCrs() == lyr.sourceCrs():
self.source_layer = lyr
#feedback.pushInfo('self.source_layer.name(): ' + self.source_layer.name())
if self.feature_source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
if raster_lyr is None and not all_rasters:
feedback.pushInfo('\nNo raster layer selected!\n')
raise QgsProcessingException(
self.invalidSourceError(parameters, self.RASTER_INPUT))
self.output_temp_tif = os.path.normpath(
os.path.join(temp_path, 'output.tif'))
self.output_temp_shp = os.path.normpath(
os.path.join(temp_path, 'each_feature.shp'))
self.output_temp_page = os.path.normpath(
os.path.join(temp_path, 'current_page.tif'))
'''here is tesseract config string'''
self.config = '--psm ' + str(psm) + ' --oem ' + str(oem)
feedback.pushInfo('Tessearct config: ' + self.config)
'''creating temporary shp file, necessary for clipping'''
self.crs = self.feature_source.sourceCrs().authid()
layer = QgsVectorLayer(
"multipolygon?crs=" + self.crs + "&field=id:integer",
"temporary layer", "memory")
QgsVectorFileWriter.writeAsVectorFormat(
layer, self.output_temp_shp, self.source_encod,
self.feature_source.sourceCrs(), "ESRI Shapefile", False)
self.temp_shp_layer = QgsVectorLayer(self.output_temp_shp, "temp",
"ogr")
features = self.feature_source.getFeatures(QgsFeatureRequest())
self.index = QgsSpatialIndex()
for feat in features:
self.index.insertFeature(feat)
feedback.pushInfo('\nprocessing time calculating...\n')
n = []
if not all_rasters and raster_lyr:
n = self.index.intersects(raster_lyr.extent())
else:
for layer in iface.mapCanvas().layers():
if layer.type() == 1:
n = n + self.index.intersects(layer.extent())
self.total = len(n)
self.actual = 0
if self.total > 0: feedback.setProgress(self.actual / self.total * 100)
if not all_rasters:
self.OnThisRaster(feedback, raster_lyr)
else:
for layer in iface.mapCanvas().layers():
if feedback.isCanceled(): break
if layer.type() == 1:
self.OnThisRaster(feedback, layer)
return {self.OUTPUT: dest_id}
def create_point_layer(self):
""" Create an temporary point layer in the Qgis canvas """
try:
QApplication.setOverrideCursor(Qt.WaitCursor) ## Start the 'wait' cursor
if self.list_points:
# create layer
vl = QgsVectorLayer("Point?crs=" + self.selected_epsg, self.layer_name, "memory")
pr = vl.dataProvider()
# add fields
pr.addAttributes([QgsField("id_point", QVariant.Int),
QgsField("nom", QVariant.String),
QgsField("pfp", QVariant.Int),
QgsField("pfa", QVariant.Int),
QgsField("ty", QVariant.String),
QgsField("date_rep", QVariant.String),
QgsField("ordre", QVariant.String),
QgsField("num_carte", QVariant.String),
QgsField("coordY", QVariant.Double, "double", 12, 4),
QgsField("coordX", QVariant.Double, "double", 12, 4),
QgsField("coord_prov", QVariant.String),
QgsField("altitudeH", QVariant.Double, "double", 10, 4),
QgsField("altitude_prov", QVariant.String),
QgsField("coord_code", QVariant.String),
QgsField("geoide_cote", QVariant.String),
QgsField("geoide_prov", QVariant.String),
QgsField("ellips_code", QVariant.String),
QgsField("dev_vert_ETA", QVariant.String),
QgsField("dev_vert_XI", QVariant.String),
QgsField("dev_vert_prov", QVariant.String),
QgsField("dev_vert_ETA0", QVariant.String),
QgsField("dev_vert_XI0", QVariant.String),
QgsField("dev_vert_prov0", QVariant.String),
QgsField("code_raumtri", QVariant.String),
QgsField("num_cont", QVariant.String),
QgsField("flag_gps", QVariant.String),
QgsField("num_sess_gps", QVariant.String),
QgsField("num_zone", QVariant.String),
QgsField("reserve", QVariant.String)])
vl.updateFields() # tell the vector layer to fetch changes from the provider
# add features
for item in self.list_points:
pos_y = float(item[8])
pos_x = float(item[9])
fet = QgsFeature()
fet.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(pos_y,pos_x)))
fet.setAttributes(list(item))
pr.addFeatures([fet])
# add preconfigured qgis.qml style file
plugin_folder = os.path.dirname(os.path.dirname(__file__))
qml_file = Path(plugin_folder) / "qml" / self.qml_style_point
if qml_file.is_file(): # Test if file exist, avoid error if he is missing
vl.loadNamedStyle(str(qml_file))
# update layer's extent when new features have been added
vl.updateExtents()
# zoom to the layer extent
if self.zoom:
canvas = iface.mapCanvas()
canvas.setExtent(vl.extent())
# Show in project
self.rmv_old_qgs_point_layer()
QgsProject.instance().addMapLayer(vl)
except:
QApplication.restoreOverrideCursor() ## Stop the 'wait' cursor
print("Point -> Failed to create a new Qgis point layer (def create_point_layer)")
finally:
QApplication.restoreOverrideCursor() ## Stop the 'wait' cursor
def setupUi(self):
self.checkBoxes = {}
self.showAdvanced = False
self.wrappers = {}
self.valueItems = {}
self.dependentItems = {}
self.algorithmItem = None
self.resize(650, 450)
self.buttonBox = QDialogButtonBox()
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok
| QDialogButtonBox.Help)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setSpacing(5)
self.verticalLayout.setMargin(20)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.verticalLayout.addWidget(self.bar)
hLayout = QHBoxLayout()
hLayout.setSpacing(5)
hLayout.setMargin(0)
descriptionLabel = QLabel(self.tr("Description"))
self.descriptionBox = QLineEdit()
self.descriptionBox.setText(self._alg.displayName())
hLayout.addWidget(descriptionLabel)
hLayout.addWidget(self.descriptionBox)
self.verticalLayout.addLayout(hLayout)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
self.verticalLayout.addWidget(line)
self.algorithmItem = QgsGui.instance().processingGuiRegistry(
).algorithmConfigurationWidget(self._alg)
if self.configuration:
self.algorithmItem.setConfiguration(self.configuration)
self.verticalLayout.addWidget(self.algorithmItem)
widget_context = QgsProcessingParameterWidgetContext()
if iface is not None:
widget_context.setMapCanvas(iface.mapCanvas())
widget_context.setModel(self.model)
widget_context.setModelChildAlgorithmId(self.childId)
for param in self._alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.advancedButton = QPushButton()
self.advancedButton.setText(
self.tr('Show advanced parameters'))
self.advancedButton.clicked.connect(
self.showAdvancedParametersClicked)
advancedButtonHLayout = QHBoxLayout()
advancedButtonHLayout.addWidget(self.advancedButton)
advancedButtonHLayout.addStretch()
self.verticalLayout.addLayout(advancedButtonHLayout)
break
for param in self._alg.parameterDefinitions():
if param.isDestination(
) or param.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
wrapper = WidgetWrapperFactory.create_wrapper(param, self)
self.wrappers[param.name()] = wrapper
if issubclass(wrapper.__class__,
QgsProcessingModelerParameterWidget):
wrapper.setWidgetContext(widget_context)
wrapper.registerProcessingContextGenerator(
self.context_generator)
widget = wrapper
else:
widget = wrapper.widget
if widget is not None:
self.valueItems[param.name()] = widget
if issubclass(wrapper.__class__,
QgsProcessingModelerParameterWidget):
label = wrapper.createLabel()
else:
tooltip = param.description()
widget.setToolTip(tooltip)
label = wrapper.label
self.widget_labels[param.name()] = label
if param.flags(
) & QgsProcessingParameterDefinition.FlagAdvanced:
label.setVisible(self.showAdvanced)
widget.setVisible(self.showAdvanced)
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(widget)
for dest in self._alg.destinationParameterDefinitions():
if dest.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
if isinstance(dest, (QgsProcessingParameterRasterDestination,
QgsProcessingParameterVectorDestination,
QgsProcessingParameterFeatureSink,
QgsProcessingParameterFileDestination,
QgsProcessingParameterFolderDestination)):
label = QLabel(dest.description())
item = QgsFilterLineEdit()
if hasattr(item, 'setPlaceholderText'):
item.setPlaceholderText(
self.tr('[Enter name if this is a final result]'))
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(item)
self.valueItems[dest.name()] = item
label = QLabel(' ')
self.verticalLayout.addWidget(label)
label = QLabel(self.tr('Parent algorithms'))
self.dependenciesPanel = self.getDependenciesPanel()
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(self.dependenciesPanel)
self.verticalLayout.addStretch(1000)
self.setPreviousValues()
self.setWindowTitle(self._alg.displayName())
self.verticalLayout2 = QVBoxLayout()
self.verticalLayout2.setSpacing(2)
self.verticalLayout2.setMargin(0)
self.paramPanel = QWidget()
self.paramPanel.setLayout(self.verticalLayout)
self.scrollArea = QgsScrollArea()
self.scrollArea.setWidget(self.paramPanel)
self.scrollArea.setWidgetResizable(True)
self.verticalLayout2.addWidget(self.scrollArea)
self.verticalLayout2.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout2)
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.buttonBox.helpRequested.connect(self.openHelp)
QMetaObject.connectSlotsByName(self)
def useCanvasExtent(self):
self.setValueFromRect(
QgsReferencedRectangle(
iface.mapCanvas().extent(),
iface.mapCanvas().mapSettings().destinationCrs()))
def __init__(self, parent):
super().__init__(parent)
self.canvas = iface.mapCanvas()
self.dockwidget = wyszukiwarkaDzialekDockWidget()
# self.menu = self.tr(PLUGIN_NAME)
# self.toolbar = self.iface.addToolBar(PLUGIN_NAME)
# self.toolbar.setObjectName(PLUGIN_NAME)
self.teryt_search_result_collector = ResultCollectorSingle(self)
self.map_point_search_result_collector = self.teryt_search_result_collector
self.project = QgsProject.instance()
self.wms_layer = None
self.module_csv_import = None
self.module_teryt_search = None
self.module_point_layer_import = None
self.module_wms_kieg_initialized = False
self.module_map_point_search = MapPointSearch(
self, self.teryt_search_result_collector)
result_collector_factory = lambda parent, target_layer: ResultCollectorMultiple(
self, target_layer)
self.module_teryt_search = TerytSearch(
self, self.dockwidget.tab_teryt_search_layout,
self.teryt_search_result_collector, result_collector_factory,
ResultCollectorMultiple.default_layer_factory)
self.module_teryt_search.lpis_bbox_found.connect(self.add_wms_lpis)
result_collector_factory = lambda parent, target_layer: ResultCollectorMultiple(
self, target_layer)
self.module_csv_import = CSVImport(
self, self.dockwidget.tab_import_csv_layout,
result_collector_factory,
ResultCollectorMultiple.default_layer_factory)
self.module_point_layer_import = PointLayerImport(
self, self.dockwidget.tab_import_layer_point_layout)
self.wms_kieg_layer = None
self.dockwidget.button_wms_kieg.clicked.connect(self.add_wms_kieg)
self.module_wms_kieg_initialized = True
self.wms_lpis_layer = None
self.dockwidget.button_wms_lpis.clicked.connect(self.add_wms_lpis)
self.module_wms_lpis_initialized = True
icon_info_path = ':/plugins/plugin/info.png'
self.dockwidget.label_info_map_point_search.setPixmap(
QPixmap(icon_info_path))
self.dockwidget.label_info_map_point_search.setToolTip((
"Wybierz narzędzie i kliknij na mapę.\n"
"Narzędzie wyszuka działkę, w której zawierają się współrzędne kliknięcia."
))
#Zarejestrowanie we wtyczce
iface.addDockWidget(Qt.RightDockWidgetArea, self.dockwidget)
self.uldk_toolbar_action = self.parent.add_action(
":/plugins/gissupport_plugin/uldk/uldk.svg",
self.module_name,
lambda state: self.dockwidget.setHidden(not state),
checkable=True,
parent=iface.mainWindow(),
add_to_topmenu=True)
self.dockwidget.visibilityChanged.connect(
self.uldk_toolbar_action.setChecked)
self.identify_action = self.parent.add_action(
":/plugins/gissupport_plugin/uldk/uldk_identify.svg",
text="Identifykacja ULDK",
callback=lambda toggle: iface.mapCanvas().setMapTool(
self.module_map_point_search),
parent=iface.mainWindow(),
checkable=True,
add_to_topmenu=False)
self.module_map_point_search.setAction(self.identify_action)
self.parent.toolbar.addSeparator()
self.dockwidget.btnIdentify.setDefaultAction(self.identify_action)
self.dockwidget.hide()
def get_map_canvas():
"""Return map canvas object
"""
return iface.mapCanvas()
'enc_edif_comunic_a',
'hid_quebramar_molhe_a',
'loc_edificacao_a',
'sau_area_saude_a',
'lim_outras_unid_protegidas_a',
'edu_edif_religiosa_a',
'tra_edif_constr_aeroportuaria_a',
'hid_reservatorio_hidrico_a',
'lim_unidade_federacao_a',
'tra_descontinuidade_geometrica_a',
'sau_area_servico_social_a',
'lim_area_particular_a',
'enc_area_energia_eletrica_a']
# Pegando o EPSG do projeto
canvas = iface.mapCanvas()
epsg = int((canvas.mapRenderer().destinationCrs().authid()).split(':')[1])
# Varrer camadas e pegar as geometrias das classes que compoe a cobertura terrestre
# Carregar cada feicao na camada temporaria
lista = []
cont = 1
for layer in QgsMapLayerRegistry.instance().mapLayers().values():
if layer.name() in classes:
for feature in layer.getFeatures():
geom = feature.geometry()
if geom:
coord = geom.asPolygon()
if coord == []:
COORD = geom.asMultiPolygon()
def processAlgorithm(self, feedback):
layer = dataobjects.getLayerFromString(
self.getParameterValue(self.INPUT_VECTOR))
startPoint = self.getParameterValue(self.START_POINT)
endPoints = dataobjects.getLayerFromString(
self.getParameterValue(self.END_POINTS))
strategy = self.getParameterValue(self.STRATEGY)
directionFieldName = self.getParameterValue(self.DIRECTION_FIELD)
forwardValue = self.getParameterValue(self.VALUE_FORWARD)
backwardValue = self.getParameterValue(self.VALUE_BACKWARD)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
speedFieldName = self.getParameterValue(self.SPEED_FIELD)
defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED)
tolerance = self.getParameterValue(self.TOLERANCE)
fields = QgsFields()
fields.append(QgsField('start', QVariant.String, '', 254, 0))
fields.append(QgsField('end', QVariant.String, '', 254, 0))
fields.append(QgsField('cost', QVariant.Double, '', 20, 7))
feat = QgsFeature()
feat.setFields(fields)
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
fields.toList(), QgsWkbTypes.LineString, layer.crs())
tmp = startPoint.split(',')
startPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
directionField = -1
if directionFieldName is not None:
directionField = layer.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName is not None:
speedField = layer.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(layer, directionField, forwardValue,
backwardValue, bothValue,
defaultDirection)
distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(
distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed,
multiplier * 1000.0 / 3600.0)
multiplier = 3600
director.addStrategy(strategy)
builder = QgsGraphBuilder(
iface.mapCanvas().mapSettings().destinationCrs(), True, tolerance)
feedback.pushInfo(self.tr('Loading end points...'))
request = QgsFeatureRequest()
request.setFlags(request.flags()
^ QgsFeatureRequest.SubsetOfAttributes)
features = vector.features(endPoints, request)
count = len(features)
points = [startPoint]
for f in features:
points.append(f.geometry().asPoint())
feedback.pushInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, points)
feedback.pushInfo(self.tr('Calculating shortest paths...'))
graph = builder.graph()
idxStart = graph.findVertex(snappedPoints[0])
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
route = []
total = 100.0 / count
for i in range(1, count + 1):
idxEnd = graph.findVertex(snappedPoints[i])
if tree[idxEnd] == -1:
msg = self.tr(
'There is no route from start point ({}) to end point ({}).'
.format(startPoint.toString(), points[i].toString()))
feedback.setProgressText(msg)
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING, msg)
continue
cost = 0.0
current = idxEnd
while current != idxStart:
cost += graph.edge(tree[current]).cost(0)
route.append(
graph.vertex(graph.edge(tree[current]).inVertex()).point())
current = graph.edge(tree[current]).outVertex()
route.append(snappedPoints[0])
route.reverse()
geom = QgsGeometry.fromPolyline(route)
feat.setGeometry(geom)
feat['start'] = startPoint.toString()
feat['end'] = points[i].toString()
feat['cost'] = cost / multiplier
writer.addFeature(feat)
route[:] = []
feedback.setProgress(int(i * total))
del writer
def processAlgorithm(self, feedback):
extent = self.getParameterValue(self.EXTENT).split(',')
xSpace = self.getParameterValue(self.STEP_X)
ySpace = self.getParameterValue(self.STEP_Y)
bbox = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
mapCRS = iface.mapCanvas().mapSettings().destinationCrs()
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
fields.append(QgsField('coord', QVariant.Double, '', 24, 15))
fieldCount = 2
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.LineString, mapCRS)
feat = QgsFeature()
feat.initAttributes(fieldCount)
feat.setFields(fields)
geom = QgsGeometry()
idVar = 0
count = 0
count_max = (bbox.yMaximum() - bbox.yMinimum()) / ySpace
count_update = count_max * 0.10
y = bbox.yMaximum()
while y >= bbox.yMinimum():
pt1 = QgsPoint(bbox.xMinimum(), y)
pt2 = QgsPoint(bbox.xMaximum(), y)
line = [pt1, pt2]
feat.setGeometry(geom.fromPolyline(line))
feat.setAttribute(0, idVar)
feat.setAttribute(1, y)
writer.addFeature(feat)
y = y - ySpace
idVar += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
feedback.setProgress(int(count / count_max * 50))
feedback.setProgress(50)
# counters for progressbar - update every 5%
count = 0
count_max = (bbox.xMaximum() - bbox.xMinimum()) / xSpace
count_update = count_max * 0.10
x = bbox.xMinimum()
while x <= bbox.xMaximum():
pt1 = QgsPoint(x, bbox.yMaximum())
pt2 = QgsPoint(x, bbox.yMinimum())
line = [pt1, pt2]
feat.setGeometry(geom.fromPolyline(line))
feat.setAttribute(0, idVar)
feat.setAttribute(1, x)
writer.addFeature(feat)
x = x + xSpace
idVar += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
feedback.setProgress(50 + int(count / count_max * 50))
del writer
def processAlgorithm(self, progress):
extent = str(self.getParameterValue(self.EXTENT)).split(',')
spacing = float(self.getParameterValue(self.SPACING))
inset = float(self.getParameterValue(self.INSET))
randomize = self.getParameterValue(self.RANDOMIZE)
isSpacing = self.getParameterValue(self.IS_SPACING)
extent = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
mapCRS = iface.mapCanvas().mapSettings().destinationCrs()
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, mapCRS)
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.0 / (area / pSpacing)
y = extent.yMaximum() - inset
extent_geom = QgsGeometry.fromRect(extent)
extent_engine = QgsGeometry.createGeometryEngine(
extent_geom.geometry())
extent_engine.prepareGeometry()
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if randomize:
geom = QgsGeometry().fromPoint(
QgsPoint(
uniform(x - (pSpacing / 2.0),
x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0),
y + (pSpacing / 2.0))))
else:
geom = QgsGeometry().fromPoint(QgsPoint(x, y))
if extent_engine.intersects(geom.geometry()):
f.setAttribute('id', count)
f.setGeometry(geom)
writer.addFeature(f)
x += pSpacing
count += 1
progress.setPercentage(int(count * total))
y = y - pSpacing
del writer
def get_qgis_app(cleanup=True):
""" Start one QGIS application to test against.
:returns: Handle to QGIS app, canvas, iface and parent. If there are any
errors the tuple members will be returned as None.
:rtype: (QgsApplication, CANVAS, IFACE, PARENT)
If QGIS is already running the handle to that app will be returned.
"""
global QGIS_APP, PARENT, IFACE, CANVAS # pylint: disable=W0603
if iface:
from qgis.core import QgsApplication
QGIS_APP = QgsApplication
CANVAS = iface.mapCanvas()
PARENT = iface.mainWindow()
IFACE = iface
return QGIS_APP, CANVAS, IFACE, PARENT
from qgis.core import QgsApplication
from qgis.gui import QgsMapCanvas
from qgis.PyQt.QtCore import QSize
from qgis.PyQt.QtWidgets import QWidget
from .qgis_interface import QgisInterface
global QGISAPP # pylint: disable=global-variable-undefined
try:
QGISAPP
except NameError:
myGuiFlag = True # All test will run qgis in gui mode
# In python3 we need to convert to a bytes object (or should
# QgsApplication accept a QString instead of const char* ?)
try:
argvb = list(map(os.fsencode, sys.argv))
except AttributeError:
argvb = sys.argv
# Note: QGIS_PREFIX_PATH is evaluated in QgsApplication -
# no need to mess with it here.
QGISAPP = QgsApplication(argvb, myGuiFlag)
QGISAPP.initQgis()
s = QGISAPP.showSettings()
LOGGER.debug(s)
def debug_log_message(message, tag, level):
"""
Prints a debug message to a log
:param message: message to print
:param tag: log tag
:param level: log message level (severity)
:return:
"""
print('{}({}): {}'.format(tag, level, message))
QgsApplication.instance().messageLog().messageReceived.connect(
debug_log_message)
if cleanup:
import atexit
@atexit.register
def exitQgis(): # pylint: disable=unused-variable
"""
Gracefully closes the QgsApplication instance
"""
try:
QGISAPP.exitQgis() # pylint: disable=used-before-assignment
QGISAPP = None # pylint: disable=redefined-outer-name
except NameError:
pass
if PARENT is None:
# noinspection PyPep8Naming
PARENT = QWidget()
if CANVAS is None:
# noinspection PyPep8Naming
CANVAS = QgsMapCanvas(PARENT)
CANVAS.resize(QSize(400, 400))
if IFACE is None:
# QgisInterface is a stub implementation of the QGIS plugin interface
# noinspection PyPep8Naming
IFACE = QgisInterface(CANVAS)
return QGISAPP, CANVAS, IFACE, PARENT
from qgis.utils import iface
# inserire qui il nome del layer geometrico
vl = QgsMapLayerRegistry.instance().mapLayersByName('nomeLayerGeom')[0]
iface.setActiveLayer(vl)
cLayer = iface.mapCanvas().currentLayer()
# qui sotto i nomi dei due campi da correlare
expr = QgsExpression("\"refGeom\"=[% "refAttr" %]")
it = cLayer.getFeatures( QgsFeatureRequest( expr ) )
ids = [i.id() for i in it]
cLayer.setSelectedFeatures( ids )
# zoom alla selezione
box = cLayer.boundingBoxOfSelected()
iface.mapCanvas().setExtent(box)
iface.mapCanvas().refresh()
-- caso dei pill:
from qgis.utils import iface
vl = QgsMapLayerRegistry.instance().mapLayersByName('pti_pill')[0]
iface.setActiveLayer(vl)
cLayer = iface.mapCanvas().currentLayer()
expr = QgsExpression("\"pk_uid\"=[% "pk_uid" %]")
it = cLayer.getFeatures( QgsFeatureRequest( expr ) )
ids = [i.id() for i in it]
cLayer.setSelectedFeatures( ids )
box = cLayer.boundingBoxOfSelected()
iface.mapCanvas().setExtent(box)
iface.mapCanvas().refresh()
-- articolo:
-- https://medium.com/tantotanto/qgis-selezionare-geometrie-da-una-tabella-di-attributi-correlata-bea37747a7e2
def selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_VECTOR), context)
startPoint = self.getParameterValue(self.START_POINT)
strategy = self.getParameterValue(self.STRATEGY)
travelCost = self.getParameterValue(self.TRAVEL_COST)
directionFieldName = self.getParameterValue(self.DIRECTION_FIELD)
forwardValue = self.getParameterValue(self.VALUE_FORWARD)
backwardValue = self.getParameterValue(self.VALUE_BACKWARD)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
speedFieldName = self.getParameterValue(self.SPEED_FIELD)
defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED)
tolerance = self.getParameterValue(self.TOLERANCE)
tmp = startPoint.split(',')
startPoint = QgsPointXY(float(tmp[0]), float(tmp[1]))
directionField = -1
if directionFieldName is not None:
directionField = layer.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName is not None:
speedField = layer.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(layer,
directionField,
forwardValue,
backwardValue,
bothValue,
defaultDirection)
distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField,
defaultSpeed,
multiplier * 1000.0 / 3600.0)
director.addStrategy(strategy)
builder = QgsGraphBuilder(iface.mapCanvas().mapSettings().destinationCrs(),
True,
tolerance)
feedback.pushInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, [startPoint])
feedback.pushInfo(self.tr('Calculating service area...'))
graph = builder.graph()
idxStart = graph.findVertex(snappedPoints[0])
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
vertices = []
for i, v in enumerate(cost):
if v > travelCost and tree[i] != -1:
vertexId = graph.edge(tree[i]).outVertex()
if cost[vertexId] <= travelCost:
vertices.append(i)
upperBoundary = []
lowerBoundary = []
for i in vertices:
upperBoundary.append(graph.vertex(graph.edge(tree[i]).inVertex()).point())
lowerBoundary.append(graph.vertex(graph.edge(tree[i]).outVertex()).point())
feedback.pushInfo(self.tr('Writing results...'))
fields = QgsFields()
fields.append(QgsField('type', QVariant.String, '', 254, 0))
fields.append(QgsField('start', QVariant.String, '', 254, 0))
feat = QgsFeature()
feat.setFields(fields)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
writer = self.getOutputFromName(
self.OUTPUT_POINTS).getVectorWriter(fields, QgsWkbTypes.MultiPoint, layer.crs(), context)
feat.setGeometry(geomUpper)
feat['type'] = 'upper'
feat['start'] = startPoint.toString()
writer.addFeature(feat, QgsFeatureSink.FastInsert)
feat.setGeometry(geomLower)
feat['type'] = 'lower'
feat['start'] = startPoint.toString()
writer.addFeature(feat, QgsFeatureSink.FastInsert)
del writer
upperBoundary.append(startPoint)
lowerBoundary.append(startPoint)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
writer = self.getOutputFromName(
self.OUTPUT_POLYGON).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)
geom = geomUpper.convexHull()
feat.setGeometry(geom)
feat['type'] = 'upper'
feat['start'] = startPoint.toString()
writer.addFeature(feat, QgsFeatureSink.FastInsert)
geom = geomLower.convexHull()
feat.setGeometry(geom)
feat['type'] = 'lower'
feat['start'] = startPoint.toString()
writer.addFeature(feat, QgsFeatureSink.FastInsert)
del writer
