def testSignal(self):
w = QgsProjectionSelectionWidget()
w.show()
spy = QSignalSpy(w.crsChanged)
w.setCrs(QgsCoordinateReferenceSystem('EPSG:3111'))
self.assertEqual(w.crs().authid(), 'EPSG:3111')
self.assertEqual(len(spy), 1)
# setting the same crs doesn't emit the signal
w.setCrs(QgsCoordinateReferenceSystem('EPSG:3111'))
self.assertEqual(len(spy), 1)
def testSignal(self):
w = QgsProjectionSelectionWidget()
w.show()
spy = QSignalSpy(w.crsChanged)
w.setCrs(QgsCoordinateReferenceSystem('EPSG:3111'))
self.assertEqual(w.crs().authid(), 'EPSG:3111')
self.assertEqual(len(spy), 1)
# setting the same crs doesn't emit the signal
w.setCrs(QgsCoordinateReferenceSystem('EPSG:3111'))
self.assertEqual(len(spy), 1)
class BBOXDialog(QDialog, FORM_CLASS):
def __init__(self, inp_sparql, triplestoreconf, endpointIndex):
super(QDialog, self).__init__()
self.setupUi(self)
self.inp_sparql = inp_sparql
self.triplestoreconf = triplestoreconf
self.endpointIndex = endpointIndex
self.vl = QgsVectorLayer("Point", "temporary_points", "memory")
self.map_canvas = QgsMapCanvas(self)
self.layerExtentOrBBOX = False
self.map_canvas.setMinimumSize(500, 475)
self.map_canvas.move(0, 30)
self.nominatimmap = {}
actionPan = QAction("Pan", self)
actionPan.setCheckable(True)
actionPan.triggered.connect(self.pan)
self.toolPan = QgsMapToolPan(self.map_canvas)
self.toolPan.setAction(actionPan)
uri = "url=http://a.tile.openstreetmap.org/{z}/{x}/{y}.png&zmin=0&type=xyz"
self.mts_layer = QgsRasterLayer(uri, 'OSM', 'wms')
if not self.mts_layer.isValid():
print("Layer failed to load!")
self.rect_tool = RectangleMapTool(self.map_canvas)
self.circ_tool = CircleMapTool(self.map_canvas, 1)
self.poly_tool = PolygonMapTool(self.map_canvas)
self.map_canvas.setMapTool(self.rect_tool)
self.map_canvas.setExtent(self.mts_layer.extent())
self.map_canvas.setLayers([self.vl, self.mts_layer])
self.map_canvas.setCurrentLayer(self.mts_layer)
self.pan()
self.selectCircle.hide()
self.geocodeSearch = NominatimText(self, self.nominatimmap,
self.map_canvas)
self.move(120, 0)
self.crsdialog = QgsProjectionSelectionWidget(self)
self.crsdialog.move(160, 540)
self.crsdialog.resize(331, 30)
self.crsdialog.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.crsdialog.show()
self.nominatimurl = 'https://nominatim.openstreetmap.org/search?format=json&q={address}'
self.panButton.clicked.connect(self.pan)
self.selectCircle.clicked.connect(self.selectcircle)
self.selectPolygon.clicked.connect(self.selectpolygon)
self.selectButton.clicked.connect(self.selectarea)
self.zoomIn.clicked.connect(self.map_canvas.zoomIn)
self.zoomOut.clicked.connect(self.map_canvas.zoomOut)
self.b2.clicked.connect(self.setBBOXExtentQuery)
self.searchButton.hide()
self.searchPlace.hide()
self.geocodeSearch.hide()
layers = QgsProject.instance().layerTreeRoot().children()
for layer in layers:
self.chooseBBOXLayer.addItem(layer.name())
self.searchButton.clicked.connect(self.geocode)
self.b1.clicked.connect(self.setBBOXInQuery)
def geocode(self):
try:
nominatimurl = self.nominatimurl.format(
**{'address': self.geocodeSearch.text()})
self.networkrequest(nominatimurl)
except Exception as e:
msgBox = QMessageBox()
msgBox.setWindowTitle("Mandatory variables missing!")
msgBox.setText(str(e))
msgBox.exec()
def networkrequest(self, nurl):
global reply
self.manager = QNetworkAccessManager()
url = QUrl(nurl)
request = QNetworkRequest(url)
self.manager.finished.connect(self.handleResponse)
self.manager.get(request)
def handleResponse(self, reply):
er = reply.error()
if er == QNetworkReply.NoError:
bytes_string = reply.readAll()
print(str(bytes_string, 'utf-8'))
results = json.loads(str(bytes_string, 'utf-8'))
self.nominatimmap = {}
chooselist = []
for rec in results:
chooselist.append(rec['display_name'])
self.nominatimmap[rec['display_name']] = [
rec['lon'], rec['lat']
]
completer = SPARQLCompleter(chooselist)
self.geocodeSearch.setMap(self.nominatimmap)
self.geocodeSearch.setCompleter(completer)
#self.geocodeSearch.insertCompletion.connect(self.zoomToCoordinates)
completer.popup().show()
else:
print("Error occured: ", er)
def zoomToCoordinates(self, completion):
msgBox = QMessageBox()
msgBox.setText(completion)
msgBox.exec()
self.map_canvas.zoomWithCenter(self.nominatimmap[completion][0],
self.nominatimmap[completion][1], True)
def pan(self):
self.map_canvas.setMapTool(self.toolPan)
def selectarea(self):
self.rectangle = True
self.circle = False
self.polygon = False
self.map_canvas.setMapTool(self.rect_tool)
def selectcircle(self):
self.rectangle = False
self.circle = True
self.polygon = False
self.map_canvas.setMapTool(self.circ_tool)
def selectpolygon(self):
self.rectangle = False
self.circle = False
self.polygon = True
self.map_canvas.setMapTool(self.poly_tool)
def setBBOXExtentQuery(self):
if len(QgsProject.instance().layerTreeRoot().children()) > 0:
self.mts_layer = QgsProject.instance().layerTreeRoot().children()[
self.chooseBBOXLayer.currentIndex()].layer()
self.layerExtentOrBBOX = True
self.setBBOXInQuery()
self.close()
else:
msgBox = QMessageBox()
msgBox.setWindowTitle("No layer loaded in QGIS!")
msgBox.setText(
"No layer has been loaded in QGIS to get an extent from!")
msgBox.exec()
def setBBOXInQuery(self):
sourceCrs = None
if self.layerExtentOrBBOX:
xMax = self.mts_layer.extent().xMaximum()
xMin = self.mts_layer.extent().xMinimum()
yMin = self.mts_layer.extent().yMinimum()
yMax = self.mts_layer.extent().yMaximum()
pointt1 = QgsGeometry.fromPointXY(QgsPointXY(xMax, yMin))
pointt2 = QgsGeometry.fromPointXY(QgsPointXY(xMin, yMin))
pointt3 = QgsGeometry.fromPointXY(QgsPointXY(xMin, yMax))
pointt4 = QgsGeometry.fromPointXY(QgsPointXY(xMax, yMax))
sourceCrs = QgsCoordinateReferenceSystem(self.mts_layer.crs())
else:
sourceCrs = QgsCoordinateReferenceSystem(self.mts_layer.crs())
destCrs = self.crsdialog.crs()
if self.polygon:
polygon = self.poly_tool.rb.asGeometry()
tr = QgsCoordinateTransform(sourceCrs, destCrs,
QgsProject.instance())
polygon.transform(tr)
elif self.circle:
pointt1 = QgsGeometry.fromWkt(self.circ_tool.point1.asWkt())
pointt2 = QgsGeometry.fromWkt(self.circ_tool.point2.asWkt())
pointt3 = QgsGeometry.fromWkt(self.circ_tool.point3.asWkt())
pointt4 = QgsGeometry.fromWkt(self.circ_tool.point4.asWkt())
else:
pointt1 = QgsGeometry.fromWkt(self.rect_tool.point1.asWkt())
pointt2 = QgsGeometry.fromWkt(self.rect_tool.point2.asWkt())
pointt3 = QgsGeometry.fromWkt(self.rect_tool.point3.asWkt())
pointt4 = QgsGeometry.fromWkt(self.rect_tool.point4.asWkt())
if sourceCrs != None:
tr = QgsCoordinateTransform(sourceCrs, destCrs,
QgsProject.instance())
pointt1.transform(tr)
pointt2.transform(tr)
pointt3.transform(tr)
pointt4.transform(tr)
polygon = QgsGeometry.fromPolylineXY([
pointt1.asPoint(),
pointt2.asPoint(),
pointt3.asPoint(),
pointt4.asPoint()
])
center = polygon.centroid()
#distance = QgsDistanceArea()
#distance.setSourceCrs(destCrs)
#distance.setEllipsoidalMode(True)
#distance.setEllipsoid('WGS84')
curquery = self.inp_sparql.toPlainText()
if self.rectangle or self.circle:
widthm = 100 #distance.measureLine(pointt1, pointt2)
self.curbbox = []
self.curbbox.append(pointt1)
self.curbbox.append(pointt2)
self.curbbox.append(pointt3)
self.curbbox.append(pointt4)
self.close()
if "bboxquery" in self.triplestoreconf[
self.endpointIndex] and self.triplestoreconf[
self.
endpointIndex]["bboxquery"]["type"] == "geosparql":
curquery = curquery[
0:curquery.rfind('}')] + self.triplestoreconf[
self.endpointIndex]["bboxquery"]["query"].replace(
"%%x1%%", str(pointt1.asPoint().x())).replace(
"%%x2%%", str(pointt3.asPoint().x())).replace(
"%%y1%%",
str(pointt1.asPoint().y())).replace(
"%%y2%%", str(pointt3.asPoint().y())
) + "}\n" + curquery[curquery.rfind('}') +
1:]
elif "bboxquery" in self.triplestoreconf[
self.endpointIndex] and self.triplestoreconf[
self.endpointIndex]["bboxquery"]["type"] == "minmax":
curquery = curquery[
0:curquery.rfind('}')] + self.triplestoreconf[
self.endpointIndex]["bboxquery"]["query"].replace(
"%%minPoint%%", pointt2.asWkt()).replace(
"%%maxPoint%%", pointt4.asWkt()
) + curquery[curquery.rfind('}') + 1:]
elif "bboxquery" in self.triplestoreconf[
self.endpointIndex] and self.triplestoreconf[
self.
endpointIndex]["bboxquery"]["type"] == "pointdistance":
curquery = curquery[
0:curquery.rfind('}')] + self.triplestoreconf[
self.endpointIndex]["bboxquery"]["query"].replace(
"%%lat%%", str(center.asPoint().y())).replace(
"%%lon%%", str(center.asPoint().x())).replace(
"%%distance%%", str(widthm / 1000)
) + curquery[curquery.rfind('}') + 1:]
elif polygon:
widthm = 100
if "bboxquery" in self.triplestoreconf[
self.endpointIndex] and self.triplestoreconf[
self.
endpointIndex]["bboxquery"]["type"] == "geosparql":
curquery = curquery[0:curquery.rfind(
'}')] + "FILTER(geof:sfIntersects(?geo,\"" + polygon.asWkt(
) + "\"^^geo:wktLiteral))"
elif "bboxquery" in self.triplestoreconf[
self.endpointIndex] and self.triplestoreconf[
self.endpointIndex]["bboxquery"]["type"] == "minmax":
curquery = curquery[
0:curquery.rfind('}')] + self.triplestoreconf[
self.endpointIndex]["bboxquery"]["query"].replace(
"%%minPoint%%",
"POINT(" + str(polygon.boundingBox().yMinimum()) +
" " + str(polygon.boundingBox().xMinimum()) +
")").replace(
"%%maxPoint%%", "POINT(" +
str(polygon.boundingBox().yMaximum()) + " " +
str(polygon.boundingBox().xMaximum()) +
")") + curquery[curquery.rfind('}') + 1:]
elif "bboxquery" in self.triplestoreconf[
self.endpointIndex] and self.triplestoreconf[
self.
endpointIndex]["bboxquery"]["type"] == "pointdistance":
curquery = curquery[
0:curquery.rfind('}')] + self.triplestoreconf[
self.endpointIndex]["bboxquery"]["query"].replace(
"%%lat%%",
str(polygon.boundingBox().center().asPoint().y(
))).replace(
"%%lon%%",
str(polygon.boundingBox().center().asPoint().x(
))).replace("%%distance%%", str(
widthm /
1000)) + curquery[curquery.rfind('}') + 1:]
self.inp_sparql.setPlainText(curquery)
self.close()
# coding: utf-8
from qgis.core import QgsCoordinateReferenceSystem
from qgis.gui import QgsProjectionSelectionWidget
projection_selection_widget = QgsProjectionSelectionWidget()
projection_selection_widget.resize(400, 30)
projection_selection_widget.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
projection_selection_widget.show()
class ExportGeoDialog(QtWidgets.QDialog, FORM_CLASS):
def __init__(self, parent=None):
"""Constructor."""
super(ExportGeoDialog, self).__init__(parent)
# Set up the user interface from Designer through FORM_CLASS.
# After self.setupUi() you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
tools.TitleLayout("Tetra mesh boundaries", self.boundaries,
self.verticalLayout)
tools.TitleLayout("linear mesh boundaries", self.linearboundaries,
self.verticalLayout)
self.meshSizeSelector = QtWidgets.QComboBox(self)
self.meshSizeSelector.currentIndexChanged.connect(
self.onMeshSizeSelectorActivated)
tools.TitleLayout("Mesh size layer", self.meshSizeSelector,
self.verticalLayout)
self.projectionButton = QgsProjectionSelectionWidget()
tools.TitleLayout("Projection", self.projectionButton,
self.verticalLayout).label
self.projectionLabel = QtWidgets.QLabel()
self.verticalLayout.addWidget(self.projectionLabel)
self.projectionLabel.hide()
self.outputFile = tools.FileSelectorLayout("Output file", parent,
"save", "*.geo",
self.verticalLayout)
self.outputFile.fileWidget.textChanged.connect(self.validate)
self.runLayout = tools.CancelRunLayout(self, "Generate geometry file",
self.saveGeo,
self.verticalLayout)
self.boundaries.itemChanged.connect(self.validate)
self.linearboundaries.itemChanged.connect(self.validate)
self.setLayout(self.verticalLayout)
def onMeshSizeSelectorActivated(self, idx):
layer = self.meshSizeSelector.itemData(idx)
if layer is None:
self.projectionLabel.hide()
self.projectionButton.show()
else:
self.projectionButton.hide()
self.projectionLabel.show()
self.projectionLabel.setText("%s" % (layer.crs().description()))
def validate(self):
outputFile = self.outputFile.getFile()
something = False
tetraLayers = []
for i in range(self.boundaries.count()):
item = self.boundaries.item(i)
if item.checkState() == Qt.Checked:
tetraLayers += [item.data(Qt.UserRole).id()]
self.runLayout.runButton.setEnabled(
bool(outputFile != "" and tetraLayers))
def saveGeo(self):
filename = self.outputFile.getFile()
ignoredLayers = []
QuadLayers = []
TetraLayers = []
for i in range(self.boundaries.count()):
item = self.boundaries.item(i)
itemi = self.linearboundaries.item(i)
if item.checkState() == Qt.Checked:
TetraLayers += [item.data(Qt.UserRole)]
elif itemi.checkState() == Qt.Checked:
QuadLayers += [item.data(Qt.UserRole)]
else:
ignoredLayers += [item.data(Qt.UserRole)]
meshSizeLayer = self.meshSizeSelector.itemData(
self.meshSizeSelector.currentIndex())
crs = self.projectionButton.crs()
if meshSizeLayer:
crs = meshSizeLayer.crs()
proj = QgsProject.instance()
proj.writeEntry("qgmsh", "geo_file", filename)
proj.writeEntry("qgmsh", "ignored_boundary_layers", "%%".join(
(l.id() for l in ignoredLayers)))
proj.writeEntry("qgmsh", "tetralayers", "%%".join(
(l.id() for l in TetraLayers)))
proj.writeEntry("qgmsh", "quadlayers", "%%".join(
(l.id() for l in QuadLayers)))
proj.writeEntry("qgmsh", "projection", crs.authid())
proj.writeEntry(
"qgmsh", "mesh_size_layer",
"None" if meshSizeLayer is None else meshSizeLayer.id())
status = exportGeo(filename, TetraLayers, QuadLayers, meshSizeLayer,
crs)
self.close()
def exec_(self):
proj = QgsProject.instance()
self.outputFile.setFile(proj.readEntry("qgmsh", "geo_file", "")[0])
ignoredLayers = set(
proj.readEntry("qgmsh", "ignored_boundary_layers",
"")[0].split("%%"))
tetraLayers = set(
proj.readEntry("qgmsh", "tetralayers", "")[0].split("%%"))
quadLayers = set(
proj.readEntry("qgmsh", "quadlayers", "")[0].split("%%"))
meshSizeLayerId = proj.readEntry("qgmsh", "mesh_size_layer", "None")[0]
projid = proj.readEntry("qgmsh", "projection", "")[0]
crs = None
if projid:
crs = QgsCoordinateReferenceSystem(projid)
if crs is None or not crs.isValid():
crs = QgsCoordinateReferenceSystem("EPSG:4326")
self.projectionButton.setCrs(crs)
layers = [
tree_layer.layer() for tree_layer in
QgsProject.instance().layerTreeRoot().findLayers()
]
self.boundaries.clear()
self.linearboundaries.clear()
self.meshSizeSelector.clear()
self.meshSizeSelector.addItem("None", None)
for layer in layers:
if layer.type() == QgsMapLayer.VectorLayer:
item = QtWidgets.QListWidgetItem(layer.name(), self.boundaries)
item.setData(Qt.UserRole, layer)
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
item.setCheckState(Qt.Unchecked if (
layer.id() in ignoredLayers or layer.id() in quadLayers
) else Qt.Checked)
item = QtWidgets.QListWidgetItem(layer.name(),
self.linearboundaries)
item.setData(Qt.UserRole, layer)
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
item.setCheckState(Qt.Checked if layer.id() in
quadLayers else Qt.Unchecked)
if layer.type() == QgsMapLayer.RasterLayer:
self.meshSizeSelector.addItem(layer.name(), layer)
if layer.id() == meshSizeLayerId:
self.meshSizeSelector.setCurrentIndex(
self.meshSizeSelector.count() - 1)
self.runLayout.setFocus()
self.validate()
super(ExportGeoDialog, self).exec_()
class Dialog(QtWidgets.QDialog):
def __init__(self, mainWindow, iface, meshDialog):
super(Dialog, self).__init__(mainWindow)
self.meshDialog = meshDialog
self.setWindowTitle("Generate a Gmsh geometry file")
layout = QtWidgets.QVBoxLayout()
self.geometrySelector = QtWidgets.QListWidget()
tools.TitleLayout("Mesh Boundaries", self.geometrySelector, layout)
self.forceAllBndButton = QtWidgets.QCheckBox(
"Force all boundary points")
layout.addWidget(self.forceAllBndButton)
self.insideSelector = QtWidgets.QListWidget()
tools.TitleLayout("Forced line and points inside the domain",
self.insideSelector, layout)
self.meshSizeSelector = QtWidgets.QComboBox(self)
self.meshSizeSelector.currentIndexChanged.connect(
self.onMeshSizeSelectorActivated)
tools.TitleLayout("Mesh size layer", self.meshSizeSelector, layout)
self.projectionButton = QgsProjectionSelectionWidget()
tools.TitleLayout("Projection", self.projectionButton, layout).label
self.projectionLabel = QtWidgets.QLabel()
layout.addWidget(self.projectionLabel)
self.projectionLabel.hide()
self.outputFile = tools.FileSelectorLayout("Output file",
iface.mainWindow(), "save",
"*.geo", layout)
self.outputFile.fileWidget.textChanged.connect(self.validate)
self.geometrySelector.itemChanged.connect(self.validate)
self.runLayout = tools.CancelRunLayout(self, "Generate geometry file",
self.saveGeo, layout)
self.setLayout(layout)
self.forceAllBndButton.stateChanged.connect(self.validate)
self.iface = iface
self.resize(max(450, self.width()), self.height())
def validate(self):
outputFile = self.outputFile.getFile()
something = False
activeLayers = []
for i in range(self.geometrySelector.count()):
item = self.geometrySelector.item(i)
if item.checkState() == Qt.Checked:
activeLayers += [item.data(Qt.UserRole).id()]
for i in range(self.insideSelector.count()):
item = self.insideSelector.item(i)
if item.data(Qt.UserRole).id() in activeLayers:
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
else:
item.setFlags(item.flags() | Qt.ItemIsEnabled)
self.runLayout.runButton.setEnabled(
bool(outputFile != "" and activeLayers))
def saveGeo(self):
filename = self.outputFile.getFile()
ignoredLayers = []
insideLayers = []
activeLayers = []
for i in range(self.geometrySelector.count()):
item = self.geometrySelector.item(i)
itemi = self.insideSelector.item(i)
if item.checkState() == Qt.Checked:
activeLayers += [item.data(Qt.UserRole)]
elif itemi.checkState() == Qt.Checked:
insideLayers += [item.data(Qt.UserRole)]
else:
ignoredLayers += [item.data(Qt.UserRole)]
meshSizeLayer = self.meshSizeSelector.itemData(
self.meshSizeSelector.currentIndex())
crs = self.projectionButton.crs()
if meshSizeLayer:
crs = meshSizeLayer.crs()
forceAllBnd = self.forceAllBndButton.isChecked()
proj = QgsProject.instance()
proj.writeEntry("gmsh", "geo_file", filename)
proj.writeEntry("gmsh", "ignored_boundary_layers", "%%".join(
(l.id() for l in ignoredLayers)))
proj.writeEntry("gmsh", "inside_layers", "%%".join(
(l.id() for l in insideLayers)))
proj.writeEntry("gmsh", "projection", crs.authid())
proj.writeEntry(
"gmsh", "mesh_size_layer",
"None" if meshSizeLayer is None else meshSizeLayer.id())
proj.writeEntry("gmsh", "force_all_boundary_points",
"True" if forceAllBnd else "False")
status = exportGeo(filename, activeLayers, insideLayers, meshSizeLayer,
crs, forceAllBnd)
self.close()
if status:
self.meshDialog.exec_()
def onMeshSizeSelectorActivated(self, idx):
layer = self.meshSizeSelector.itemData(idx)
if layer is None:
self.projectionLabel.hide()
self.projectionButton.show()
else:
self.projectionButton.hide()
self.projectionLabel.show()
self.projectionLabel.setText("%s" % (layer.crs().description()))
def exec_(self):
proj = QgsProject.instance()
self.outputFile.setFile(proj.readEntry("gmsh", "geo_file", "")[0])
ignoredLayers = set(
proj.readEntry("gmsh", "ignored_boundary_layers",
"")[0].split("%%"))
insideLayers = set(
proj.readEntry("gmsh", "inside_layers", "")[0].split("%%"))
meshSizeLayerId = proj.readEntry("gmsh", "mesh_size_layer", "None")[0]
projid = proj.readEntry("gmsh", "projection", "")[0]
forceAllBnd = proj.readEntry("gmsh", "force_all_boundary_points",
"False")[0] == "True"
self.forceAllBndButton.setCheckState(
Qt.Checked if forceAllBnd else Qt.Unchecked)
crs = None
if projid:
crs = QgsCoordinateReferenceSystem(projid)
if crs is None or not crs.isValid():
crs = QgsCoordinateReferenceSystem("EPSG:4326")
self.projectionButton.setCrs(crs)
layers = [
tree_layer.layer() for tree_layer in
QgsProject.instance().layerTreeRoot().findLayers()
]
self.geometrySelector.clear()
self.insideSelector.clear()
self.meshSizeSelector.clear()
self.meshSizeSelector.addItem("None", None)
for layer in layers:
if layer.type() == QgsMapLayer.VectorLayer:
item = QtWidgets.QListWidgetItem(layer.name(),
self.geometrySelector)
item.setData(Qt.UserRole, layer)
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
item.setCheckState(Qt.Unchecked if (
layer.id() in ignoredLayers or layer.id() in insideLayers
) else Qt.Checked)
item = QtWidgets.QListWidgetItem(layer.name(),
self.insideSelector)
item.setData(Qt.UserRole, layer)
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
item.setCheckState(Qt.Checked if layer.id() in
insideLayers else Qt.Unchecked)
if layer.type() == QgsMapLayer.RasterLayer:
self.meshSizeSelector.addItem(layer.name(), layer)
if layer.id() == meshSizeLayerId:
self.meshSizeSelector.setCurrentIndex(
self.meshSizeSelector.count() - 1)
self.runLayout.setFocus()
self.validate()
super(Dialog, self).exec_()
