def __init__(self, dialog, alg, default=None):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.dialog = dialog
self.params = alg.parameters
if self.canUseAutoExtent():
if hasattr(self.leText, "setPlaceholderText"):
self.leText.setPlaceholderText(self.tr("[Leave blank to use min covering extent]"))
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
if default:
tokens = unicode(default).split(",")
if len(tokens) == 4:
try:
float(tokens[0])
float(tokens[1])
float(tokens[2])
float(tokens[3])
self.leText.setText(unicode(default))
except:
pass
def __init__(self, dialog, param):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.dialog = dialog
self.param = param
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
if hasattr(self.leText, 'setPlaceholderText'):
self.leText.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
if param.defaultValue() is not None:
context = createContext()
rect = QgsProcessingParameters.parameterAsExtent(param, {param.name(): param.defaultValue()}, context)
if not rect.isNull():
try:
s = '{},{},{},{}'.format(
rect.xMinimum(), rect.xMaximum(), rect.yMinimum(), rect.yMaximum())
self.leText.setText(s)
except:
pass
def __init__(self, dialog, param):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.dialog = dialog
self.param = param
if self.param.optional:
if hasattr(self.leText, 'setPlaceholderText'):
self.leText.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
if param.default:
tokens = param.default.split(',')
if len(tokens) == 4:
try:
float(tokens[0])
float(tokens[1])
float(tokens[2])
float(tokens[3])
self.leText.setText(param.default)
except:
pass
def __init__(self, parent=None):
super(BboxWidget, self).__init__(parent)
self.setupUi(self)
self.dialog = None
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
def __init__(self, dialog, param):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.dialog = dialog
self.param = param
self.crs = QgsProject.instance().crs()
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
if hasattr(self.leText, 'setPlaceholderText'):
self.leText.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.btnSelect.clicked.connect(self.selectExtent)
if iface is not None:
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
else:
self.prevMapTool = None
self.tool = None
if param.defaultValue() is not None:
context = createContext()
rect = QgsProcessingParameters.parameterAsExtent(param, {param.name(): param.defaultValue()}, context)
crs = QgsProcessingParameters.parameterAsExtentCrs(param, {param.name(): param.defaultValue()}, context)
if not rect.isNull():
try:
s = '{},{},{},{}'.format(
rect.xMinimum(), rect.xMaximum(), rect.yMinimum(), rect.yMaximum())
if crs.isValid():
s += ' [' + crs.authid() + ']'
self.crs = crs
self.leText.setText(s)
except:
pass
def __init__(self, dialog, alg, default):
super(ExtentSelectionPanel, self).__init__(None)
self.dialog = dialog
self.params = alg.parameters
self.horizontalLayout = QtGui.QHBoxLayout(self)
self.horizontalLayout.setSpacing(2)
self.horizontalLayout.setMargin(0)
self.text = QtGui.QLineEdit()
self.text.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
if self.canUseAutoExtent():
if hasattr(self.text, 'setPlaceholderText'):
self.text.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.horizontalLayout.addWidget(self.text)
self.pushButton = QtGui.QPushButton()
self.pushButton.setText('...')
self.pushButton.clicked.connect(self.buttonPushed)
self.horizontalLayout.addWidget(self.pushButton)
self.setLayout(self.horizontalLayout)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.connect(self.tool, SIGNAL('rectangleCreated()'), self.fillCoords)
def __init__(self, dialog, alg, default):
QWidget.__init__(self)
self.setupUi(self)
self.dialog = dialog
self.params = alg.parameters
if self.canUseAutoExtent():
if hasattr(self.leText, "setPlaceholderText"):
self.leText.setPlaceholderText(self.tr("[Leave blank to use min covering extent]"))
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
def __init__(self, dialog, alg, default):
super(ExtentSelectionPanel, self).__init__(None)
self.dialog = dialog
self.params = alg.parameters
self.horizontalLayout = QtGui.QHBoxLayout(self)
self.horizontalLayout.setSpacing(2)
self.horizontalLayout.setMargin(0)
self.text = QtGui.QLineEdit()
#self.text.setText(default)
self.text.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
if self.canUseAutoExtent():
if hasattr(self.text, 'setPlaceholderText'):
self.text.setPlaceholderText("[Leave blank to use min covering extent]")
self.horizontalLayout.addWidget(self.text)
self.pushButton = QtGui.QPushButton()
self.pushButton.setText("...")
self.pushButton.clicked.connect(self.buttonPushed)
self.horizontalLayout.addWidget(self.pushButton)
self.setLayout(self.horizontalLayout)
canvas = QGisLayers.iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.connect(self.tool, SIGNAL("rectangleCreated()"), self.fillCoords)
class ExtentSelectionPanel(BASE, WIDGET):
def __init__(self, dialog, param):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.dialog = dialog
self.param = param
self.crs = QgsProject.instance().crs()
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
if hasattr(self.leText, 'setPlaceholderText'):
self.leText.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.btnSelect.clicked.connect(self.selectExtent)
if iface is not None:
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
else:
self.prevMapTool = None
self.tool = None
if param.defaultValue() is not None:
context = createContext()
rect = QgsProcessingParameters.parameterAsExtent(
param, {param.name(): param.defaultValue()}, context)
crs = QgsProcessingParameters.parameterAsExtentCrs(
param, {param.name(): param.defaultValue()}, context)
if not rect.isNull():
try:
s = '{},{},{},{}'.format(rect.xMinimum(), rect.xMaximum(),
rect.yMinimum(), rect.yMaximum())
if crs.isValid():
s += ' [' + crs.authid() + ']'
self.crs = crs
self.leText.setText(s)
except:
pass
def selectExtent(self):
popupmenu = QMenu()
useCanvasExtentAction = QAction(
QCoreApplication.translate("ExtentSelectionPanel",
'Use Canvas Extent'), self.btnSelect)
useLayerExtentAction = QAction(
QCoreApplication.translate("ExtentSelectionPanel",
'Use Layer Extent…'), self.btnSelect)
selectOnCanvasAction = QAction(self.tr('Select Extent on Canvas'),
self.btnSelect)
popupmenu.addAction(useCanvasExtentAction)
popupmenu.addAction(selectOnCanvasAction)
popupmenu.addSeparator()
popupmenu.addAction(useLayerExtentAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
useCanvasExtentAction.triggered.connect(self.useCanvasExtent)
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
useMincoveringExtentAction = QAction(
self.tr('Use Min Covering Extent from Input Layers'),
self.btnSelect)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
def useMinCoveringExtent(self):
self.leText.setText('')
def useLayerExtent(self):
extentsDict = {}
extents = []
layers = QgsProcessingUtils.compatibleLayers(QgsProject.instance())
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,
0, False)
if ok:
self.setValueFromRect(
QgsReferencedRectangle(
extentsDict[item]["extent"],
QgsCoordinateReferenceSystem(extentsDict[item]["authid"])))
def useCanvasExtent(self):
self.setValueFromRect(
QgsReferencedRectangle(
iface.mapCanvas().extent(),
iface.mapCanvas().mapSettings().destinationCrs()))
def selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def updateExtent(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = '{},{},{},{}'.format(r.xMinimum(), r.xMaximum(), r.yMinimum(),
r.yMaximum())
try:
self.crs = r.crs()
except:
self.crs = QgsProject.instance().crs()
if self.crs.isValid():
s += ' [' + self.crs.authid() + ']'
self.leText.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if str(self.leText.text()).strip() != '':
return str(self.leText.text())
else:
return None
def setExtentFromString(self, s):
self.leText.setText(s)
class ExtentSelectionPanel(QWidget, Ui_Form):
def __init__(self, dialog, alg, default):
QWidget.__init__(self)
self.setupUi(self)
self.dialog = dialog
self.params = alg.parameters
if self.canUseAutoExtent():
if hasattr(self.leText, "setPlaceholderText"):
self.leText.setPlaceholderText(self.tr("[Leave blank to use min covering extent]"))
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
def canUseAutoExtent(self):
for param in self.params:
if isinstance(param, (ParameterRaster, ParameterVector)):
return True
if isinstance(param, ParameterMultipleInput):
return True
return False
def selectExtent(self):
popupmenu = QMenu()
useLayerExtentAction = QAction(self.tr("Use layer/canvas extent"), self.btnSelect)
selectOnCanvasAction = QAction(self.tr("Select extent on canvas"), self.btnSelect)
popupmenu.addAction(useLayerExtentAction)
popupmenu.addAction(selectOnCanvasAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
if self.canUseAutoExtent():
useMincoveringExtentAction = QAction(self.tr("Use min covering extent from input layers"), self.btnSelect)
useMincoveringExtentAction.triggered.connect(self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
def useMinCoveringExtent(self):
self.leText.setText("")
def getMinCoveringExtent(self):
first = True
found = False
for param in self.params:
if param.value:
if isinstance(param, (ParameterRaster, ParameterVector)):
if isinstance(param.value, (QgsRasterLayer, QgsVectorLayer)):
layer = param.value
else:
layer = dataobjects.getObjectFromUri(param.value)
if layer:
found = True
self.addToRegion(layer, first)
first = False
elif isinstance(param, ParameterMultipleInput):
layers = param.value.split(";")
for layername in layers:
layer = dataobjects.getObjectFromUri(layername, first)
if layer:
found = True
self.addToRegion(layer, first)
first = False
if found:
return "{},{},{},{}".format(self.xmin, self.xmax, self.ymin, self.ymax)
else:
return None
def useNewAlg(self, alg):
self.params = alg.parameters
def addToRegion(self, layer, first):
if first:
self.xmin = layer.extent().xMinimum()
self.xmax = layer.extent().xMaximum()
self.ymin = layer.extent().yMinimum()
self.ymax = layer.extent().yMaximum()
else:
self.xmin = min(self.xmin, layer.extent().xMinimum())
self.xmax = max(self.xmax, layer.extent().xMaximum())
self.ymin = min(self.ymin, layer.extent().yMinimum())
self.ymax = max(self.ymax, layer.extent().yMaximum())
def useLayerExtent(self):
CANVAS_KEY = "Use canvas extent"
extentsDict = {}
extentsDict[CANVAS_KEY] = iface.mapCanvas().extent()
extents = [CANVAS_KEY]
layers = dataobjects.getAllLayers()
for layer in layers:
extents.append(layer.name())
extentsDict[layer.name()] = layer.extent()
(item, ok) = QInputDialog.getItem(self, self.tr("Select extent"), self.tr("Use extent from"), extents, False)
if ok:
self.setValueFromRect(extentsDict[item])
def selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def updateExtent(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = "{},{},{},{}".format(r.xMinimum(), r.xMaximum(), r.yMinimum(), r.yMaximum())
self.leText.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if str(self.leText.text()).strip() != "":
return unicode(self.leText.text())
else:
return self.getMinCoveringExtent()
def setExtentFromString(self, s):
self.leText.setText(s)
class ExtentSelectionPanel(BASE, WIDGET):
def __init__(self, dialog, param):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.dialog = dialog
self.param = param
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
if hasattr(self.leText, 'setPlaceholderText'):
self.leText.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
if param.defaultValue() is not None:
context = createContext()
rect = QgsProcessingParameters.parameterAsExtent(
param, {param.name(): param.defaultValue()}, context)
if not rect.isNull():
try:
s = '{},{},{},{}'.format(rect.xMinimum(), rect.xMaximum(),
rect.yMinimum(), rect.yMaximum())
self.leText.setText(s)
except:
pass
def selectExtent(self):
popupmenu = QMenu()
useLayerExtentAction = QAction(self.tr('Use layer/canvas extent'),
self.btnSelect)
selectOnCanvasAction = QAction(self.tr('Select extent on canvas'),
self.btnSelect)
popupmenu.addAction(useLayerExtentAction)
popupmenu.addAction(selectOnCanvasAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
useMincoveringExtentAction = QAction(
self.tr('Use min covering extent from input layers'),
self.btnSelect)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
def useMinCoveringExtent(self):
self.leText.setText('')
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 = QgsProcessingUtils.compatibleLayers(QgsProject.instance())
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 selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def updateExtent(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = '{},{},{},{}'.format(r.xMinimum(), r.xMaximum(), r.yMinimum(),
r.yMaximum())
self.leText.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if str(self.leText.text()).strip() != '':
return str(self.leText.text())
else:
return None
def setExtentFromString(self, s):
self.leText.setText(s)
class ExtentSelectionPanel(BASE, WIDGET):
hasChanged = pyqtSignal()
def __init__(self, dialog, param):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.leText.textChanged.connect(lambda: self.hasChanged.emit())
self.dialog = dialog
self.param = param
self.crs = QgsProject.instance().crs()
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
if hasattr(self.leText, 'setPlaceholderText'):
self.leText.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.btnSelect.clicked.connect(self.selectExtent)
if iface is not None:
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
else:
self.prevMapTool = None
self.tool = None
if param.defaultValue() is not None:
context = createContext()
rect = QgsProcessingParameters.parameterAsExtent(param, {param.name(): param.defaultValue()}, context)
crs = QgsProcessingParameters.parameterAsExtentCrs(param, {param.name(): param.defaultValue()}, context)
if not rect.isNull():
try:
s = '{},{},{},{}'.format(
rect.xMinimum(), rect.xMaximum(), rect.yMinimum(), rect.yMaximum())
if crs.isValid():
s += ' [' + crs.authid() + ']'
self.crs = crs
self.leText.setText(s)
except:
pass
def selectExtent(self):
popupmenu = QMenu()
useCanvasExtentAction = QAction(
QCoreApplication.translate("ExtentSelectionPanel", 'Use Canvas Extent'),
self.btnSelect)
useLayerExtentAction = QAction(
QCoreApplication.translate("ExtentSelectionPanel", 'Use Layer Extent…'),
self.btnSelect)
selectOnCanvasAction = QAction(
self.tr('Select Extent on Canvas'), self.btnSelect)
popupmenu.addAction(useCanvasExtentAction)
popupmenu.addAction(selectOnCanvasAction)
popupmenu.addSeparator()
popupmenu.addAction(useLayerExtentAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
useCanvasExtentAction.triggered.connect(self.useCanvasExtent)
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
useMincoveringExtentAction = QAction(
self.tr('Use Min Covering Extent from Input Layers'),
self.btnSelect)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
def useMinCoveringExtent(self):
self.leText.setText('')
def useLayerExtent(self):
dlg = LayerSelectionDialog(self)
if dlg.exec_():
layer = dlg.selected_layer()
self.setValueFromRect(QgsReferencedRectangle(layer.extent(), layer.crs()))
def useCanvasExtent(self):
self.setValueFromRect(QgsReferencedRectangle(iface.mapCanvas().extent(),
iface.mapCanvas().mapSettings().destinationCrs()))
def selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def updateExtent(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = '{},{},{},{}'.format(
r.xMinimum(), r.xMaximum(), r.yMinimum(), r.yMaximum())
try:
self.crs = r.crs()
except:
self.crs = QgsProject.instance().crs()
if self.crs.isValid():
s += ' [' + self.crs.authid() + ']'
self.leText.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if str(self.leText.text()).strip() != '':
return str(self.leText.text())
else:
return None
def setExtentFromString(self, s):
self.leText.setText(s)
class ExtentSelectionPanel(BASE, WIDGET):
def __init__(self, dialog, alg, default=None):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.dialog = dialog
self.params = alg.parameters
if self.canUseAutoExtent():
if hasattr(self.leText, 'setPlaceholderText'):
self.leText.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
if default:
tokens = unicode(default).split(',')
if len(tokens) == 4:
try:
float(tokens[0])
float(tokens[1])
float(tokens[2])
float(tokens[3])
self.leText.setText(unicode(default))
except:
pass
def canUseAutoExtent(self):
for param in self.params:
if isinstance(param, (ParameterRaster, ParameterVector)):
return True
if isinstance(param, ParameterMultipleInput):
return True
return False
def selectExtent(self):
popupmenu = QMenu()
useLayerExtentAction = QAction(self.tr('Use layer/canvas extent'),
self.btnSelect)
selectOnCanvasAction = QAction(self.tr('Select extent on canvas'),
self.btnSelect)
popupmenu.addAction(useLayerExtentAction)
popupmenu.addAction(selectOnCanvasAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
if self.canUseAutoExtent():
useMincoveringExtentAction = QAction(
self.tr('Use min covering extent from input layers'),
self.btnSelect)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
def useMinCoveringExtent(self):
self.leText.setText('')
def getMinCoveringExtent(self):
first = True
found = False
for param in self.params:
if param.value:
if isinstance(param, (ParameterRaster, ParameterVector)):
if isinstance(param.value,
(QgsRasterLayer, QgsVectorLayer)):
layer = param.value
else:
layer = dataobjects.getObject(param.value)
if layer:
found = True
self.addToRegion(layer, first)
first = False
elif isinstance(param, ParameterMultipleInput):
layers = param.value.split(';')
for layername in layers:
layer = dataobjects.getObject(layername)
if layer:
found = True
self.addToRegion(layer, first)
first = False
if found:
return '{},{},{},{}'.format(self.xmin, self.xmax, self.ymin,
self.ymax)
else:
return None
def useNewAlg(self, alg):
self.params = alg.parameters
def addToRegion(self, layer, first):
if first:
self.xmin = layer.extent().xMinimum()
self.xmax = layer.extent().xMaximum()
self.ymin = layer.extent().yMinimum()
self.ymax = layer.extent().yMaximum()
else:
self.xmin = min(self.xmin, layer.extent().xMinimum())
self.xmax = max(self.xmax, layer.extent().xMaximum())
self.ymin = min(self.ymin, layer.extent().yMinimum())
self.ymax = max(self.ymax, layer.extent().yMaximum())
def useLayerExtent(self):
CANVAS_KEY = 'Use canvas extent'
extentsDict = {}
extentsDict[CANVAS_KEY] = {
"extent": iface.mapCanvas().extent(),
"authid":
iface.mapCanvas().mapRenderer().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().mapRenderer(
).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 selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def updateExtent(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = '{},{},{},{}'.format(r.xMinimum(), r.xMaximum(), r.yMinimum(),
r.yMaximum())
self.leText.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if unicode(self.leText.text()).strip() != '':
return unicode(self.leText.text())
else:
return self.getMinCoveringExtent()
def setExtentFromString(self, s):
self.leText.setText(s)
class BboxWidget(BASE, WIDGET):
def __init__(self, parent=None):
super(BboxWidget, self).__init__(parent)
self.setupUi(self)
self.dialog = None
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
def setDialog(self):
self._dialog = Dialog
def selectExtent(self):
popupmenu = QMenu()
useLayerExtentAction = QAction(
self.tr('Use layer/canvas extent'), self.btnSelect)
selectOnCanvasAction = QAction(
self.tr('Select extent on canvas'), self.btnSelect)
popupmenu.addAction(useLayerExtentAction)
popupmenu.addAction(selectOnCanvasAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
popupmenu.exec_(QCursor.pos())
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]
for layer in QgsProject.instance().mapLayers().values():
authid = layer.crs().authid()
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.setValue(extentsDict[item]["extent"], extentsDict[item]['authid'])
def selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
if self.dialog:
self.dialog.showMinimized()
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 setValue(self, value, crs_authid):
if isinstance(value, QgsRectangle):
s = '{},{},{},{}'.format(value.xMinimum(),
value.yMinimum(),
value.xMaximum(),
value.yMaximum())
elif isinstance(value, str):
s = value
else:
s = ",".join([str(v) for v in value])
s = '{},{}'.format(s, crs_authid)
self.leText.setText(s)
return True
def value(self):
return self.leText.text()
def rectangle(self):
if self.value() == '':
return None
xmin, ymin, xmax, ymax = [float(x) for x in self.value().split(',')[0:4]]
return QgsRectangle(xmin, ymin, xmax, ymax)
def crs(self):
if self.value() == '':
return None
return QgsCoordinateReferenceSystem(self.value().split(',')[4])
def isValid(self):
try:
rect = self.rectangle()
crs = self.crs()
assert crs.isValid()
return True
except:
return False
class ExtentSelectionPanel(BASE, WIDGET):
def __init__(self, dialog, param):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.dialog = dialog
self.param = param
if self.param.optional:
if hasattr(self.leText, 'setPlaceholderText'):
self.leText.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
if param.default:
tokens = param.default.split(',')
if len(tokens) == 4:
try:
float(tokens[0])
float(tokens[1])
float(tokens[2])
float(tokens[3])
self.leText.setText(param.default)
except:
pass
def selectExtent(self):
popupmenu = QMenu()
useLayerExtentAction = QAction(
self.tr('Use layer/canvas extent'), self.btnSelect)
selectOnCanvasAction = QAction(
self.tr('Select extent on canvas'), self.btnSelect)
popupmenu.addAction(useLayerExtentAction)
popupmenu.addAction(selectOnCanvasAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
if self.param.optional:
useMincoveringExtentAction = QAction(
self.tr('Use min covering extent from input layers'),
self.btnSelect)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
def useMinCoveringExtent(self):
self.leText.setText('')
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 selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def updateExtent(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = '{},{},{},{}'.format(
r.xMinimum(), r.xMaximum(), r.yMinimum(), r.yMaximum())
self.leText.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if str(self.leText.text()).strip() != '':
return str(self.leText.text())
else:
return None
def setExtentFromString(self, s):
self.leText.setText(s)
class ExtentSelectionPanel(BASE, WIDGET):
hasChanged = pyqtSignal()
def __init__(self, dialog, param):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.leText.textChanged.connect(lambda: self.hasChanged.emit())
self.dialog = dialog
self.param = param
self.crs = QgsProject.instance().crs()
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
if hasattr(self.leText, 'setPlaceholderText'):
self.leText.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.btnSelect.clicked.connect(self.selectExtent)
if iface is not None:
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
else:
self.prevMapTool = None
self.tool = None
if param.defaultValue() is not None:
context = createContext()
rect = QgsProcessingParameters.parameterAsExtent(param, {param.name(): param.defaultValue()}, context)
crs = QgsProcessingParameters.parameterAsExtentCrs(param, {param.name(): param.defaultValue()}, context)
if not rect.isNull():
try:
s = '{},{},{},{}'.format(
rect.xMinimum(), rect.xMaximum(), rect.yMinimum(), rect.yMaximum())
if crs.isValid():
s += ' [' + crs.authid() + ']'
self.crs = crs
self.leText.setText(s)
except:
pass
def selectExtent(self):
popupmenu = QMenu()
useCanvasExtentAction = QAction(
QCoreApplication.translate("ExtentSelectionPanel", 'Use Canvas Extent'),
self.btnSelect)
useLayerExtentAction = QAction(
QCoreApplication.translate("ExtentSelectionPanel", 'Use Layer Extent…'),
self.btnSelect)
selectOnCanvasAction = QAction(
self.tr('Select Extent on Canvas'), self.btnSelect)
popupmenu.addAction(useCanvasExtentAction)
popupmenu.addAction(selectOnCanvasAction)
popupmenu.addSeparator()
popupmenu.addAction(useLayerExtentAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
useCanvasExtentAction.triggered.connect(self.useCanvasExtent)
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
useMincoveringExtentAction = QAction(
self.tr('Use Min Covering Extent from Input Layers'),
self.btnSelect)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
def useMinCoveringExtent(self):
self.leText.setText('')
def useLayerExtent(self):
dlg = LayerSelectionDialog(self)
if dlg.exec_():
layer = dlg.selected_layer()
self.setValueFromRect(QgsReferencedRectangle(layer.extent(), layer.crs()))
def useCanvasExtent(self):
self.setValueFromRect(QgsReferencedRectangle(iface.mapCanvas().extent(),
iface.mapCanvas().mapSettings().destinationCrs()))
def selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def updateExtent(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = '{},{},{},{}'.format(
r.xMinimum(), r.xMaximum(), r.yMinimum(), r.yMaximum())
try:
self.crs = r.crs()
except:
self.crs = QgsProject.instance().crs()
if self.crs.isValid():
s += ' [' + self.crs.authid() + ']'
self.leText.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if str(self.leText.text()).strip() != '':
return str(self.leText.text())
else:
return None
def setExtentFromString(self, s):
self.leText.setText(s)
class ExtentSelectionPanel(BASE, WIDGET):
def __init__(self, dialog, param):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.dialog = dialog
self.param = param
self.crs = QgsProject.instance().crs()
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
if hasattr(self.leText, 'setPlaceholderText'):
self.leText.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.btnSelect.clicked.connect(self.selectExtent)
if iface is not None:
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
else:
self.prevMapTool = None
self.tool = None
if param.defaultValue() is not None:
context = createContext()
rect = QgsProcessingParameters.parameterAsExtent(param, {param.name(): param.defaultValue()}, context)
crs = QgsProcessingParameters.parameterAsExtentCrs(param, {param.name(): param.defaultValue()}, context)
if not rect.isNull():
try:
s = '{},{},{},{}'.format(
rect.xMinimum(), rect.xMaximum(), rect.yMinimum(), rect.yMaximum())
if crs.isValid():
s += ' [' + crs.authid() + ']'
self.crs = crs
self.leText.setText(s)
except:
pass
def selectExtent(self):
popupmenu = QMenu()
useLayerExtentAction = QAction(
self.tr('Use layer/canvas extent'), self.btnSelect)
selectOnCanvasAction = QAction(
self.tr('Select extent on canvas'), self.btnSelect)
popupmenu.addAction(useLayerExtentAction)
popupmenu.addAction(selectOnCanvasAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
useMincoveringExtentAction = QAction(
self.tr('Use min covering extent from input layers'),
self.btnSelect)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
def useMinCoveringExtent(self):
self.leText.setText('')
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 = QgsProcessingUtils.compatibleLayers(QgsProject.instance())
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(QgsReferencedRectangle(extentsDict[item]["extent"], QgsCoordinateReferenceSystem(extentsDict[item]["authid"])))
def selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def updateExtent(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = '{},{},{},{}'.format(
r.xMinimum(), r.xMaximum(), r.yMinimum(), r.yMaximum())
try:
self.crs = r.crs()
except:
self.crs = QgsProject.instance().crs()
if self.crs.isValid():
s += ' [' + self.crs.authid() + ']'
self.leText.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if str(self.leText.text()).strip() != '':
return str(self.leText.text())
else:
return None
def setExtentFromString(self, s):
self.leText.setText(s)
class ExtentSelectionPanel(QWidget, Ui_Form):
def __init__(self, dialog, alg, default):
QWidget.__init__(self)
self.setupUi(self)
self.dialog = dialog
self.params = alg.parameters
if self.canUseAutoExtent():
if hasattr(self.leText, 'setPlaceholderText'):
self.leText.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
def canUseAutoExtent(self):
for param in self.params:
if isinstance(param, (ParameterRaster, ParameterVector)):
return True
if isinstance(param, ParameterMultipleInput):
return True
return False
def selectExtent(self):
popupmenu = QMenu()
useLayerExtentAction = QAction(self.tr('Use layer/canvas extent'),
self.btnSelect)
selectOnCanvasAction = QAction(self.tr('Select extent on canvas'),
self.btnSelect)
popupmenu.addAction(useLayerExtentAction)
popupmenu.addAction(selectOnCanvasAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
if self.canUseAutoExtent():
useMincoveringExtentAction = QAction(
self.tr('Use min covering extent from input layers'),
self.btnSelect)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
def useMinCoveringExtent(self):
self.leText.setText('')
def getMinCoveringExtent(self):
first = True
found = False
for param in self.params:
if param.value:
if isinstance(param, (ParameterRaster, ParameterVector)):
if isinstance(param.value,
(QgsRasterLayer, QgsVectorLayer)):
layer = param.value
else:
layer = dataobjects.getObjectFromUri(param.value)
if layer:
found = True
self.addToRegion(layer, first)
first = False
elif isinstance(param, ParameterMultipleInput):
layers = param.value.split(';')
for layername in layers:
layer = dataobjects.getObjectFromUri(layername, first)
if layer:
found = True
self.addToRegion(layer, first)
first = False
if found:
return '{},{},{},{}'.format(self.xmin, self.xmax, self.ymin,
self.ymax)
else:
return None
def useNewAlg(self, alg):
self.params = alg.parameters
def addToRegion(self, layer, first):
if first:
self.xmin = layer.extent().xMinimum()
self.xmax = layer.extent().xMaximum()
self.ymin = layer.extent().yMinimum()
self.ymax = layer.extent().yMaximum()
else:
self.xmin = min(self.xmin, layer.extent().xMinimum())
self.xmax = max(self.xmax, layer.extent().xMaximum())
self.ymin = min(self.ymin, layer.extent().yMinimum())
self.ymax = max(self.ymax, layer.extent().yMaximum())
def useLayerExtent(self):
CANVAS_KEY = 'Use canvas extent'
extentsDict = {}
extentsDict[CANVAS_KEY] = iface.mapCanvas().extent()
extents = [CANVAS_KEY]
layers = dataobjects.getAllLayers()
for layer in layers:
extents.append(layer.name())
extentsDict[layer.name()] = layer.extent()
(item, ok) = QInputDialog.getItem(self, self.tr('Select extent'),
self.tr('Use extent from'), extents,
False)
if ok:
self.setValueFromRect(extentsDict[item])
def selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def updateExtent(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = '{},{},{},{}'.format(r.xMinimum(), r.xMaximum(), r.yMinimum(),
r.yMaximum())
self.leText.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if str(self.leText.text()).strip() != '':
return unicode(self.leText.text())
else:
return self.getMinCoveringExtent()
class ExtentSelectionPanel(BASE, WIDGET):
def __init__(self, dialog, alg, default=None):
super(ExtentSelectionPanel, self).__init__(None)
self.setupUi(self)
self.dialog = dialog
self.params = alg.parameters
if self.canUseAutoExtent():
if hasattr(self.leText, "setPlaceholderText"):
self.leText.setPlaceholderText(self.tr("[Leave blank to use min covering extent]"))
self.btnSelect.clicked.connect(self.selectExtent)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.tool.rectangleCreated.connect(self.updateExtent)
if default:
tokens = unicode(default).split(",")
if len(tokens) == 4:
try:
float(tokens[0])
float(tokens[1])
float(tokens[2])
float(tokens[3])
self.leText.setText(unicode(default))
except:
pass
def canUseAutoExtent(self):
for param in self.params:
if isinstance(param, (ParameterRaster, ParameterVector)):
return True
if isinstance(param, ParameterMultipleInput):
return True
return False
def selectExtent(self):
popupmenu = QMenu()
useLayerExtentAction = QAction(self.tr("Use layer/canvas extent"), self.btnSelect)
selectOnCanvasAction = QAction(self.tr("Select extent on canvas"), self.btnSelect)
popupmenu.addAction(useLayerExtentAction)
popupmenu.addAction(selectOnCanvasAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
if self.canUseAutoExtent():
useMincoveringExtentAction = QAction(self.tr("Use min covering extent from input layers"), self.btnSelect)
useMincoveringExtentAction.triggered.connect(self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
def useMinCoveringExtent(self):
self.leText.setText("")
def getMinCoveringExtent(self):
first = True
found = False
for param in self.params:
if param.value:
if isinstance(param, (ParameterRaster, ParameterVector)):
if isinstance(param.value, (QgsRasterLayer, QgsVectorLayer)):
layer = param.value
else:
layer = dataobjects.getObject(param.value)
if layer:
found = True
self.addToRegion(layer, first)
first = False
elif isinstance(param, ParameterMultipleInput):
layers = param.value.split(";")
for layername in layers:
layer = dataobjects.getObject(layername)
if layer:
found = True
self.addToRegion(layer, first)
first = False
if found:
return "{},{},{},{}".format(self.xmin, self.xmax, self.ymin, self.ymax)
else:
return None
def useNewAlg(self, alg):
self.params = alg.parameters
def addToRegion(self, layer, first):
if first:
self.xmin = layer.extent().xMinimum()
self.xmax = layer.extent().xMaximum()
self.ymin = layer.extent().yMinimum()
self.ymax = layer.extent().yMaximum()
else:
self.xmin = min(self.xmin, layer.extent().xMinimum())
self.xmax = max(self.xmax, layer.extent().xMaximum())
self.ymin = min(self.ymin, layer.extent().yMinimum())
self.ymax = max(self.ymax, layer.extent().yMaximum())
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 selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def updateExtent(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = "{},{},{},{}".format(r.xMinimum(), r.xMaximum(), r.yMinimum(), r.yMaximum())
self.leText.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if unicode(self.leText.text()).strip() != "":
return unicode(self.leText.text())
else:
return self.getMinCoveringExtent()
def setExtentFromString(self, s):
self.leText.setText(s)
class ScenePropertyPage(PropertyPage, Ui_ScenePropertiesWidget):
def __init__(self, parent=None):
PropertyPage.__init__(self, PAGE_SCENE, parent)
Ui_ScenePropertiesWidget.setupUi(self, self)
widgets = [
self.radioButton_FixedExtent, self.lineEdit_CenterX,
self.lineEdit_CenterY, self.lineEdit_Width, self.lineEdit_Height,
self.lineEdit_Rotation, self.checkBox_FixAspectRatio,
self.lineEdit_BaseSize, self.lineEdit_zFactor,
self.lineEdit_zShift, self.checkBox_autoZShift,
self.comboBox_MaterialType, self.checkBox_Outline,
self.radioButton_Color, self.colorButton_Color,
self.radioButton_WGS84
]
self.registerPropertyWidgets(widgets)
# material type
self.comboBox_MaterialType.addItem("Lambert Material",
MaterialManager.MESH_LAMBERT)
self.comboBox_MaterialType.addItem("Phong Material",
MaterialManager.MESH_PHONG)
self.comboBox_MaterialType.addItem("Toon Material",
MaterialManager.MESH_TOON)
self.radioButton_FixedExtent.toggled.connect(self.fixedExtentToggled)
self.lineEdit_Width.editingFinished.connect(self.widthEditingFinished)
self.pushButton_SelectExtent.clicked.connect(self.showSelectExtentMenu)
self.checkBox_FixAspectRatio.toggled.connect(
self.fixAspectRatioToggled)
def setup(self, properties, mapSettings):
self.mapSettings = mapSettings
# restore properties
if properties:
self.setProperties(properties)
else:
self.radioButton_UseCanvasExtent.setChecked(True)
self.lineEdit_BaseSize.setText(str(DEF_SETS.BASE_SIZE))
self.lineEdit_zFactor.setText(str(DEF_SETS.Z_EXAGGERATION))
self.lineEdit_zShift.setText(str(DEF_SETS.Z_SHIFT))
self.checkBox_autoZShift.setChecked(DEF_SETS.AUTO_Z_SHIFT)
# map extent (2D)
if self.radioButton_UseCanvasExtent.isChecked():
self.fixedExtentToggled(False)
# Supported projections
# https://github.com/proj4js/proj4js
projs = ["longlat", "merc"]
projs += [
"aea", "aeqd", "cass", "cea", "eqc", "eqdc", "gnom", "krovak",
"laea", "lcc", "mill", "moll", "nzmg", "omerc", "poly", "sinu",
"somerc", "stere", "sterea", "tmerc", "utm", "vandg"
]
proj = QgsProject.instance().crs().toProj4()
m = re.search(r"\+proj=(\w+)", proj)
proj_supported = bool(m and m.group(1) in projs)
if not proj_supported:
self.radioButton_ProjectCRS.setChecked(True)
self.radioButton_WGS84.setEnabled(proj_supported)
def initMapTool(self, canvas):
try:
self.canvas = canvas
self.prevMapTool = canvas.mapTool()
self.mapTool = RectangleMapTool(canvas)
self.mapTool.rectangleCreated.connect(self.updateExtent)
return True
except:
#TODO: hide button
return False
def properties(self):
p = PropertyPage.properties(self)
# check validity
if not is_number(self.lineEdit_BaseSize.text()):
p["lineEdit_BaseSize"] = str(DEF_SETS.BASE_SIZE)
if not is_number(self.lineEdit_zFactor.text()):
p["lineEdit_zFactor"] = str(DEF_SETS.Z_EXAGGERATION)
if not is_number(self.lineEdit_zShift.text()):
p["lineEdit_zShift"] = str(DEF_SETS.Z_SHIFT)
return p
def setExtent(self, extent=None):
be = extent or MapExtent.fromMapSettings(
self.mapSettings, self.checkBox_FixAspectRatio.isChecked())
self.lineEdit_CenterX.setText(str(be.center().x()))
self.lineEdit_CenterY.setText(str(be.center().y()))
self.lineEdit_Width.setText(str(be.width()))
self.lineEdit_Height.setText(str(be.height()))
self.lineEdit_Rotation.setText(str(be.rotation()))
for i in range(self.gridLayout_Extent.count()):
w = self.gridLayout_Extent.itemAt(i).widget()
if isinstance(w, QLineEdit):
w.setCursorPosition(0)
def fixedExtentToggled(self, checked):
self.setLayoutEnabled(self.gridLayout_Extent, checked)
if checked:
if self.checkBox_FixAspectRatio.isChecked():
self.fixAspectRatioToggled(True)
else:
self.setExtent()
def fixAspectRatioToggled(self, checked):
if self.radioButton_FixedExtent.isChecked():
self.lineEdit_Height.setEnabled(not checked)
if checked:
try:
w, h = (float(self.lineEdit_Width.text()),
float(self.lineEdit_Height.text()))
if w > h:
self.lineEdit_Height.setText(
self.lineEdit_Width.text())
else:
self.lineEdit_Width.setText(
self.lineEdit_Height.text())
self.lineEdit_Width.setCursorPosition(0)
self.lineEdit_Height.setCursorPosition(0)
except ValueError:
pass
else:
self.setExtent()
def widthEditingFinished(self):
if self.checkBox_FixAspectRatio.isChecked():
self.lineEdit_Height.setText(self.lineEdit_Width.text())
self.lineEdit_Height.setCursorPosition(0)
def showSelectExtentMenu(self):
popup = QMenu()
selectOnCanvasAction = QAction("Select Extent on Canvas",
self.pushButton_SelectExtent)
useLayerExtentAction = QAction("Use Layer Extent...",
self.pushButton_SelectExtent)
popup.addAction(selectOnCanvasAction)
popup.addSeparator()
popup.addAction(useLayerExtentAction)
selectOnCanvasAction.triggered.connect(self.selectExtentOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
popup.exec_(QCursor.pos())
def selectExtentOnCanvas(self):
if self.canvas:
self.canvas.setMapTool(self.mapTool)
self.dialog.wnd.showMinimized()
def updateExtent(self):
self.checkBox_FixAspectRatio.setChecked(False)
r = self.mapTool.rectangle()
extent = MapExtent(
r.center(), r.width(), r.height(),
self.canvas.mapSettings().rotation()) # get current map settings
self.setExtent(extent)
self.mapTool.reset()
self.canvas.setMapTool(self.prevMapTool)
wnd = self.dialog.wnd
wnd.showNormal()
wnd.activateWindow()
def useLayerExtent(self):
from .layerselectdialog import SingleLayerSelectDialog
dlg = SingleLayerSelectDialog(self, "Use extent from")
dlg.setWindowTitle("Select Extent")
if dlg.exec_():
layer = dlg.selectedLayer()
transform = QgsCoordinateTransform(
layer.crs(), self.mapSettings.destinationCrs(),
QgsProject.instance())
r = transform.transformBoundingBox(layer.extent())
self.checkBox_FixAspectRatio.setChecked(False)
extent = MapExtent(r.center(), r.width(), r.height())
self.setExtent(extent)
class ExtentSelector(QWidget, FORM_CLASS):
"""Helper widget to provide extent selection functionality.
Mimics the UI behaviour of the qgis.processing.gui.ExtentSelectionPanel
"""
EXTRACT_REGEX = r'(-?\d+(\.\d+)?) (-?\d+(\.\d+)?), (-?\d+(\.\d+)?) (-?\d+(\.\d+)?) \[(EPSG:(\d{2,}))\]'
def __init__(self, parent=None, iface=None, filters=None):
"""Constructor."""
super(ExtentSelector, self).__init__(parent)
self.setupUi(self)
# self.dialog is used by RectangleMapTool!!!
self.dialog = parent
self.iface = iface if iface else qgis.utils.iface
self.canvas = iface.mapCanvas()
self.prev_map_tool = self.canvas.mapTool()
self.tool = RectangleMapTool(self.canvas)
self.tool.rectangleCreated.connect(self.on_tool_update_extent)
self.actionCanvas = QAction('Use canvas extent', self.menuButton)
self.actionLayer = QAction('Use layer extent', self.menuButton)
self.actionSelection = QAction('Draw extent...', self.menuButton)
self.actionCanvas.setToolTip('')
self.actionLayer.setToolTip('')
self.actionSelection.setToolTip('')
self.menu = QMenu()
self.menu.addAction(self.actionCanvas)
self.menu.addAction(self.actionLayer)
self.menu.addSeparator()
self.menu.addAction(self.actionSelection)
self.menuButton.setMenu(self.menu)
self.extent_layer_dialog = self._init_extent_layer_dialog()
self.actionCanvas.triggered.connect(self.on_action_canvas_triggered)
self.actionLayer.triggered.connect(self.on_action_layer_triggered)
self.actionSelection.triggered.connect(
self.on_action_selection_triggered)
self.extent_layer_dialog.accepted.connect(
self.on_extent_layer_dialog_accepted)
self.lineEdit.textChanged.connect(self.on_line_textchanged)
def _init_extent_layer_dialog(self, filters=QgsMapLayerProxyModel.All):
dialog = QDialog()
layout = QVBoxLayout()
buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, dialog)
layer_combobox = QgsMapLayerComboBox()
layout.addWidget(layer_combobox)
layout.addWidget(buttons)
layer_combobox.setFilters(filters)
layer_combobox.setAccessibleName('')
dialog.setModal(True)
dialog.setLayout(layout)
buttons.accepted.connect(dialog.accept)
buttons.rejected.connect(dialog.reject)
# ugly, but better to keep the function as pure as possible pure.
# I guess it begs for it's own class
dialog.layer_combobox = layer_combobox
return dialog
def is_valid(self, value=None):
"""Check if input string is valid."""
if value is None:
value = self.lineEdit.text()
if re.match(self.EXTRACT_REGEX, value):
return True
else:
return False
def value(self):
"""Mimic the QT API to get the value."""
# Even though it is more work, everytime we should convert the
# rectangle to string and then parse the string back to a rectangle.
# This way there is only single source of
# truth and will keep away a lot of tricky bugs
value = self.lineEdit.text().strip()
if not self.is_valid(value):
return None
[x1, _, y1, _, x2, _, y2, _, epsg,
crs_code] = re.findall(self.EXTRACT_REGEX, value)[0]
p1 = QgsPointXY(float(x1), float(y1))
p2 = QgsPointXY(float(x2), float(y2))
rect = QgsReferencedRectangle(
QgsRectangle(p1, p2), QgsCoordinateReferenceSystem(int(crs_code)))
return rect
def toggle_line_validity(self, is_valid=None):
"""Set the input with red class if not valid."""
if is_valid is None:
is_valid = self.is_valid()
if is_valid:
self.lineEdit.setStyleSheet('color: inherit;')
else:
self.lineEdit.setStyleSheet('color: red;')
def on_line_textchanged(self, value):
"""Triggered when the input changes, even programatically."""
self.toggle_line_validity()
def on_extent_layer_dialog_accepted(self):
"""Triggered when a layer is selected and dialog accepted."""
layer = self.extent_layer_dialog.layer_combobox.currentLayer()
self.set_value_from_layer(layer)
def on_action_canvas_triggered(self):
"""Triggered when menu action "canvas" is clicked."""
self.set_value_from_rect(self.canvas.extent())
def on_action_layer_triggered(self, filters):
"""Triggered when menu action "layer" is clicked."""
self.extent_layer_dialog.show()
def on_action_selection_triggered(self):
"""Triggered when menu action "selection" is clicked."""
self.prev_map_tool = self.canvas.mapTool()
self.canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def on_tool_update_extent(self):
"""Triggered when the map tool finishes drawing a rectangle."""
rect = self.tool.rectangle()
self.set_value_from_rect(rect)
self.tool.reset()
self.canvas.setMapTool(self.prev_map_tool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def set_value_from_str(self, value, crs=None):
"""Set the coordinates from the coordinates string.
If no CRS provided, gets the one from the project.
There should be no CRS in the string!
"""
# don't cache current project, as it may be changed
crs = QgsProject.instance().crs() if not crs else crs
if crs.isValid():
value += ' [' + crs.authid() + ']'
self.toggle_line_validity()
self.lineEdit.setText(value)
def set_value_from_layer(self, layer):
"""Set the coordinates to the passed layer extent."""
self.set_value_from_rect(layer.extent(), layer.crs())
def set_value_from_rect(self, rect, crs=None):
"""Set the coordinates from the passed rectangle extent.
If no CRS provided, tries to obtain it from the rectangle.
"""
value = rect.asWktCoordinates()
crs = rect.crs() if isinstance(rect, QgsReferencedRectangle) else crs
self.set_value_from_str(value, crs)
class ExtentSelectionPanel(QtGui.QWidget):
def __init__(self, dialog, alg, default):
super(ExtentSelectionPanel, self).__init__(None)
self.dialog = dialog
self.params = alg.parameters
self.horizontalLayout = QtGui.QHBoxLayout(self)
self.horizontalLayout.setSpacing(2)
self.horizontalLayout.setMargin(0)
self.text = QtGui.QLineEdit()
self.text.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
if self.canUseAutoExtent():
if hasattr(self.text, 'setPlaceholderText'):
self.text.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.horizontalLayout.addWidget(self.text)
self.pushButton = QtGui.QPushButton()
self.pushButton.setText('...')
self.pushButton.clicked.connect(self.buttonPushed)
self.horizontalLayout.addWidget(self.pushButton)
self.setLayout(self.horizontalLayout)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.connect(self.tool, SIGNAL('rectangleCreated()'), self.fillCoords)
def canUseAutoExtent(self):
for param in self.params:
if isinstance(param, (ParameterRaster, ParameterVector)):
return True
if isinstance(param, ParameterMultipleInput):
return True
return False
def buttonPushed(self):
popupmenu = QMenu()
useLayerExtentAction = QtGui.QAction(self.tr('Use layer/canvas extent'),
self.pushButton)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
popupmenu.addAction(useLayerExtentAction)
selectOnCanvasAction = QtGui.QAction(self.tr('Select extent on canvas'),
self.pushButton)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
popupmenu.addAction(selectOnCanvasAction)
if self.canUseAutoExtent():
useMincoveringExtentAction = \
QtGui.QAction(self.tr('Use min covering extent from input layers'),
self.pushButton)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QtGui.QCursor.pos())
def useMinCoveringExtent(self):
self.text.setText('')
def getMinCoveringExtent(self):
first = True
found = False
for param in self.params:
if param.value:
if isinstance(param, (ParameterRaster, ParameterVector)):
if isinstance(param.value, (QgsRasterLayer,
QgsVectorLayer)):
layer = param.value
else:
layer = dataobjects.getObjectFromUri(param.value)
if layer:
found = True
self.addToRegion(layer, first)
first = False
elif isinstance(param, ParameterMultipleInput):
layers = param.value.split(';')
for layername in layers:
layer = dataobjects.getObjectFromUri(layername, first)
if layer:
found = True
self.addToRegion(layer, first)
first = False
if found:
return str(self.xmin) + ',' + str(self.xmax) + ',' \
+ str(self.ymin) + ',' + str(self.ymax)
else:
return None
def useNewAlg(self, alg):
self.params = alg.parameters
def addToRegion(self, layer, first):
if first:
self.xmin = layer.extent().xMinimum()
self.xmax = layer.extent().xMaximum()
self.ymin = layer.extent().yMinimum()
self.ymax = layer.extent().yMaximum()
else:
self.xmin = min(self.xmin, layer.extent().xMinimum())
self.xmax = max(self.xmax, layer.extent().xMaximum())
self.ymin = min(self.ymin, layer.extent().yMinimum())
self.ymax = max(self.ymax, layer.extent().yMaximum())
def useLayerExtent(self):
CANVAS_KEY = 'Use canvas extent'
extentsDict = {}
extentsDict[CANVAS_KEY] = iface.mapCanvas().extent()
extents = [CANVAS_KEY]
layers = dataobjects.getAllLayers()
for layer in layers:
extents.append(layer.name())
extentsDict[layer.name()] = layer.extent()
(item, ok) = QtGui.QInputDialog.getItem(self, 'Select extent',
'Use extent from', extents, False)
if ok:
self.setValueFromRect(extentsDict[item])
def selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def fillCoords(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = str(r.xMinimum()) + ',' + str(r.xMaximum()) + ',' \
+ str(r.yMinimum()) + ',' + str(r.yMaximum())
self.text.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if str(self.text.text()).strip() != '':
return str(self.text.text())
else:
return self.getMinCoveringExtent()
class ExtentSelectionPanel(QtGui.QWidget):
def __init__(self, dialog, alg, default):
super(ExtentSelectionPanel, self).__init__(None)
self.dialog = dialog
self.params = alg.parameters
self.horizontalLayout = QtGui.QHBoxLayout(self)
self.horizontalLayout.setSpacing(2)
self.horizontalLayout.setMargin(0)
self.text = QtGui.QLineEdit()
self.text.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
if self.canUseAutoExtent():
if hasattr(self.text, 'setPlaceholderText'):
self.text.setPlaceholderText(
self.tr('[Leave blank to use min covering extent]'))
self.horizontalLayout.addWidget(self.text)
self.pushButton = QtGui.QPushButton()
self.pushButton.setText('...')
self.pushButton.clicked.connect(self.buttonPushed)
self.horizontalLayout.addWidget(self.pushButton)
self.setLayout(self.horizontalLayout)
canvas = iface.mapCanvas()
self.prevMapTool = canvas.mapTool()
self.tool = RectangleMapTool(canvas)
self.connect(self.tool, SIGNAL('rectangleCreated()'), self.fillCoords)
def canUseAutoExtent(self):
for param in self.params:
if isinstance(param, (ParameterRaster, ParameterVector)):
return True
if isinstance(param, ParameterMultipleInput):
return True
return False
def buttonPushed(self):
popupmenu = QMenu()
useLayerExtentAction = QtGui.QAction(
self.tr('Use layer/canvas extent'), self.pushButton)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
popupmenu.addAction(useLayerExtentAction)
selectOnCanvasAction = QtGui.QAction(
self.tr('Select extent on canvas'), self.pushButton)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
popupmenu.addAction(selectOnCanvasAction)
if self.canUseAutoExtent():
useMincoveringExtentAction = \
QtGui.QAction(self.tr('Use min covering extent from input layers'),
self.pushButton)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QtGui.QCursor.pos())
def useMinCoveringExtent(self):
self.text.setText('')
def getMinCoveringExtent(self):
first = True
found = False
for param in self.params:
if param.value:
if isinstance(param, (ParameterRaster, ParameterVector)):
if isinstance(param.value,
(QgsRasterLayer, QgsVectorLayer)):
layer = param.value
else:
layer = dataobjects.getObjectFromUri(param.value)
if layer:
found = True
self.addToRegion(layer, first)
first = False
elif isinstance(param, ParameterMultipleInput):
layers = param.value.split(';')
for layername in layers:
layer = dataobjects.getObjectFromUri(layername, first)
if layer:
found = True
self.addToRegion(layer, first)
first = False
if found:
return str(self.xmin) + ',' + str(self.xmax) + ',' \
+ str(self.ymin) + ',' + str(self.ymax)
else:
return None
def useNewAlg(self, alg):
self.params = alg.parameters
def addToRegion(self, layer, first):
if first:
self.xmin = layer.extent().xMinimum()
self.xmax = layer.extent().xMaximum()
self.ymin = layer.extent().yMinimum()
self.ymax = layer.extent().yMaximum()
else:
self.xmin = min(self.xmin, layer.extent().xMinimum())
self.xmax = max(self.xmax, layer.extent().xMaximum())
self.ymin = min(self.ymin, layer.extent().yMinimum())
self.ymax = max(self.ymax, layer.extent().yMaximum())
def useLayerExtent(self):
CANVAS_KEY = 'Use canvas extent'
extentsDict = {}
extentsDict[CANVAS_KEY] = iface.mapCanvas().extent()
extents = [CANVAS_KEY]
layers = dataobjects.getAllLayers()
for layer in layers:
extents.append(layer.name())
extentsDict[layer.name()] = layer.extent()
(item, ok) = QtGui.QInputDialog.getItem(self, 'Select extent',
'Use extent from', extents,
False)
if ok:
self.setValueFromRect(extentsDict[item])
def selectOnCanvas(self):
canvas = iface.mapCanvas()
canvas.setMapTool(self.tool)
self.dialog.showMinimized()
def fillCoords(self):
r = self.tool.rectangle()
self.setValueFromRect(r)
def setValueFromRect(self, r):
s = str(r.xMinimum()) + ',' + str(r.xMaximum()) + ',' \
+ str(r.yMinimum()) + ',' + str(r.yMaximum())
self.text.setText(s)
self.tool.reset()
canvas = iface.mapCanvas()
canvas.setMapTool(self.prevMapTool)
self.dialog.showNormal()
self.dialog.raise_()
self.dialog.activateWindow()
def getValue(self):
if str(self.text.text()).strip() != '':
return str(self.text.text())
else:
return self.getMinCoveringExtent()
