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(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, 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 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 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): 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 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 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 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 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()
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 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