def getSnapRubberBand(self): rubberBand = QgsRubberBand(self.canvas, geometryType = QGis.Point) rubberBand.setFillColor(QColor(255, 0, 0, 40)) rubberBand.setBorderColor(QColor(255, 0, 0, 200)) rubberBand.setWidth(2) rubberBand.setIcon(QgsRubberBand.ICON_X) return rubberBand
def highlight(): rb = QgsRubberBand( self.canvas, QGis.Polygon) rb.setBorderColor( QColor( 255, 0, 0 ) ) rb.setWidth( 2 ) rb.setToGeometry( geomRB, None ) return rb
def addGraphic(self, geom ): canvas = self.iface.mapCanvas() rBand = QgsRubberBand(canvas, True) self.graphics.append( rBand ) rBand.setToGeometry( geom, None ) rBand.setColor(QtGui.QColor(0,0,255, 70)) if QGis.QGIS_VERSION_INT >= 20600: rBand.setBorderColor( QtGui.QColor(0,0,250, 220) ) rBand.setWidth(3)
def getRubberBand(self): geomType = self.iface.activeLayer().geometryType() if geomType == QGis.Polygon: rubberBand = QgsRubberBand(self.canvas, True) rubberBand.setFillColor(QColor(255, 0, 0, 40)) elif geomType == QGis.Line: rubberBand = QgsRubberBand(self.canvas, False) rubberBand.setBorderColor(QColor(255, 0, 0, 200)) rubberBand.setWidth(2) return rubberBand
def onClickedHighlight(self): def removeRB(): rb.reset( True ) self.qgisCanvas.scene().removeItem( rb ) rb = QgsRubberBand( self.qgisCanvas, QGis.Polygon) rb.setBorderColor( QColor( 255, 0, 0 ) ) rb.setWidth( 2 ) rb.setToGeometry( QgsGeometry.fromRect( self.canvas.extent() ), None ) QTimer.singleShot( 2000, removeRB )
class RubberBandPolygon(QgsMapTool): def __init__(self, canvas): QgsMapTool.__init__(self, canvas) self.mCanvas = canvas self.mRubberBand = None self.mRubberBand0 = QgsRubberBand(self.mCanvas, QGis.Polygon) self.mCursor = Qt.ArrowCursor self.mFillColor = QColor(254, 178, 76, 63) self.mBorderColour = QColor(254, 58, 29, 100) self.mRubberBand0.setBorderColor(self.mBorderColour) self.polygonGeom = None self.drawFlag = False # self.constructionLayer = constructionLayer def canvasPressEvent(self, e): if (self.mRubberBand == None): self.mRubberBand0.reset(QGis.Polygon) # define._canvas.clearCache () self.mRubberBand = QgsRubberBand(self.mCanvas, QGis.Polygon) self.mRubberBand0 = QgsRubberBand(self.mCanvas, QGis.Polygon) self.mRubberBand.setFillColor(self.mFillColor) self.mRubberBand.setBorderColor(self.mBorderColour) self.mRubberBand0.setFillColor(self.mFillColor) self.mRubberBand0.setBorderColor(self.mBorderColour) if (e.button() == Qt.LeftButton): self.mRubberBand.addPoint(self.toMapCoordinates(e.pos())) else: if (self.mRubberBand.numberOfVertices() > 2): self.polygonGeom = self.mRubberBand.asGeometry() else: return # QgsMapToolSelectUtils.setSelectFeatures( self.mCanvas, polygonGeom, e ) self.mRubberBand.reset(QGis.Polygon) self.mRubberBand0.addGeometry(self.polygonGeom, None) self.mRubberBand0.show() self.mRubberBand = None self.emit(SIGNAL("outputResult"), self.polygonGeom) def canvasMoveEvent(self, e): pass if (self.mRubberBand == None): return if (self.mRubberBand.numberOfVertices() > 0): self.mRubberBand.removeLastPoint(0) self.mRubberBand.addPoint(self.toMapCoordinates(e.pos())) def deactivate(self): # self.rubberBand.reset(QGis.Point) QgsMapTool.deactivate(self) self.emit(SIGNAL("deactivated()"))
def btnPreview_Click(self): self.priviewClickFlag = not self.priviewClickFlag if not self.priviewClickFlag: QgisHelper.ClearRubberBandInCanvas(define._canvas) return if self.comboBox.currentIndex() == ProtectionAreaType.Primary: rBand = QgsRubberBand(define._canvas, QGis.Polygon) for point in self.area.PreviewArea.method_14(): rBand.addPoint(point) rBand.setFillColor( QtGui.QColor(46, 64, 142, 100) ) rBand.setBorderColor( QtGui.QColor(0, 10, 238) ) rBand.show() elif self.comboBox.currentIndex() == ProtectionAreaType.Secondary: rBand = QgsRubberBand(define._canvas, QGis.Polygon) if isinstance(self.area, SecondaryObstacleAreaWithManyPoints): for point in self.area.PreviewArea.method_14(): rBand.addPoint(point) rBand.setFillColor( QtGui.QColor(46, 64, 142, 100) ) rBand.setBorderColor( QtGui.QColor(0, 10, 238) ) rBand.show() else: for point in self.area.area.PreviewArea.method_14(): rBand.addPoint(point) rBand.setFillColor( QtGui.QColor(46, 64, 142, 100) ) rBand.setBorderColor( QtGui.QColor(0, 10, 238) ) rBand.show() elif self.comboBox.currentIndex() == ProtectionAreaType.PrimaryAndSecondary: rBand = QgsRubberBand(define._canvas, QGis.Polygon) for point in self.area.primaryArea.PreviewArea.method_14(): rBand.addPoint(point) rBand.setFillColor( QtGui.QColor(46, 64, 142, 100) ) rBand.setBorderColor( QtGui.QColor(0, 10, 238) ) rBand.show() rBand = QgsRubberBand(define._canvas, QGis.Polygon) for point in self.area.secondaryArea1.PreviewArea.method_14(): rBand.addPoint(point) rBand.setFillColor( QtGui.QColor(46, 64, 142, 100) ) rBand.setBorderColor( QtGui.QColor(0, 10, 238) ) rBand.show() rBand = QgsRubberBand(define._canvas, QGis.Polygon) for point in self.area.secondaryArea2.PreviewArea.method_14(): rBand.addPoint(point) rBand.setFillColor( QtGui.QColor(46, 64, 142, 100) ) rBand.setBorderColor( QtGui.QColor(0, 10, 238) ) rBand.show() else: for obstacleArea in self.area: if isinstance(obstacleArea, PrimaryObstacleArea): rBand = QgsRubberBand(define._canvas, QGis.Polygon) for point in obstacleArea.PreviewArea.method_14(): rBand.addPoint(point) rBand.setFillColor( QtGui.QColor(46, 64, 142, 100) ) rBand.setBorderColor( QtGui.QColor(0, 10, 238) ) rBand.show() else: rBand = QgsRubberBand(define._canvas, QGis.Polygon) if isinstance(obstacleArea, SecondaryObstacleAreaWithManyPoints): for point in obstacleArea.PreviewArea.method_14(): rBand.addPoint(point) rBand.setFillColor( QtGui.QColor(46, 64, 142, 100) ) rBand.setBorderColor( QtGui.QColor(0, 10, 238) ) rBand.show() else: for point in obstacleArea.area.PreviewArea.method_14(): rBand.addPoint(point) rBand.setFillColor( QtGui.QColor(46, 64, 142, 100) ) rBand.setBorderColor( QtGui.QColor(0, 10, 238) ) rBand.show() define._canvas.refresh()
class ReshapeGeom(): def __init__(self, iface): self.iface = iface def initGui(self): # cria uma ação que iniciará a configuração do plugin self.initVariables() self.initSignals() def initVariables(self): # Criação da action e da toolbar self.toolbar = self.iface.addToolBar("Reshape") path = self.iface.mainWindow() icon_path = ':/plugins/ReshapeGeom/icon.png' self.action = QAction(QIcon(icon_path), u"Reshape feature.", path) self.action.setObjectName("ReshapeGeom") self.action.setStatusTip(None) self.action.setWhatsThis(None) self.action.setCheckable(True) self.toolbar.addAction(self.action) self.lastButton = Qt.RightButton self.controlStatus = False self.createRubberBand() self.previousMapTool = self.iface.mapCanvas().mapTool() self.isEditing = 0 #self.start() def initSignals(self): # self.action.toggled.connect(self.initRubberBand) #self.myMapTool.canvasClicked.connect(self.mouseClick) self.iface.mapCanvas().currentLayerChanged.connect(self.start) def createRubberBand(self): self.myRubberBand = QgsRubberBand(self.iface.mapCanvas()) color = QColor(78, 97, 114) color.setAlpha(190) self.myRubberBand.setColor(color) self.myRubberBand.setFillColor(QColor(255, 0, 0, 40)) self.myRubberBand.setBorderColor(QColor(255, 0, 0, 200)) def start(self): #self.myRubberBand.reset() self.createRubberBand() # Set MapTool self.myMapTool = QgsMapToolEmitPoint(self.iface.mapCanvas()) self.iface.mapCanvas().setMapTool(self.myMapTool) self.iface.mapCanvas().xyCoordinates.connect(self.mouseMove) self.iface.mapCanvas().keyPressed.connect(self.keyPressEvent) self.iface.mapCanvas().keyReleased.connect(self.keyReleaseEvent) # self.myMapTool.canvasClicked.connect(self.mouseClick) def initRubberBand(self, b): if b: self.start() else: self.disconnect() def disconnect(self): self.iface.mapCanvas().setMapTool(self.previousMapTool) try: self.iface.mapCanvas().xyCoordinates.disconnect(self.mouseMove) self.myMapTool.canvasClicked.disconnect(self.mouseClick) self.isEditing = 0 self.lastButton = Qt.RightButton self.myRubberBand.reset() except: pass try: #self.myRubberBand.reset() del self.myRubberBand # del self.myMapTool except: pass def unload(self): self.disconnect() # def mouseClick(self, currentPos, clickedButton): # if self.iface.mapCanvas().currentLayer().type() != QgsMapLayer.VectorLayer: # return # else: # if self.iface.mapCanvas().currentLayer().geometryType() != QGis.Polygon and self.iface.mapCanvas().currentLayer().geometryType() != QGis.Line: # # return # if clickedButton == Qt.LeftButton: # if self.lastButton == Qt.RightButton: # self.myRubberBand.reset() # self.lastButton = Qt.LeftButton # self.isEditing = 1 # elif clickedButton == Qt.RightButton and self.myRubberBand.numberOfVertices() > 2: # self.lastButton = Qt.RightButton # self.doReshape() #____________________________________________________________________________________________________________________ def doReshape(self): self.isEditing = 0 layer = self.iface.mapCanvas().currentLayer() # layer atual layer.startEditing() # Ligando a edição da layer line = self.myRubberBand.asGeometry() # Linha do rubberband for feat in layer.getFeatures(): geom = feat.geometry() # geometria que receberá o reshape. if geom.intersects(line): # Se intersecta geom.reshapeGeometry(line.asPolyline( )) # realiza o reshape entre a linha e a geometria. layer.changeGeometry(feat.id(), geom) self.iface.mapCanvas().refresh( ) # Refresh para atualizar, mas não salvar as alterações self.myRubberBand.reset() #___________________________________________________________________________________________________________________ def mouseMove(self, currentPos): # FreeHand if self.isEditing == 1: # self.myRubberBand.movePoint(QgsPoint(currentPos)) # Rubberband self.myRubberBand.addPoint(QgsPoint(currentPos)) # Freehand def keyPressEvent(self, event): if event.key( ) == QtCore.Qt.Key_Control: #Preciso implementar o Ctrl corretamente. if self.iface.mapCanvas().currentLayer().type( ) != QgsMapLayer.VectorLayer: event.accept() elif self.controlStatus == False: self.controlStatus = True self.isEditing = 1 self.previousMapTool = self.iface.mapCanvas().mapTool() self.action.setChecked(True) self.start() else: event.accept() def keyReleaseEvent(self, event): if event.key( ) == QtCore.Qt.Key_Control: #Preciso implementar o Ctrl corretamente. #self.iface.mapCanvas().setMapTool(self.previousMapTool) if self.iface.mapCanvas().currentLayer().type( ) != QgsMapLayer.VectorLayer: event.accept() elif self.controlStatus == True: if self.myRubberBand.numberOfVertices() > 2: self.doReshape() self.controlStatus = False self.action.setChecked(False) self.iface.mapCanvas().unsetMapTool(self.myMapTool) self.iface.mapCanvas().setMapTool(self.previousMapTool) self.disconnect() else: event.accept()
class AuxiliaryWindow(QMainWindow): closed = pyqtSignal( int ) def __init__(self, parent, geometryWin, numWin): def populateStatusBar(): statusBar = self.statusBar() w = QCheckBox( "Render", self ) w.setObjectName( 'renderCheck') w.setToolTip( "Toggle map rendering" ) w.setChecked( True ) statusBar.addPermanentWidget( w ) w = QCheckBox( "Marker", self ) w.setObjectName( 'markerCheck') w.setToolTip( "Toggle marker with cursor position from main map" ) w.setChecked( False ) statusBar.addPermanentWidget( w, 1 ) w = QCheckBox( "Extent", self ) w.setObjectName( 'extentCheck') w.setToolTip( "Show extent of main map" ) w.setChecked( False ) statusBar.addPermanentWidget( w, 1 ) w = QToolButton(self) w.setObjectName( 'highlightBtn') w.setToolTip( "Highlight extent in main map" ) w.setText("Highlight") statusBar.addPermanentWidget( w, 1 ) w = QLabel( "Scale factor:", self ) w.setObjectName( 'scaleFactorLabel') w.setAlignment(Qt.AlignRight | Qt.AlignVCenter) statusBar.addPermanentWidget( w, 1 ) w = QDoubleSpinBox(self) w.setObjectName( 'scaleFactorSpin') w.setToolTip( "Current scale factor of main map" ) w.setMinimum(0.0) w.setMaximum(1000.0) w.setDecimals(3) w.setValue(1) w.setSingleStep(.05) statusBar.addPermanentWidget( w, 1 ) w = QToolButton(self) w.setObjectName( 'scaleBtn') w.setToolTip( "Set scale for main map" ) w.setText("Scale: ") statusBar.addPermanentWidget( w, 1 ) def setupUi(): self.setObjectName( "AuxiliaryWindow" ) self.setGeometry( geometryWin ) self.addDockWidget ( Qt.LeftDockWidgetArea, self.dockLegend ) self.actLegend = self.menuBar().addAction("") self.actLegend.triggered.connect( self.onActionLegend ) self.canvas.setMapTool( self.toolPan ) self.canvas.setCanvasColor( QColor(255,255,255) ) self.canvas.enableAntiAliasing( False ) self.canvas.useImageToRender( False ) self.canvas.setWheelAction( QgsMapCanvas.WheelZoom ) self.setCentralWidget( centralWidget ) self.messageBar.setSizePolicy( QSizePolicy.Minimum, QSizePolicy.Fixed ) layout = QGridLayout() layout.setContentsMargins( 0, 0, 0, 0 ) layout.addWidget( self.canvas, 0, 0, 2, 1 ) layout.addWidget( self.messageBar, 0, 0, 1, 1 ) centralWidget.setLayout( layout ) super( AuxiliaryWindow, self ).__init__( parent ) centralWidget = QWidget( self ) self.canvas = QgsMapCanvas( centralWidget ) self.messageBar = QgsMessageBar( centralWidget ) self.toolPan = QgsMapToolPan( self.canvas ) self.qgisCanvas = qgis.utils.iface.mapCanvas() self.qgisTView = qgis.utils.iface.layerTreeView() self.qgisSyncGroup = None self.numWin = numWin self.ltg = QgsLayerTreeGroup('', Qt.Unchecked) self.dockLegend = AuxiliaryLegend( self, numWin ) self.root = QgsProject.instance().layerTreeRoot() self.extent = self.actLegend = None self.marker = MarkerWindow( self.canvas ) setupUi() populateStatusBar() self.onCurrentLayerChanged( None ) self.onDestinationCrsChanged_MapUnitsChanged() self.onHasCrsTransformEnabledChanged( self.qgisCanvas.hasCrsTransformEnabled() ) def _connect(self, isConnect = True): widgets = { 'scaleBtn': self.findChild( QToolButton, 'scaleBtn'), 'renderCheck': self.findChild( QCheckBox, 'renderCheck'), 'markerCheck': self.findChild( QCheckBox, 'markerCheck'), 'extentCheck': self.findChild( QCheckBox, 'extentCheck'), 'highlightBtn': self.findChild( QToolButton, 'highlightBtn'), 'scaleFactorSpin': self.findChild( QDoubleSpinBox, 'scaleFactorSpin') } signal_slot = ( { 'signal': widgets['scaleBtn'].clicked, 'slot': self.onClickedScale }, { 'signal': widgets['renderCheck'].toggled, 'slot': self.onToggledRender }, { 'signal': widgets['markerCheck'].toggled, 'slot': self.onToggledMarker }, { 'signal': widgets['extentCheck'].toggled, 'slot': self.onToggledExtent }, { 'signal': widgets['highlightBtn'].clicked, 'slot': self.onClickedHighlight }, { 'signal': widgets['scaleFactorSpin'].valueChanged, 'slot': self.onValueChangedScale }, { 'signal': self.dockLegend.currentLayerChanged, 'slot': self.onCurrentLayerChanged }, { 'signal': self.dockLegend.currentLayerQgis, 'slot': self.onCurrentLayerQgis }, { 'signal': self.dockLegend.syncGroupLayer, 'slot': self.onSyncGroupAddLayersQgis }, { 'signal': self.dockLegend.addSelectedLayersQgis, 'slot': self.onAddSelectedLayersQgis }, { 'signal': self.dockLegend.removeLayer, 'slot': self.onRemoveLayers }, { 'signal': self.dockLegend.needSelectLayer, 'slot': self.onNeedSelectLayer }, { 'signal': self.dockLegend.closed, 'slot': self.onClosedLegend }, { 'signal': self.canvas.extentsChanged, 'slot': self.onExtentsChangedMirror }, { 'signal': self.qgisCanvas.extentsChanged, 'slot': self.onExtentsChangedQgisCanvas }, { 'signal': self.qgisCanvas.xyCoordinates, 'slot': self.marker.onXYCoordinates }, { 'signal': self.qgisCanvas.destinationCrsChanged, 'slot': self.onDestinationCrsChanged_MapUnitsChanged }, { 'signal': self.qgisCanvas.mapUnitsChanged, 'slot': self.onDestinationCrsChanged_MapUnitsChanged }, { 'signal': self.qgisCanvas.hasCrsTransformEnabledChanged, 'slot': self.onHasCrsTransformEnabledChanged }, { 'signal': self.root.removedChildren, 'slot': self.onRemovedChildrenQgisRoot }, { 'signal': QgsMapLayerRegistry.instance().layersWillBeRemoved, 'slot': self.onLayersWillBeRemoved } ) if isConnect: for item in signal_slot: item['signal'].connect( item['slot'] ) else: for item in signal_slot: item['signal'].disconnect( item['slot'] ) def _extentsChanged(self, canvasOrigin, originSlot, canvasDest, scaleFactor=None): canvasOrigin.extentsChanged.disconnect( originSlot ) if scaleFactor is None: scale = canvasOrigin.scale() canvasOrigin.setExtent( canvasDest.extent() ) canvasOrigin.zoomScale( scale ) else: canvasOrigin.setExtent( canvasDest.extent() ) canvasOrigin.zoomScale( scaleFactor * canvasDest.scale() ) canvasOrigin.extentsChanged.connect( originSlot ) def _textScaleBtnChanched(self): scale = locale.format( "%.0f", self.canvas.scale(), True ) w = self.findChild( QToolButton, 'scaleBtn' ) w.setText("Scale 1:%s" % scale ) def _extent(self): rect = self.qgisCanvas.extent() p1 = QgsPoint( rect.xMinimum() , rect.yMinimum() ) p2 = QgsPoint( rect.xMinimum() , rect.yMaximum() ) p3 = QgsPoint( rect.xMaximum() , rect.yMaximum() ) p4 = QgsPoint( rect.xMaximum() , rect.yMinimum() ) p5 = QgsPoint( rect.xMinimum() , rect.yMinimum() ) points = [ p1, p2, p3, p4, p5 ] self.extent.setToGeometry(QgsGeometry.fromPolyline (points), None) def _execFunction( self, func, arg, signal, slot): signal.disconnect( slot ) func( arg ) signal.connect( slot ) def _connectVectorRefresh(self, layer, isConnect=True): if isinstance( layer, QgsVectorLayer ): f = layer.editCommandEnded.connect if isConnect else layer.editCommandEnded.disconnect f( self.canvas.refresh ) def _addLayersQgis( self, layersQgis, needMsg=True ): self.dockLegend.clearBridge() l1 = set( layersQgis ) l2 = set( map( lambda item: item.layer(), self.ltg.findLayers() ) ) layers = list( l1 - l2 ) if len( layers ) == 0: if needMsg: self.messageBar.pushMessage("Need select new layer(s) in main map", QgsMessageBar.WARNING, 2 ) else: # Get order by layersQgis for item in layersQgis: if item in layers: self.ltg.addLayer( item ) self._connectVectorRefresh( item ) self.dockLegend.setBridge( self.canvas ) def _syncGroupAddLayersQgis( self, ltg ): layersQgis = map( lambda item: item.layer(), ltg.findLayers() ) if len( layersQgis ) == 0: return False name = ltg.name() if self.qgisSyncGroup == ltg: msg = "Already synchronized group (main map) -> '%s'" % name self.messageBar.pushMessage( msg, QgsMessageBar.INFO, 4 ) return True if not self.qgisSyncGroup is None: self.qgisSyncGroup.addedChildren.disconnect( self.addedChildrenLayer ) self.qgisSyncGroup = ltg self.qgisSyncGroup.addedChildren.connect( self.addedChildrenLayer ) self.dockLegend.addNameSyncGroup( name ) msg = "Changed synchronized group (main map) -> '%s'" % name self.messageBar.pushMessage( msg, QgsMessageBar.INFO, 4 ) self._addLayersQgis( layersQgis ) return True def run(self): if len( self.qgisTView.selectedLayerNodes() ) > 0: self.onAddSelectedLayersQgis() else: ltn = self.qgisTView.currentNode() if not isinstance( ltn, QgsLayerTreeGroup ): return False else: if ltn == self.root: return False else: if not self._syncGroupAddLayersQgis( ltn ): return False self.dockLegend.setBridge( self.canvas) self.canvas.setRenderFlag( False ) self.show() # Need show before self._connect() self._connect() self.canvas.setExtent( self.qgisCanvas.extent() ) w = self.findChild( QDoubleSpinBox, 'scaleFactorSpin') w.setValue( 1 ) self.canvas.setRenderFlag( True ) return True def getLayersCanvas(self): layerIds = map(lambda x: x.layerId(), self.ltg.findLayers() ) layerChecks = map(lambda x: str( x.isVisible() ), self.ltg.findLayers() ) return ( layerIds, layerChecks ) def setLayersCanvas(self, layerIds, layerChecks ): prevFlag = self.canvas.renderFlag() self.canvas.setRenderFlag( False ) lyrRegs = QgsMapLayerRegistry.instance() for id in range( len( layerIds ) ): layer = lyrRegs.mapLayer( layerIds[id] ) isVisible = int( layerChecks[id] ) if not layer is None: self.ltg.addLayer( layer ).setVisible( isVisible ) self.canvas.setRenderFlag( prevFlag ) def getWindowSetting(self): g = self.geometry() r = self.canvas.extent() nodes = self.ltg.findLayers() currentLayer = self.dockLegend.tview.currentLayer() currentLayerId = currentLayer.id() if not currentLayer is None else "None" windowSetting = { 'numWin': self.numWin, 'geometryWin': { 'x': g.x(), 'y': g.y(), 'width': g.width(), 'height': g.height() }, 'extentCanvas': { 'xmin': r.xMinimum(), 'ymin': r.yMinimum(), 'xmax': r.xMaximum(), 'ymax': r.yMaximum() }, 'currentLayerId': currentLayerId, 'layerIds' : ' '.join( map(lambda item: item.layerId(), nodes ) ), 'visibles': ' '.join( map(lambda item: str( int( item.isVisible() ) ), nodes ) ) } for item in ( 'render', 'marker', 'extent' ): nameGui = "%sCheck" % item windowSetting[ item ] = int( self.findChild( QCheckBox, nameGui).isChecked() ) return windowSetting def setWindowSetting(self, windowSetting): self.numWin = windowSetting['numWin'] # Populate with layers and set Bridge for legend layerIds = windowSetting['layerIds'].split(' ') visibles = map( lambda item: bool( int( item ) ), windowSetting['visibles'].split(' ') ) ltg = self.qgisTView.layerTreeModel().rootGroup() for id in range( len( layerIds ) ): node = ltg.findLayer( layerIds[ id ] ) if node is None: continue layer = node.layer() visible = Qt.Checked if visibles[ id ] else Qt.Unchecked self._connectVectorRefresh( layer ) self.ltg.addLayer( layer ).setVisible( visible ) self.dockLegend.setBridge( self.canvas) self.show() # Need show before self._connect() self._connect() node = ltg.findLayer( windowSetting['currentLayerId'] ) if not node is None: layer = node.layer() self.dockLegend.tview.setCurrentLayer( layer ) w = windowSetting['extentCanvas'] self.canvas.setExtent( QgsRectangle( w['xmin'], w['ymin'], w['xmax'], w['ymax'] ) ) for item in ( 'render', 'marker', 'extent' ): value = bool( windowSetting[ item ] ) nameGui = "%sCheck" % item self.findChild( QCheckBox, nameGui ).setChecked( value ) def closeEvent(self, event): self._connect( False ) event.accept() self.closed.emit( self.numWin ) @pyqtSlot(int) def onValueChangedScale(self, scaleFactor): w = self.findChild( QCheckBox, 'renderCheck') if not w.isChecked(): return self._execFunction( self.canvas.zoomScale, scaleFactor * self.qgisCanvas.scale(), self.canvas.extentsChanged, self.onExtentsChangedMirror ) self._textScaleBtnChanched() @pyqtSlot() def onClickedScale(self): self._execFunction( self.qgisCanvas.zoomScale, self.canvas.scale(), self.qgisCanvas.extentsChanged, self.onExtentsChangedQgisCanvas ) w = self.findChild( QDoubleSpinBox, 'scaleFactorSpin' ) self._execFunction( w.setValue, 1.0, w.valueChanged, self.onValueChangedScale ) @pyqtSlot() def onClickedHighlight(self): def removeRB(): rb.reset( True ) self.qgisCanvas.scene().removeItem( rb ) rb = QgsRubberBand( self.qgisCanvas, QGis.Polygon) rb.setBorderColor( QColor( 255, 0, 0 ) ) rb.setWidth( 2 ) rb.setToGeometry( QgsGeometry.fromRect( self.canvas.extent() ), None ) QTimer.singleShot( 2000, removeRB ) @pyqtSlot(bool) def onToggledRender(self, enabled): if enabled: self.canvas.setMapTool(self.toolPan) w = self.findChild( QDoubleSpinBox, 'scaleFactorSpin' ) self._extentsChanged( self.canvas, self.onExtentsChangedMirror, self.qgisCanvas, w.value() ) self._textScaleBtnChanched() self.canvas.setWheelAction( QgsMapCanvas.WheelZoom ) else: self.canvas.unsetMapTool(self.toolPan) self.canvas.setWheelAction( QgsMapCanvas.WheelNothing ) self.canvas.setRenderFlag( enabled ) @pyqtSlot(bool) def onToggledMarker(self, enabled): self.marker.add() if enabled else self.marker.remove() @pyqtSlot(bool) def onToggledExtent(self, enabled): def setExtent(): if not self.extent is None: self.canvas.scene().removeItem( self.extent ) self.extent = QgsRubberBand( self.canvas, QGis.Polygon ) self.extent.setBorderColor( QColor( 255, 0 , 0 ) ) self.extent.setWidth( 2 ) self._extent() if enabled: setExtent() else: if not self.extent is None: self.canvas.scene().removeItem( self.extent ) self.extent = None @pyqtSlot() def onExtentsChangedMirror(self): w = self.findChild( QCheckBox, 'renderCheck') if not w.isChecked(): return self._extentsChanged( self.qgisCanvas, self.onExtentsChangedQgisCanvas, self.canvas ) self._textScaleBtnChanched() w = self.findChild( QDoubleSpinBox, 'scaleFactorSpin' ) self._execFunction( w.setValue, self.canvas.scale() / self.qgisCanvas.scale(), w.valueChanged, self.onValueChangedScale ) if not self.extent is None: self._extent() @pyqtSlot() def onExtentsChangedQgisCanvas(self): w = self.findChild( QCheckBox, 'renderCheck') if not w.isChecked(): return w = self.findChild( QDoubleSpinBox, 'scaleFactorSpin' ) self._extentsChanged( self.canvas, self.onExtentsChangedMirror, self.qgisCanvas, w.value() ) self._textScaleBtnChanched() if not self.extent is None: self._extent() @pyqtSlot() def onDestinationCrsChanged_MapUnitsChanged(self): prevFlag = self.canvas.renderFlag() self.canvas.setRenderFlag( False ) self.canvas.setDestinationCrs( self.qgisCanvas.mapRenderer().destinationCrs() ) self.canvas.setMapUnits( self.qgisCanvas.mapUnits() ) self.canvas.setRenderFlag( prevFlag ) @pyqtSlot(bool) def onHasCrsTransformEnabledChanged(self, enabled): prevFlag = self.canvas.renderFlag() self.canvas.setRenderFlag( False ) self.canvas.mapRenderer().setProjectionsEnabled( enabled ) self.canvas.setRenderFlag( prevFlag ) @pyqtSlot(list) def onLayersWillBeRemoved( self, theLayerIds ): ids = list( set( self.ltg.findLayerIds() ) & set( theLayerIds ) ) # intersection nodes = map( lambda item: self.ltg.findLayer( item ), ids ) for item in nodes: self._connectVectorRefresh( item.layer(), False ) self.ltg.removeChildNode( item ) @pyqtSlot() def onAddSelectedLayersQgis( self ): layersQgis = map( lambda item: item.layer(), self.qgisTView.selectedLayerNodes() ) self._addLayersQgis( layersQgis ) @pyqtSlot('QgsLayerTreeNode', int, int) def addedChildrenLayer(self, ltg, indexFrom, indexTo): layersQgis = map( lambda item: item.layer(), ltg.findLayers() ) self._addLayersQgis( layersQgis, False ) @pyqtSlot('QgsLayerTreeNode', int, int) def onRemovedChildrenQgisRoot(self, ltg, indexFrom, indexTo): if not self.qgisSyncGroup is None and not self.qgisSyncGroup in self.root.children(): self.qgisSyncGroup = None self.dockLegend.addNameSyncGroup( "None" ) msg = "Removed synchronized group (main map)" self.messageBar.pushMessage( msg, QgsMessageBar.INFO, 4 ) @pyqtSlot() def onSyncGroupAddLayersQgis( self): msg = "Need active a group in main map with new layers" ltn = self.qgisTView.currentNode() if not isinstance( ltn, QgsLayerTreeGroup ) or ltn == self.root: self.messageBar.pushMessage( msg, QgsMessageBar.WARNING, 3 ) return if not self._syncGroupAddLayersQgis( ltn ): self.messageBar.pushMessage( msg, QgsMessageBar.WARNING, 3 ) @pyqtSlot( 'QgsMapLayer' ) def onRemoveLayers( self, layer ): self._connectVectorRefresh(layer, False) @pyqtSlot() def onNeedSelectLayer(self): self.messageBar.pushMessage("Need select layer(s)", QgsMessageBar.WARNING, 2 ) @pyqtSlot('QgsMapLayer') def onCurrentLayerQgis(self, layer ): if layer is None: self.messageBar.pushMessage("Need active layer", QgsMessageBar.WARNING, 2 ) else: self.qgisTView.setCurrentLayer( layer ) @pyqtSlot('QgsMapLayer') def onCurrentLayerChanged(self, layer ): hasLayer = True if not layer is None else False selectName = "Select layer '%s'" % layer.name() if hasLayer else "None select layer" title = "#%d - %s" % ( self.numWin, selectName ) self.setWindowTitle( title ) @pyqtSlot() def onClosedLegend(self): self.actLegend.setText( "Show layers" ) @pyqtSlot() def onActionLegend(self): self.actLegend.setText( "" ) self.dockLegend.show()
class GeomFilterEPSG(): def __init__(self, iface): self.iface = iface def initGui(self): # cria uma ação que iniciará a configuração do plugin #self.myMapTool = QgsMapToolEmitPoint( self.iface.mapCanvas() ) self.initVariables() self.initSignals() def initVariables(self): self.coordinates = [] # Criação da action e da toolbar self.toolbar = self.iface.addToolBar("My_ToolBar") pai = self.iface.mainWindow() icon_path = ':/plugins/GeomFilterEPSG/icon.png' self.action = QAction(QIcon(icon_path), u"Filtro EPSG.", pai) self.action.setObjectName("Filtro EPSG.") self.action.setStatusTip(None) self.action.setWhatsThis(None) self.action.setCheckable(True) self.toolbar.addAction(self.action) self.previousMapTool = self.iface.mapCanvas().mapTool() self.myMapTool = QgsMapToolEmitPoint(self.iface.mapCanvas()) self.isEditing = 0 def initSignals(self): self.action.toggled.connect(self.RubberBand) self.myMapTool.canvasClicked.connect(self.mouseClick) def RubberBand(self, bolean): if bolean: self.myRubberBand = QgsRubberBand(self.iface.mapCanvas(), QGis.Polygon) color = QColor(78, 97, 114) color.setAlpha(190) self.myRubberBand.setColor(color) self.myRubberBand.setFillColor(QColor(255, 0, 0, 40)) self.myRubberBand.setBorderColor(QColor(255, 0, 0, 200)) # Set MapTool self.iface.mapCanvas().setMapTool(self.myMapTool) self.iface.mapCanvas().xyCoordinates.connect(self.mouseMove) else: self.disconnect() def disconnect(self): self.iface.mapCanvas().unsetMapTool(self.myMapTool) try: self.iface.mapCanvas().xyCoordinates.disconnect(self.mouseMove) except: pass try: self.myRubberBand.reset() except: pass def unChecked(self): self.action.setCheckable(False) self.action.setCheckable(True) def unload(self): self.disconnect() def mouseClick(self, currentPos, clickedButton): if clickedButton == Qt.LeftButton: # and myRubberBand.numberOfVertices() == 0: self.myRubberBand.addPoint(QgsPoint(currentPos)) self.coordinates.append(QgsPoint(currentPos)) self.isEditing = 1 elif clickedButton == Qt.RightButton and self.myRubberBand.numberOfVertices( ) > 2: self.isEditing = 0 # create feature and set geometry. poly = QgsFeature() geomP = self.myRubberBand.asGeometry() poly.setGeometry(geomP) g = geomP.exportToWkt() # Get WKT coordenates. #print g canvas = self.iface.mapCanvas() c = canvas.mapRenderer().destinationCrs().authid() # Get EPSG. rep = c.replace("EPSG:", "") string = U"st_intersects(geom,st_geomfromewkt('SRID=" + rep + ";" + g + "'))" self.layers = self.iface.mapCanvas().layers() for layer in self.layers: layer.setSubsetString(string) self.myRubberBand.reset(QGis.Polygon) self.disconnect() self.unChecked() def mouseMove(self, currentPos): if self.isEditing == 1: self.myRubberBand.movePoint(QgsPoint(currentPos))
def getRubberBand(self): rubberBand = QgsRubberBand(self.canvas, True) rubberBand.setFillColor(QColor(255, 0, 0, 40)) rubberBand.setBorderColor(QColor(255, 0, 0, 200)) rubberBand.setWidth(2) return rubberBand
class ObstacleAreaJigSelectArea(QgsMapTool): def __init__(self, canvas, areaType): self.mCanvas = canvas self.areaType = areaType QgsMapTool.__init__(self, canvas) self.mCursor = Qt.ArrowCursor self.mRubberBand = None self.mDragging = False self.mSelectRect = QRect() self.mRubberBandResult = None self.mSnapper = QgsMapCanvasSnapper(canvas) self.lineCount = 0 self.resultGeomList = [] self.geomList = [] self.area = None self.isFinished = False # QgsRubberBand* mRubberBand; # def reset(self): # self.startPoint = None # self.endPoint = None # self.isDrawing = False # SelectByRect.RubberRect.reset(QGis.Polygon) # self.layer = self.canvas.currentLayer() def canvasPressEvent(self, e): QgisHelper.ClearRubberBandInCanvas(define._canvas) self.mSelectRect.setRect( 0, 0, 0, 0 ) self.mRubberBand = QgsRubberBand( self.mCanvas, QGis.Polygon ) self.startPoint, self.pointID, self.layer= self.snapPoint(e.pos()) def canvasMoveEvent(self, e): if self.areaType == ProtectionAreaType.Secondary: if self.lineCount == 0: define._messageLabel.setText("Select a line or arc representing the INNER edge of the secondary area.") elif self.lineCount == 1: define._messageLabel.setText("Select a line representing the OUTER edge of the secondary area.") elif self.areaType == ProtectionAreaType.Primary: define._messageLabel.setText("") elif self.areaType == ProtectionAreaType.PrimaryAndSecondary: if self.lineCount == 0: define._messageLabel.setText("Select a line or arc representing the INNER edge of the FIRST secondary area.") elif self.lineCount == 1: define._messageLabel.setText("Select a line representing the OUTER edge of the FIRST secondary area.") elif self.lineCount == 2: define._messageLabel.setText("Select a line or arc representing the INNER edge of the SECOND secondary area.") elif self.lineCount == 3: define._messageLabel.setText("Select a line representing the OUTER edge of the SECOND secondary area.") else: define._messageLabel.setText("") if ( e.buttons() != Qt.LeftButton ): return if ( not self.mDragging ): self.mDragging = True self.mSelectRect.setTopLeft( e.pos() ) self.mSelectRect.setBottomRight( e.pos() ) QgsMapToolSelectUtils.setRubberBand( self.mCanvas, self.mSelectRect,self.mRubberBand ) def canvasReleaseEvent(self, e): self.endPoint, self.pointID, self.layer= self.snapPoint(e.pos()) vlayer = QgsMapToolSelectUtils.getCurrentVectorLayer( self.mCanvas ) if ( vlayer == None ): if ( self.mRubberBand != None): self.mRubberBand.reset( QGis.Polygon ) del self.mRubberBand self.mRubberBand = None self.mDragging = False return if (not self.mDragging ): QgsMapToolSelectUtils.expandSelectRectangle(self. mSelectRect, vlayer, e.pos() ) else: if ( self.mSelectRect.width() == 1 ): self.mSelectRect.setLeft( self.mSelectRect.left() + 1 ) if ( self.mSelectRect.height() == 1 ): self.mSelectRect.setBottom( self.mSelectRect.bottom() + 1 ) if ( self.mRubberBand != None ): QgsMapToolSelectUtils.setRubberBand( self.mCanvas, self.mSelectRect, self.mRubberBand ) selectGeom = self.mRubberBand.asGeometry() selectedFeatures = QgsMapToolSelectUtils.setSelectFeaturesOrRubberband_Tas_1( self.mCanvas, selectGeom, e ) if len(selectedFeatures) > 0: self.lineCount += 1 geom = selectedFeatures[0].geometry() resultArray = QgisHelper.findArcOrLineInLineGeometry(geom, selectGeom) # if resultArray != None: # bulge = MathHelper.smethod_60(resultArray[0], resultArray[int(len(resultArray)/2)], resultArray[len(resultArray)-1]) # bulge1 = MathHelper.smethod_60(resultArray[len(resultArray)-1], resultArray[int(len(resultArray)/2)], resultArray[0]) # n = 0 pointArray0 = geom.asPolyline() self.resultGeomList.append(resultArray) self.geomList.append(pointArray0) if self.lineCount == 2 and self.areaType != ProtectionAreaType.PrimaryAndSecondary and self.areaType != ProtectionAreaType.Complex: self.area = self.makeArea(self.resultGeomList, self.areaType) pointArray = self.getPointArray(self.resultGeomList).method_14_closed() self.mRubberBandResult = None self.mRubberBandResult = QgsRubberBand( self.mCanvas, QGis.Polygon ) self.mRubberBandResult.setFillColor(QColor(255, 255, 255, 100)) self.mRubberBandResult.setBorderColor(QColor(0, 0, 0)) for point in pointArray: self.mRubberBandResult.addPoint(point) self.mRubberBandResult.show() self.emit(SIGNAL("outputResult"), self.area, self.mRubberBandResult) self.lineCount = 0 self.resultGeomList = [] self.isFinished = True # self.rubberBandLine.reset(QGis.Line) elif self.lineCount == 4 and self.areaType == ProtectionAreaType.PrimaryAndSecondary: self.area = self.makeArea(self.resultGeomList, self.areaType) pointArray = self.getPointArray([self.resultGeomList[1], self.resultGeomList[3]]).method_14_closed() self.mRubberBandResult = None self.mRubberBandResult = QgsRubberBand( self.mCanvas, QGis.Polygon ) self.mRubberBandResult.setFillColor(QColor(255, 255, 255, 100)) self.mRubberBandResult.setBorderColor(QColor(0, 0, 0)) for point in pointArray: self.mRubberBandResult.addPoint(point) self.mRubberBandResult.show() self.emit(SIGNAL("outputResult"), self.area, self.mRubberBandResult) self.lineCount = 0 self.resultGeomList = [] # else: # return del selectGeom self.mRubberBand.reset( QGis.Polygon ) del self.mRubberBand self.mRubberBand = None self.mDragging = False def getPointArray(self, geomList): pointArrayInner = geomList[0] pointArray1Outer = geomList[1] innerStartPoint = pointArrayInner[0] innerEndPoint = pointArrayInner[1] innerBulge = pointArrayInner[2] outerStartPoint = pointArray1Outer[0] outerEndPoint = pointArray1Outer[1] outerBulge = pointArray1Outer[2] line0 = QgsGeometry.fromPolyline([innerStartPoint, outerStartPoint]) line1 = QgsGeometry.fromPolyline([innerEndPoint, outerEndPoint]) # for i in range(1, len(pointArray0)): if line0.intersects(line1): tempPoint = outerStartPoint outerStartPoint = outerEndPoint outerEndPoint = tempPoint outerBulge = -outerBulge polylineArea = PolylineArea() polylineArea.Add(PolylineAreaPoint(innerStartPoint, innerBulge)) polylineArea.Add(PolylineAreaPoint(innerEndPoint)) polylineArea.Add(PolylineAreaPoint(outerEndPoint, -outerBulge)) polylineArea.Add(PolylineAreaPoint(outerStartPoint)) return polylineArea def makeArea(self, geomList, areaType): if areaType == ProtectionAreaType.Primary or areaType == ProtectionAreaType.Secondary: return self.makePrimaryAreaOrSecondaryArea(geomList, areaType) elif areaType == ProtectionAreaType.PrimaryAndSecondary: pointArray0 = geomList[0] pointArray1 = geomList[1] pointArray2 = geomList[2] pointArray3 = geomList[3] primaryArea = self.makePrimaryAreaOrSecondaryArea([pointArray0, pointArray2], ProtectionAreaType.Primary) secondaryArea1 = self.makePrimaryAreaOrSecondaryArea([pointArray0, pointArray1], ProtectionAreaType.Secondary) secondaryArea2 = self.makePrimaryAreaOrSecondaryArea([pointArray2, pointArray3], ProtectionAreaType.Secondary) return PrimarySecondaryObstacleArea(primaryArea, secondaryArea1, secondaryArea2) # if len(geomList[0]) == 2 and len(geomList[1]) == 2 and len(geomList[2]) == 2 and len(geomList[3]) == 2: # for i in range(1, len(geomList)): # pointArray0 = geomList[0] # pointArray1 = geomList[i] # line0 = QgsGeometry.fromPolyline([pointArray0[0], pointArray1[0]]) # line1 = QgsGeometry.fromPolyline([pointArray0[len(pointArray0) - 1], pointArray1[len(pointArray1) - 1]]) # if line0.intersects(line1): # pointArray1.reverse() # pointArray0 = geomList[0] # pointArray1 = geomList[1] # pointArray2 = geomList[2] # pointArray3 = geomList[3] # area = PrimarySecondaryObstacleArea() # area.set_areas(pointArray0, pointArray1, pointArray2, pointArray3) # return area # return None return None def makePrimaryAreaOrSecondaryArea(self, geomList, areaType): pointArrayInner = geomList[0] pointArray1Outer = geomList[1] innerStartPoint = pointArrayInner[0] innerEndPoint = pointArrayInner[1] innerBulge = pointArrayInner[2] outerStartPoint = pointArray1Outer[0] outerEndPoint = pointArray1Outer[1] outerBulge = pointArray1Outer[2] line0 = QgsGeometry.fromPolyline([innerStartPoint, outerStartPoint]) line1 = QgsGeometry.fromPolyline([innerEndPoint, outerEndPoint]) # for i in range(1, len(pointArray0)): if line0.intersects(line1): tempPoint = Point3D(outerStartPoint.get_X(), outerStartPoint.get_Y()) outerStartPoint = Point3D(outerEndPoint.get_X(), outerEndPoint.get_Y()) outerEndPoint = Point3D(tempPoint.get_X(), tempPoint.get_Y()) outerBulge = -outerBulge if areaType == ProtectionAreaType.Primary: polylineArea = PolylineArea() polylineArea.Add(PolylineAreaPoint(innerStartPoint, innerBulge)) polylineArea.Add(PolylineAreaPoint(innerEndPoint)) polylineArea.Add(PolylineAreaPoint(outerEndPoint, -outerBulge)) polylineArea.Add(PolylineAreaPoint(outerStartPoint)) return PrimaryObstacleArea(polylineArea) elif areaType == ProtectionAreaType.Secondary: if innerBulge == 0 and outerBulge == 0: return SecondaryObstacleArea(innerStartPoint, innerEndPoint, outerStartPoint, outerEndPoint, MathHelper.getBearing(innerStartPoint, innerEndPoint)) elif innerBulge != 0 and outerBulge != 0: if round(innerBulge, 1) != round(outerBulge, 1): return None innerCenterPoint = MathHelper.smethod_71(innerStartPoint, innerEndPoint, innerBulge) outerCenterPoint = MathHelper.smethod_71(outerStartPoint, outerEndPoint, outerBulge) innerRadius = MathHelper.calcDistance(innerCenterPoint, innerStartPoint); outerRadius = MathHelper.calcDistance(outerCenterPoint, outerStartPoint); bearing = (MathHelper.getBearing(innerCenterPoint, innerStartPoint) + MathHelper.getBearing(innerCenterPoint, innerEndPoint)) / 2 innerMiddlePoint = MathHelper.distanceBearingPoint(innerCenterPoint, bearing, innerRadius) if round(MathHelper.smethod_60(innerStartPoint, innerMiddlePoint, innerEndPoint), 4) != round(outerBulge, 4): bearing += 3.14159265358979 innerMiddlePoint = MathHelper.distanceBearingPoint(innerCenterPoint, bearing, innerRadius) bearing = (MathHelper.getBearing(outerCenterPoint, outerStartPoint) + MathHelper.getBearing(outerCenterPoint, outerEndPoint)) / 2 outerMiddlePoint = MathHelper.distanceBearingPoint(outerCenterPoint, bearing, outerRadius) if round(MathHelper.smethod_60(outerStartPoint, outerMiddlePoint, outerEndPoint), 4) != round(outerBulge, 4): bearing += 3.14159265358979 outerMiddlePoint = MathHelper.distanceBearingPoint(outerCenterPoint, bearing, outerRadius) return SecondaryObstacleArea(innerStartPoint, innerMiddlePoint, innerEndPoint, outerStartPoint, None, outerMiddlePoint, outerEndPoint, innerBulge, innerBulge) return None def snapPoint(self, p, bNone = False): if define._snapping == False: return (define._canvas.getCoordinateTransform().toMapCoordinates( p ), None, None) snappingResults = self.mSnapper.snapToBackgroundLayers( p ) if ( snappingResults[0] != 0 or len(snappingResults[1]) < 1 ): if bNone: return (None, None, None) else: return (define._canvas.getCoordinateTransform().toMapCoordinates( p ), None, None) else: return (snappingResults[1][0].snappedVertex, snappingResults[1][0].snappedAtGeometry, snappingResults[1][0].layer)
class RubberBand(): def __init__(self, iface): self.iface = iface def initGui(self): # cria uma ação que iniciará a configuração do plugin #self.myMapTool = QgsMapToolEmitPoint( self.iface.mapCanvas() ) self.initVariables() self.initSignals() def initVariables(self): self.coordinates = [] # Criação da action e da toolbar self.toolbar = self.iface.addToolBar("My_ToolBar") pai = self.iface.mainWindow() icon_path = ':/plugins/RubberBand/icon.png' self.action = QAction(QIcon(icon_path), u"Cria RubberBand de Polygon.", pai) self.action.setObjectName("Cria RubberBand de Polygon.") self.action.setStatusTip(None) self.action.setWhatsThis(None) self.action.setCheckable(True) self.toolbar.addAction(self.action) self.previousMapTool = self.iface.mapCanvas().mapTool() self.myMapTool = QgsMapToolEmitPoint(self.iface.mapCanvas()) self.isEditing = 0 # self.vlyr = QgsVectorLayer("Polygon?crs=EPSG:31982", "temporary_polygons", "memory") # self.dprov = self.vlyr.dataProvider() # # Add field to virtual layer # self.dprov.addAttributes([QgsField("name", QVariant.String), # QgsField("size", QVariant.Double)]) # self.vlyr.updateFields() # Access ID # self.fields = self.dprov.fields() def initSignals(self): self.action.toggled.connect(self.initRubberBand) self.myMapTool.canvasClicked.connect(self.mouseClick) def initRubberBand(self, b): if b: self.myRubberBand = QgsRubberBand(self.iface.mapCanvas(), QGis.Polygon) color = QColor(78, 97, 114) color.setAlpha(190) self.myRubberBand.setColor(color) self.myRubberBand.setFillColor(QColor(255, 0, 0, 40)) self.myRubberBand.setBorderColor(QColor(255, 0, 0, 200)) # Set MapTool self.iface.mapCanvas().setMapTool(self.myMapTool) self.iface.mapCanvas().xyCoordinates.connect(self.mouseMove) else: self.disconnect() def disconnect(self): self.iface.mapCanvas().unsetMapTool(self.myMapTool) try: self.iface.mapCanvas().xyCoordinates.disconnect(self.mouseMove) except: pass try: self.myRubberBand.reset() except: pass def unChecked(self): pass def unload(self): self.disconnect() def mouseClick(self, currentPos, clickedButton): if clickedButton == Qt.LeftButton: # and myRubberBand.numberOfVertices() == 0: self.myRubberBand.addPoint(QgsPoint(currentPos)) self.coordinates.append(QgsPoint(currentPos)) self.isEditing = 1 elif clickedButton == Qt.RightButton and self.myRubberBand.numberOfVertices( ) > 2: self.isEditing = 0 # open input dialog (description, False) = QInputDialog.getText( self.iface.mainWindow(), "Description", "Description for Polygon at x and y", QLineEdit.Normal, 'My Polygon') #create feature and set geometry poly = QgsFeature() geomP = self.myRubberBand.asGeometry() poly.setGeometry(geomP) print geomP.exportToWkt() #set attributes # indexN = self.dprov.fieldNameIndex('name') # indexA = self.dprov.fieldNameIndex('size') # poly.setAttributes([QgsDistanceArea().measurePolygon(self.coordinates), indexA]) # poly.setAttributes([description, indexN]) # add feature # self.dprov.addFeatures([poly]) # self.vlyr.updateExtents() #add layer # self.vlyr.triggerRepaint() # QgsMapLayerRegistry.instance().addMapLayers([self.vlyr]) # self.myRubberBand.reset(QGis.Polygon) def mouseMove(self, currentPos): if self.isEditing == 1: self.myRubberBand.movePoint(QgsPoint(currentPos))
class ExtractRasterValue(ParentMapTool): """ Button 18. User select nodes and assign raster elevation or value """ def __init__(self, iface, settings, action, index_action): """ Class constructor """ # Call ParentMapTool constructor super(ExtractRasterValue, self).__init__(iface, settings, action, index_action) self.dragging = False # Vertex marker self.vertexMarker = QgsVertexMarker(self.canvas) self.vertexMarker.setColor(QColor(255, 25, 25)) self.vertexMarker.setIconSize(11) self.vertexMarker.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X self.vertexMarker.setPenWidth(5) # Rubber band self.rubberBand = QgsRubberBand(self.canvas, True) mFillColor = QColor(100, 0, 0) self.rubberBand.setColor(mFillColor) self.rubberBand.setWidth(3) mBorderColor = QColor(254, 58, 29) self.rubberBand.setBorderColor(mBorderColor) # Select rectangle self.selectRect = QRect() # Init self.vectorLayer = None self.rasterLayer = None def reset(self): """ Clear selected features """ layer = self.vectorLayer if layer is not None: layer.removeSelection() # Graphic elements self.rubberBand.reset() def set_config_action(self, action_99): """ Get the config form action""" self.configAction = action_99 """ QgsMapTools inherited event functions """ def canvasMoveEvent(self, event): """ With left click the digitizing is finished """ if self.vectorLayer is None: return if event.buttons() == Qt.LeftButton: if not self.dragging: self.dragging = True self.selectRect.setTopLeft(event.pos()) self.selectRect.setBottomRight(event.pos()) self.set_rubber_band() else: # Hide highlight self.vertexMarker.hide() # Get the click x = event.pos().x() y = event.pos().y() eventPoint = QPoint(x, y) # Snapping (retval, result) = self.snapper.snapToBackgroundLayers(eventPoint) # @UnusedVariable # That's the snapped point if result <> []: # Check Arc or Node for snapPoint in result: if snapPoint.layer == self.vectorLayer: # Get the point point = QgsPoint(result[0].snappedVertex) # Add marker self.vertexMarker.setCenter(point) self.vertexMarker.show() break def canvasPressEvent(self, event): self.selectRect.setRect(0, 0, 0, 0) self.rubberBand.reset() def canvasReleaseEvent(self, event): """ With left click the digitizing is finished """ if event.button() == Qt.LeftButton: # Get the click x = event.pos().x() y = event.pos().y() eventPoint = QPoint(x, y) # Node layer layer = self.vectorLayer # Not dragging, just simple selection if not self.dragging: # Snap to node (retval, result) = self.snapper.snapToBackgroundLayers(eventPoint) # @UnusedVariable # That's the snapped point if result <> [] and (result[0].layer.name() == self.vectorLayer.name()): point = QgsPoint(result[0].snappedVertex) # @UnusedVariable layer.removeSelection() layer.select([result[0].snappedAtGeometry]) # Interpolate values self.raster_interpolate() # Hide highlight self.vertexMarker.hide() else: # Set valid values for rectangle's width and height if self.selectRect.width() == 1: self.selectRect.setLeft(self.selectRect.left() + 1) if self.selectRect.height() == 1: self.selectRect.setBottom(self.selectRect.bottom() + 1) self.set_rubber_band() selectGeom = self.rubberBand.asGeometry() # @UnusedVariable self.select_multiple_features(self.selectRectMapCoord) self.dragging = False # Interpolate values self.raster_interpolate() elif event.button() == Qt.RightButton: # Interpolate values self.raster_interpolate() def activate(self): # Check button self.action().setChecked(True) # Rubber band self.rubberBand.reset() # Store user snapping configuration self.snapperManager.storeSnappingOptions() # Clear snapping self.snapperManager.clearSnapping() # Get layers res = self.find_raster_layers() # if res == 0: # self.controller.show_warning("Raster configuration tool not properly configured.") # return # Change cursor self.canvas.setCursor(self.cursor) # Show help message when action is activated if self.show_help: message = ( "Right click to use current selection, select connec points by clicking or dragging (selection box)" ) self.controller.show_info(message, context_name="ui_message") # Control current layer (due to QGIS bug in snapping system) try: if self.canvas.currentLayer().type() == QgsMapLayer.VectorLayer: self.canvas.setCurrentLayer(self.layer_arc) except: self.canvas.setCurrentLayer(self.layer_arc) def deactivate(self): # Check button self.action().setChecked(False) # Rubber band self.rubberBand.reset() # Restore previous snapping self.snapperManager.recoverSnappingOptions() # Recover cursor self.canvas.setCursor(self.stdCursor) def nearestNeighbor(self, thePoint): ident = self.dataProv.identify(thePoint, QgsRaster.IdentifyFormatValue) value = None if ident is not None: # and ident.has_key(choosenBand+1): try: value = float(ident.results()[int(self.band)]) except TypeError: value = None if value == self.noDataValue: return None return value def writeInterpolation(self, f, fieldIdx): thePoint = f.geometry().asPoint() value = self.nearestNeighbor(thePoint) self.vectorLayer.changeAttributeValue(f.id(), fieldIdx, value) def raster_interpolate(self): """ Interpolate features value from raster """ # Interpolate values if self.vectorLayer is None and self.rasterLayer is None: return # Get data provider layer = self.vectorLayer self.dataProv = self.rasterLayer.dataProvider() if self.dataProv.srcNoDataValue(int(self.band)): self.noDataValue = self.dataProv.srcNoDataValue(int(self.band)) else: self.noDataValue = None self.continueProcess = True self.fieldIdx = "" self.fieldIdx = layer.fieldNameIndex(self.fieldName) if self.band == 0: self.controller.show_warning("You must choose a band for the raster layer.") return if self.fieldName == "": self.controller.show_warning("You must choose a field to write values.") return if self.fieldIdx < 0: self.controller.show_warning("Selected field does not exist in feature layer.") return k = 0 c = 0 f = QgsFeature() # Check features selected if layer.selectedFeatureCount() == 0: message = "You have to select at least one feature!" self.controller.show_warning(message, context_name="ui_message") return # Check editable if not layer.isEditable(): layer.startEditing() # Get selected id's ids = self.vectorLayer.selectedFeaturesIds() for fid in ids: k += 1 layer.getFeatures(QgsFeatureRequest(fid)).nextFeature(f) c += 1 self.writeInterpolation(f, self.fieldIdx) QCoreApplication.processEvents() self.controller.show_info( "%u values have been updated in layer %s.%s over %u points using %s raster" % (c, self.vectorLayer.name(), self.fieldName, k, self.table_raster) ) # Check editable if layer.isEditable(): layer.commitChanges() # Refresh map canvas self.rubberBand.reset() self.iface.mapCanvas().refresh() def set_rubber_band(self): # Coordinates transform transform = self.canvas.getCoordinateTransform() # Coordinates ll = transform.toMapCoordinates(self.selectRect.left(), self.selectRect.bottom()) lr = transform.toMapCoordinates(self.selectRect.right(), self.selectRect.bottom()) ul = transform.toMapCoordinates(self.selectRect.left(), self.selectRect.top()) ur = transform.toMapCoordinates(self.selectRect.right(), self.selectRect.top()) # Rubber band self.rubberBand.reset() self.rubberBand.addPoint(ll, False) self.rubberBand.addPoint(lr, False) self.rubberBand.addPoint(ur, False) self.rubberBand.addPoint(ul, False) self.rubberBand.addPoint(ll, True) self.selectRectMapCoord = QgsRectangle(ll, ur) def select_multiple_features(self, selectGeometry): # Default choice behaviour = QgsVectorLayer.SetSelection # Modifiers modifiers = QApplication.keyboardModifiers() if modifiers == Qt.ControlModifier: behaviour = QgsVectorLayer.AddToSelection elif modifiers == Qt.ShiftModifier: behaviour = QgsVectorLayer.RemoveFromSelection if self.vectorLayer is None: return # Change cursor QApplication.setOverrideCursor(Qt.WaitCursor) # Selection self.vectorLayer.selectByRect(selectGeometry, behaviour) # Old cursor QApplication.restoreOverrideCursor() def find_raster_layers(self): # Query database (form data) sql = "SELECT *" sql += " FROM " + self.schema_name + ".config_extract_raster_value" rows = self.controller.get_rows(sql) if not rows: self.controller.show_warning("Any data found in table config_extract_raster_value") self.configAction.activate(QAction.Trigger) return 0 # Layers row = rows[0] self.table_raster = row[1] self.band = row[2] self.table_vector = row[3] self.fieldName = row[4] # Check if we have any layer loaded layers = self.iface.legendInterface().layers() if len(layers) == 0: return # Init layers self.rasterLayer = None self.vectorLayer = None # Iterate over all layers to get the ones specified in 'db' config section for cur_layer in layers: if cur_layer.name() == self.table_raster: self.rasterLayer = cur_layer (uri_schema, uri_table) = self.controller.get_layer_source(cur_layer) # @UnusedVariable if uri_table is not None: if self.table_vector in uri_table: self.vectorLayer = cur_layer # Check config if self.vectorLayer is None or self.rasterLayer is None: self.configAction.activate(QAction.Trigger) # Set snapping if self.vectorLayer <> None: self.snapperManager.snapToLayer(self.vectorLayer) else: self.controller.show_warning("Check vector_layer in config form, layer does not exist or is not defined.") return 0 if self.rasterLayer == None: self.controller.show_warning("Check raster_layer in config form, layer does not exist or is not defined.") return 0 return 1
class ApisMapToolEmitPointAndSquare(QgsMapTool, ApisMapToolMixin): # when mapping finished signal emitted that carries the Point and a Polygon Geometry (in Map Coordinates) mappingFinished = pyqtSignal(QgsGeometry, QgsGeometry, QgsCoordinateReferenceSystem) def __init__(self, canvas, diagonal=200): QgsMapTool.__init__(self, canvas) self.canvas = canvas self.vertexMarker = None self.rubberBand = None self.capturedPoint = None self.derivedPolygon = [] self.capturing = False # self.setLayers(pointLayer, polygonLayer) self.setDiagonal(diagonal) self.setCursor(Qt.CrossCursor) def canvasReleaseEvent(self, event): if event.button() == Qt.LeftButton: if not self.capturing: self.startCapturing() self.setVertex(event.pos()) elif event.button() == Qt.RightButton: point = self.getCapturedPoint() polygon = self.getDerivedPolygon() self.stopCapturing() if point != None and polygon != None: self.mappingFinished.emit(self.getPointGeometry(point), self.getPolygonGeometry(polygon), self.canvas.mapSettings().destinationCrs()) def keyPressEvent(self, event): if event.key() == Qt.Key_Backspace or event.key() == Qt.Key_Delete: #self.removeLastVertex() event.ignore() if event.key() == Qt.Key_Escape: self.stopCapturing() self.clearScene() if event.key() == Qt.Key_Return or event.key() == Qt.Key_Enter: point = self.getCapturedPoint() polygon = self.getDerivedPolygon() self.stopCapturing() if point != None and polygon != None: self.mappingFinished.emit(self.getPointGeometry(point), self.getPolygonGeometry(polygon), self.canvas.mapSettings().destinationCrs()) def startCapturing(self): self.clearScene() self.vertexMarker = QgsVertexMarker(self.canvas) self.vertexMarker.setIconType(1) self.vertexMarker.setColor(QColor(220, 0, 0)) self.vertexMarker.setIconSize(16) self.vertexMarker.setPenWidth(3) self.vertexMarker.show() self.rubberBand = QgsRubberBand(self.canvas, QGis.Polygon) self.rubberBand.setWidth(2) self.rubberBand.setFillColor(QColor(220, 0, 0, 120)) self.rubberBand.setBorderColor(QColor(220, 0, 0)) self.rubberBand.setLineStyle(Qt.DotLine) self.rubberBand.show() self.capturing = True def clearScene(self): if self.vertexMarker: self.canvas.scene().removeItem(self.vertexMarker) self.vertexMarker = None if self.rubberBand: self.canvas.scene().removeItem(self.rubberBand) self.rubberBand = None def stopCapturing(self): self.capturing = False self.capturedPoint = None self.derivedPolygon = [] self.canvas.refresh() def setVertex(self, canvasPoint): mapPt = self.transformCoordinates(canvasPoint) # set/update vertexMarker Position self.vertexMarker.setCenter(mapPt) self.capturedPoint = mapPt # update rubberBand self.updateRubberBand() def updateRubberBand(self): if self.capturedPoint and self.rubberBand: # calculate Points self.derivedPolygon = self.calculateSquare(self.capturedPoint) self.rubberBand.reset(QGis.Polygon) for mapPt in self.derivedPolygon: self.rubberBand.addPoint(mapPt) def getCapturedPoint(self): point = self.capturedPoint if point == None: return None else: return point def getDerivedPolygon(self): polygon = self.derivedPolygon if polygon == None: return None else: return polygon def getPointGeometry(self, geom): return QgsGeometry.fromPoint(geom) def getPolygonGeometry(self, geom): return QgsGeometry.fromPolygon([geom]) def updateDiagonal(self, diagonal): self.setDiagonal(diagonal) # update Rubberband self.updateRubberBand()
class ApisMapToolEmitPolygonAndPoint(QgsMapTool, ApisMapToolMixin): mappingFinished = pyqtSignal(QgsGeometry, QgsGeometry, QgsCoordinateReferenceSystem) def __init__(self, canvas): QgsMapTool.__init__(self, canvas) self.canvas = canvas self.rubberBand = None self.tempRubberBand = None self.vertexMarker = None self.capturedPoints = [] self.derivedPoint = None self.capturing = False self.setCursor(Qt.CrossCursor) def canvasReleaseEvent(self, event): if event.button() == Qt.LeftButton: if not self.capturing: self.startCapturing() self.addVertex(event.pos()) elif event.button() == Qt.RightButton: point = self.getDerivedPoint() polygon = self.getCapturedPolygon() self.stopCapturing() if point != None and polygon != None: pointGeom = self.getPointGeometry(point) polygonGeom = self.getPolygonGeometry(polygon) if pointGeom != None and polygonGeom != None: self.mappingFinished.emit(pointGeom, polygonGeom, self.canvas.mapSettings().destinationCrs()) else: self.clearScene() else: self.clearScene() def canvasMoveEvent(self, event): if self.tempRubberBand != None and self.capturing: mapPt = self.transformCoordinates(event.pos()) self.tempRubberBand.movePoint(mapPt) def keyPressEvent(self, event): if event.key() == Qt.Key_Backspace or event.key() == Qt.Key_Delete: self.removeLastVertex() event.ignore() if event.key() == Qt.Key_Escape: self.stopCapturing() self.clearScene() if event.key() == Qt.Key_Return or event.key() == Qt.Key_Enter: point = self.getDerivedPoint() polygon = self.getCapturedPolygon() self.stopCapturing() if point != None and polygon != None: pointGeom = self.getPointGeometry(point) polygonGeom = self.getPolygonGeometry(polygon) if pointGeom != None and polygonGeom != None: self.mappingFinished.emit(pointGeom, polygonGeom, self.canvas.mapSettings().destinationCrs()) else: self.clearScene() else: self.clearScene() def startCapturing(self): self.clearScene() self.rubberBand = QgsRubberBand(self.canvas, QGis.Polygon) self.rubberBand.setWidth(2) self.rubberBand.setFillColor(QColor(220, 0, 0, 120)) self.rubberBand.setBorderColor(QColor(220, 0, 0)) self.rubberBand.setLineStyle(Qt.DotLine) self.rubberBand.show() self.tempRubberBand = QgsRubberBand(self.canvas, QGis.Polygon) self.tempRubberBand.setWidth(2) self.tempRubberBand.setFillColor(QColor(0, 0, 0, 0)) self.tempRubberBand.setBorderColor(QColor(220, 0, 0)) self.tempRubberBand.setLineStyle(Qt.DotLine) self.tempRubberBand.show() self.vertexMarker = QgsVertexMarker(self.canvas) self.vertexMarker.setIconType(1) self.vertexMarker.setColor(QColor(220, 0, 0)) self.vertexMarker.setIconSize(16) self.vertexMarker.setPenWidth(3) self.vertexMarker.show() self.capturing = True def clearScene(self): if self.vertexMarker: self.canvas.scene().removeItem(self.vertexMarker) self.vertexMarker = None if self.rubberBand: self.canvas.scene().removeItem(self.rubberBand) self.rubberBand = None if self.tempRubberBand: self.canvas.scene().removeItem(self.tempRubberBand) self.tempRubberBand = None def stopCapturing(self): if self.vertexMarker and self.rubberBand and self.rubberBand.numberOfVertices() < 3: self.canvas.scene().removeItem(self.vertexMarker) self.vertexMarker = None if self.rubberBand and self.rubberBand.numberOfVertices() < 3: self.canvas.scene().removeItem(self.rubberBand) self.rubberBand = None if self.tempRubberBand: self.canvas.scene().removeItem(self.tempRubberBand) self.tempRubberBand = None self.capturing = False self.capturedPoints = [] self.derivedPoint = None self.canvas.refresh() def addVertex(self, canvasPoint): mapPt = self.transformCoordinates(canvasPoint) self.rubberBand.addPoint(mapPt) self.capturedPoints.append(mapPt) bandSize = self.rubberBand.numberOfVertices() if bandSize > 2: rubGeom = self.rubberBand.asGeometry() cpGeom = rubGeom.centroid() if not rubGeom.contains(cpGeom): cpGeom = rubGeom.pointOnSurface() #nearestCp = rubGeom.nearestPoint(cpGeom) self.vertexMarker.setCenter(cpGeom.asPoint()) self.derivedPoint = cpGeom.asPoint() self.vertexMarker.show() self.tempRubberBand.reset(QGis.Polygon) firstPoint = self.rubberBand.getPoint(0, 0) self.tempRubberBand.addPoint(firstPoint) self.tempRubberBand.movePoint(mapPt) self.tempRubberBand.addPoint(mapPt) def removeLastVertex(self): if not self.capturing: return bandSize = self.rubberBand.numberOfVertices() tempBandSize = self.tempRubberBand.numberOfVertices() numPoints = len(self.capturedPoints) if bandSize < 1 or numPoints < 1: return self.rubberBand.removePoint(-1) if bandSize > 1: if tempBandSize > 1: point = self.rubberBand.getPoint(0, bandSize - 2) self.tempRubberBand.movePoint(tempBandSize - 2, point) else: self.tempRubberBand.reset(QGis.Polygon) bandSize = self.rubberBand.numberOfVertices() if bandSize < 3: self.vertexMarker.hide() else: rubGeom = self.rubberBand.asGeometry() cpGeom = rubGeom.centroid() if not rubGeom.contains(cpGeom): cpGeom = rubGeom.pointOnSurface() #nearestCp = rubGeom.nearestPoint(cpGeom) self.vertexMarker.setCenter(cpGeom.asPoint()) self.derivedPoint = cpGeom.asPoint() self.vertexMarker.show() del self.capturedPoints[-1] def getCapturedPolygon(self): polygon = self.capturedPoints if len(polygon) < 3: return None else: return polygon def getDerivedPoint(self): point = self.derivedPoint if point == None: return None else: return point def getPointGeometry(self, geom): p = QgsGeometry.fromPoint(geom) if p.isGeosValid() and not p.isGeosEmpty(): return p else: return None def getPolygonGeometry(self, geom): p = QgsGeometry.fromPolygon([geom]) if p.isGeosValid() and not p.isGeosEmpty(): return p else: return None
class AreaTool(QgsMapTool): """ Map tool class to select an area """ releasedSignal = pyqtSignal() def __init__(self, iface): """ Constructor :param iface: interface """ QgsMapTool.__init__(self, iface.mapCanvas()) self.__clear() def activate(self): """ When the action is selected """ QgsMapTool.activate(self) self.__rubber = QgsRubberBand(self.canvas(), QGis.Polygon) color = QColor("red") color.setAlphaF(0.6) self.__rubber.setBorderColor(color) color = QColor("orange") color.setAlphaF(0.3) self.__rubber.setFillColor(color) def deactivate(self): """ When the action is deselected """ self.__clear() QgsMapTool.deactivate(self) def __clear(self): """ To clear used variables """ self.__selecting = False self.__rubber = None self.first = None self.last = None self.geom = None def canvasMoveEvent(self, event): """ When the mouse is moved :param event: mouse event """ if self.__selecting: self.__rubber.reset() firstV2 = QgsPointV2(self.first) second = QgsPointV2(self.first.x(), event.mapPoint().y()) third = QgsPointV2(event.mapPoint()) fourth = QgsPointV2(event.mapPoint().x(), self.first.y()) lineV2 = QgsLineStringV2() lineV2.setPoints([firstV2, second, third, fourth, firstV2]) polygonV2 = QgsPolygonV2() polygonV2.setExteriorRing(lineV2) self.geom = QgsGeometry(polygonV2) self.__rubber.setToGeometry(self.geom, None) def canvasPressEvent(self, event): """ When the mouse is pressed :param event: mouse event """ self.__selecting = True self.first = event.mapPoint() def canvasReleaseEvent(self, event): """ When the mouse is clicked :param event: mouse event """ self.__selecting = False self.last = event.mapPoint() self.__rubber.reset() self.releasedSignal.emit()
class AuxiliaryWindow(QMainWindow): """Creates a New Canvas.""" closed = pyqtSignal(int) def __init__(self, parent, geometryWin, numWin): def populateStatusBar(): statusBar = self.statusBar() w = QCheckBox("Render", self) w.setObjectName('renderCheck') w.setToolTip("Toggle map rendering") w.setChecked(True) statusBar.addPermanentWidget(w) w = QCheckBox("Marker", self) w.setObjectName('markerCheck') w.setToolTip("Toggle marker with cursor position from main map") w.setChecked(False) statusBar.addPermanentWidget(w, 1) w = QCheckBox("Extent", self) w.setObjectName('extentCheck') w.setToolTip("Show extent of main map") w.setChecked(False) statusBar.addPermanentWidget(w, 1) w = QToolButton(self) w.setObjectName('highlightBtn') w.setToolTip("Highlight extent in main map") w.setText("Highlight") statusBar.addPermanentWidget(w, 1) w = QLabel("Scale factor:", self) w.setObjectName('scaleFactorLabel') w.setAlignment(Qt.AlignRight | Qt.AlignVCenter) statusBar.addPermanentWidget(w, 1) w = QDoubleSpinBox(self) w.setObjectName('scaleFactorSpin') w.setToolTip("Current scale factor of main map") w.setMinimum(0.0) w.setMaximum(1000.0) w.setDecimals(3) w.setValue(1) w.setSingleStep(.05) statusBar.addPermanentWidget(w, 1) w = QToolButton(self) w.setObjectName('scaleBtn') w.setToolTip("Set scale for main map") w.setText("Scale: ") statusBar.addPermanentWidget(w, 1) def setupUi(): self.setObjectName("AuxiliaryWindow") self.setGeometry(geometryWin) self.addDockWidget(Qt.LeftDockWidgetArea, self.dockLegend) self.actLegend = self.menuBar().addAction("") self.actLegend.triggered.connect(self.onActionLegend) self.canvas.setMapTool(self.toolPan) self.canvas.setCanvasColor(QColor(255, 255, 255)) self.canvas.enableAntiAliasing(False) self.canvas.useImageToRender(False) self.canvas.setWheelAction(QgsMapCanvas.WheelZoom) self.setCentralWidget(centralWidget) self.messageBar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) layout = QGridLayout() layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(self.canvas, 0, 0, 2, 1) layout.addWidget(self.messageBar, 0, 0, 1, 1) centralWidget.setLayout(layout) super(AuxiliaryWindow, self).__init__(parent) centralWidget = QWidget(self) self.canvas = QgsMapCanvas(centralWidget) self.messageBar = QgsMessageBar(centralWidget) self.toolPan = QgsMapToolPan(self.canvas) self.qgisCanvas = qgis.utils.iface.mapCanvas() self.qgisTView = qgis.utils.iface.layerTreeView() self.qgisSyncGroup = None self.numWin = numWin self.ltg = QgsLayerTreeGroup('', Qt.Unchecked) self.dockLegend = AuxiliaryLegend(self, numWin) self.root = QgsProject.instance().layerTreeRoot() self.extent = self.actLegend = None self.marker = MarkerWindow(self.canvas) setupUi() populateStatusBar() self.onCurrentLayerChanged(None) self.onDestinationCrsChanged_MapUnitsChanged() self.onHasCrsTransformEnabledChanged( self.qgisCanvas.hasCrsTransformEnabled()) def _connect(self, isConnect=True): widgets = { 'scaleBtn': self.findChild(QToolButton, 'scaleBtn'), 'renderCheck': self.findChild(QCheckBox, 'renderCheck'), 'markerCheck': self.findChild(QCheckBox, 'markerCheck'), 'extentCheck': self.findChild(QCheckBox, 'extentCheck'), 'highlightBtn': self.findChild(QToolButton, 'highlightBtn'), 'scaleFactorSpin': self.findChild(QDoubleSpinBox, 'scaleFactorSpin') } signal_slot = ({ 'signal': widgets['scaleBtn'].clicked, 'slot': self.onClickedScale }, { 'signal': widgets['renderCheck'].toggled, 'slot': self.onToggledRender }, { 'signal': widgets['markerCheck'].toggled, 'slot': self.onToggledMarker }, { 'signal': widgets['extentCheck'].toggled, 'slot': self.onToggledExtent }, { 'signal': widgets['highlightBtn'].clicked, 'slot': self.onClickedHighlight }, { 'signal': widgets['scaleFactorSpin'].valueChanged, 'slot': self.onValueChangedScale }, { 'signal': self.dockLegend.currentLayerChanged, 'slot': self.onCurrentLayerChanged }, { 'signal': self.dockLegend.currentLayerQgis, 'slot': self.onCurrentLayerQgis }, { 'signal': self.dockLegend.syncGroupLayer, 'slot': self.onSyncGroupAddLayersQgis }, { 'signal': self.dockLegend.addSelectedLayersQgis, 'slot': self.onAddSelectedLayersQgis }, { 'signal': self.dockLegend.removeLayer, 'slot': self.onRemoveLayers }, { 'signal': self.dockLegend.needSelectLayer, 'slot': self.onNeedSelectLayer }, { 'signal': self.dockLegend.closed, 'slot': self.onClosedLegend }, { 'signal': self.canvas.extentsChanged, 'slot': self.onExtentsChangedMirror }, { 'signal': self.qgisCanvas.extentsChanged, 'slot': self.onExtentsChangedQgisCanvas }, { 'signal': self.qgisCanvas.xyCoordinates, 'slot': self.marker.onXYCoordinates }, { 'signal': self.qgisCanvas.destinationCrsChanged, 'slot': self.onDestinationCrsChanged_MapUnitsChanged }, { 'signal': self.qgisCanvas.mapUnitsChanged, 'slot': self.onDestinationCrsChanged_MapUnitsChanged }, { 'signal': self.qgisCanvas.hasCrsTransformEnabledChanged, 'slot': self.onHasCrsTransformEnabledChanged }, { 'signal': self.root.removedChildren, 'slot': self.onRemovedChildrenQgisRoot }, { 'signal': QgsMapLayerRegistry.instance().layersWillBeRemoved, 'slot': self.onLayersWillBeRemoved }) if isConnect: for item in signal_slot: item['signal'].connect(item['slot']) else: for item in signal_slot: item['signal'].disconnect(item['slot']) def _extentsChanged(self, canvasOrigin, originSlot, canvasDest, scaleFactor=None): canvasOrigin.extentsChanged.disconnect(originSlot) if scaleFactor is None: scale = canvasOrigin.scale() canvasOrigin.setExtent(canvasDest.extent()) canvasOrigin.zoomScale(scale) else: canvasOrigin.setExtent(canvasDest.extent()) canvasOrigin.zoomScale(scaleFactor * canvasDest.scale()) canvasOrigin.extentsChanged.connect(originSlot) def _textScaleBtnChanched(self): scale = locale.format("%.0f", self.canvas.scale(), True) w = self.findChild(QToolButton, 'scaleBtn') w.setText("Scale 1:%s" % scale) def _extent(self): rect = self.qgisCanvas.extent() p1 = QgsPoint(rect.xMinimum(), rect.yMinimum()) p2 = QgsPoint(rect.xMinimum(), rect.yMaximum()) p3 = QgsPoint(rect.xMaximum(), rect.yMaximum()) p4 = QgsPoint(rect.xMaximum(), rect.yMinimum()) p5 = QgsPoint(rect.xMinimum(), rect.yMinimum()) points = [p1, p2, p3, p4, p5] self.extent.setToGeometry(QgsGeometry.fromPolyline(points), None) def _execFunction(self, func, arg, signal, slot): signal.disconnect(slot) func(arg) signal.connect(slot) def _connectVectorRefresh(self, layer, isConnect=True): if isinstance(layer, QgsVectorLayer): f = layer.editCommandEnded.connect if isConnect else layer.editCommandEnded.disconnect f(self.canvas.refresh) def _addLayersQgis(self, layersQgis, needMsg=True): self.dockLegend.clearBridge() l1 = set(layersQgis) l2 = set(map(lambda item: item.layer(), self.ltg.findLayers())) layers = list(l1 - l2) if len(layers) == 0: if needMsg: self.messageBar.pushMessage( "Need select new layer(s) in main map", QgsMessageBar.WARNING, 2) else: # Get order by layersQgis for item in layersQgis: if item in layers: self.ltg.addLayer(item) self._connectVectorRefresh(item) self.dockLegend.setBridge(self.canvas) def _syncGroupAddLayersQgis(self, ltg): layersQgis = map(lambda item: item.layer(), ltg.findLayers()) if len(layersQgis) == 0: return False name = ltg.name() if self.qgisSyncGroup == ltg: msg = "Already synchronized group (main map) -> '%s'" % name self.messageBar.pushMessage(msg, QgsMessageBar.INFO, 4) return True if not self.qgisSyncGroup is None: self.qgisSyncGroup.addedChildren.disconnect( self.addedChildrenLayer) self.qgisSyncGroup = ltg self.qgisSyncGroup.addedChildren.connect(self.addedChildrenLayer) self.dockLegend.addNameSyncGroup(name) msg = "Changed synchronized group (main map) -> '%s'" % name self.messageBar.pushMessage(msg, QgsMessageBar.INFO, 4) self._addLayersQgis(layersQgis) return True def run(self): if len(self.qgisTView.selectedLayerNodes()) > 0: self.onAddSelectedLayersQgis() else: ltn = self.qgisTView.currentNode() if not isinstance(ltn, QgsLayerTreeGroup): return False else: if ltn == self.root: return False else: if not self._syncGroupAddLayersQgis(ltn): return False self.dockLegend.setBridge(self.canvas) self.canvas.setRenderFlag(False) self.show() # Need show before self._connect() self._connect() self.canvas.setExtent(self.qgisCanvas.extent()) w = self.findChild(QDoubleSpinBox, 'scaleFactorSpin') w.setValue(1) self.canvas.setRenderFlag(True) return True def getLayersCanvas(self): layerIds = map(lambda x: x.layerId(), self.ltg.findLayers()) layerChecks = map(lambda x: str(x.isVisible()), self.ltg.findLayers()) return (layerIds, layerChecks) def setLayersCanvas(self, layerIds, layerChecks): prevFlag = self.canvas.renderFlag() self.canvas.setRenderFlag(False) lyrRegs = QgsMapLayerRegistry.instance() for id in range(len(layerIds)): layer = lyrRegs.mapLayer(layerIds[id]) isVisible = int(layerChecks[id]) if not layer is None: self.ltg.addLayer(layer).setVisible(isVisible) self.canvas.setRenderFlag(prevFlag) def getWindowSetting(self): g = self.geometry() r = self.canvas.extent() nodes = self.ltg.findLayers() currentLayer = self.dockLegend.tview.currentLayer() currentLayerId = currentLayer.id( ) if not currentLayer is None else "None" windowSetting = { 'numWin': self.numWin, 'geometryWin': { 'x': g.x(), 'y': g.y(), 'width': g.width(), 'height': g.height() }, 'extentCanvas': { 'xmin': r.xMinimum(), 'ymin': r.yMinimum(), 'xmax': r.xMaximum(), 'ymax': r.yMaximum() }, 'currentLayerId': currentLayerId, 'layerIds': ' '.join(map(lambda item: item.layerId(), nodes)), 'visibles': ' '.join(map(lambda item: str(int(item.isVisible())), nodes)) } for item in ('render', 'marker', 'extent'): nameGui = "%sCheck" % item windowSetting[item] = int( self.findChild(QCheckBox, nameGui).isChecked()) return windowSetting def setWindowSetting(self, windowSetting): self.numWin = windowSetting['numWin'] # Populate with layers and set Bridge for legend layerIds = windowSetting['layerIds'].split(' ') visibles = map(lambda item: bool(int(item)), windowSetting['visibles'].split(' ')) ltg = self.qgisTView.layerTreeModel().rootGroup() for id in range(len(layerIds)): node = ltg.findLayer(layerIds[id]) if node is None: continue layer = node.layer() visible = Qt.Checked if visibles[id] else Qt.Unchecked self._connectVectorRefresh(layer) self.ltg.addLayer(layer).setVisible(visible) self.dockLegend.setBridge(self.canvas) self.show() # Need show before self._connect() self._connect() node = ltg.findLayer(windowSetting['currentLayerId']) if not node is None: layer = node.layer() self.dockLegend.tview.setCurrentLayer(layer) w = windowSetting['extentCanvas'] self.canvas.setExtent( QgsRectangle(w['xmin'], w['ymin'], w['xmax'], w['ymax'])) for item in ('render', 'marker', 'extent'): value = bool(windowSetting[item]) nameGui = "%sCheck" % item self.findChild(QCheckBox, nameGui).setChecked(value) def closeEvent(self, event): self._connect(False) event.accept() self.closed.emit(self.numWin) @pyqtSlot(int) def onValueChangedScale(self, scaleFactor): w = self.findChild(QCheckBox, 'renderCheck') if not w.isChecked(): return self._execFunction(self.canvas.zoomScale, scaleFactor * self.qgisCanvas.scale(), self.canvas.extentsChanged, self.onExtentsChangedMirror) self._textScaleBtnChanched() @pyqtSlot() def onClickedScale(self): self._execFunction(self.qgisCanvas.zoomScale, self.canvas.scale(), self.qgisCanvas.extentsChanged, self.onExtentsChangedQgisCanvas) w = self.findChild(QDoubleSpinBox, 'scaleFactorSpin') self._execFunction(w.setValue, 1.0, w.valueChanged, self.onValueChangedScale) @pyqtSlot() def onClickedHighlight(self): def removeRB(): rb.reset(True) self.qgisCanvas.scene().removeItem(rb) rb = QgsRubberBand(self.qgisCanvas, QGis.Polygon) rb.setBorderColor(QColor(255, 0, 0)) rb.setWidth(2) rb.setToGeometry(QgsGeometry.fromRect(self.canvas.extent()), None) QTimer.singleShot(2000, removeRB) @pyqtSlot(bool) def onToggledRender(self, enabled): if enabled: self.canvas.setMapTool(self.toolPan) w = self.findChild(QDoubleSpinBox, 'scaleFactorSpin') self._extentsChanged(self.canvas, self.onExtentsChangedMirror, self.qgisCanvas, w.value()) self._textScaleBtnChanched() self.canvas.setWheelAction(QgsMapCanvas.WheelZoom) else: self.canvas.unsetMapTool(self.toolPan) self.canvas.setWheelAction(QgsMapCanvas.WheelNothing) self.canvas.setRenderFlag(enabled) @pyqtSlot(bool) def onToggledMarker(self, enabled): self.marker.add() if enabled else self.marker.remove() @pyqtSlot(bool) def onToggledExtent(self, enabled): def setExtent(): if not self.extent is None: self.canvas.scene().removeItem(self.extent) self.extent = QgsRubberBand(self.canvas, QGis.Polygon) self.extent.setBorderColor(QColor(255, 0, 0)) self.extent.setWidth(2) self._extent() if enabled: setExtent() else: if not self.extent is None: self.canvas.scene().removeItem(self.extent) self.extent = None @pyqtSlot() def onExtentsChangedMirror(self): w = self.findChild(QCheckBox, 'renderCheck') if not w.isChecked(): return self._extentsChanged(self.qgisCanvas, self.onExtentsChangedQgisCanvas, self.canvas) self._textScaleBtnChanched() w = self.findChild(QDoubleSpinBox, 'scaleFactorSpin') self._execFunction(w.setValue, self.canvas.scale() / self.qgisCanvas.scale(), w.valueChanged, self.onValueChangedScale) if not self.extent is None: self._extent() @pyqtSlot() def onExtentsChangedQgisCanvas(self): w = self.findChild(QCheckBox, 'renderCheck') if not w.isChecked(): return w = self.findChild(QDoubleSpinBox, 'scaleFactorSpin') self._extentsChanged(self.canvas, self.onExtentsChangedMirror, self.qgisCanvas, w.value()) self._textScaleBtnChanched() if not self.extent is None: self._extent() @pyqtSlot() def onDestinationCrsChanged_MapUnitsChanged(self): prevFlag = self.canvas.renderFlag() self.canvas.setRenderFlag(False) self.canvas.setDestinationCrs( self.qgisCanvas.mapRenderer().destinationCrs()) self.canvas.setMapUnits(self.qgisCanvas.mapUnits()) self.canvas.setRenderFlag(prevFlag) @pyqtSlot(bool) def onHasCrsTransformEnabledChanged(self, enabled): prevFlag = self.canvas.renderFlag() self.canvas.setRenderFlag(False) self.canvas.mapRenderer().setProjectionsEnabled(enabled) self.canvas.setRenderFlag(prevFlag) @pyqtSlot(list) def onLayersWillBeRemoved(self, theLayerIds): ids = list(set(self.ltg.findLayerIds()) & set(theLayerIds)) # intersection nodes = map(lambda item: self.ltg.findLayer(item), ids) for item in nodes: self._connectVectorRefresh(item.layer(), False) self.ltg.removeChildNode(item) @pyqtSlot() def onAddSelectedLayersQgis(self): layersQgis = map(lambda item: item.layer(), self.qgisTView.selectedLayerNodes()) self._addLayersQgis(layersQgis) @pyqtSlot('QgsLayerTreeNode', int, int) def addedChildrenLayer(self, ltg, indexFrom, indexTo): layersQgis = map(lambda item: item.layer(), ltg.findLayers()) self._addLayersQgis(layersQgis, False) @pyqtSlot('QgsLayerTreeNode', int, int) def onRemovedChildrenQgisRoot(self, ltg, indexFrom, indexTo): if not self.qgisSyncGroup is None and not self.qgisSyncGroup in self.root.children( ): self.qgisSyncGroup = None self.dockLegend.addNameSyncGroup("None") msg = "Removed synchronized group (main map)" self.messageBar.pushMessage(msg, QgsMessageBar.INFO, 4) @pyqtSlot() def onSyncGroupAddLayersQgis(self): msg = "Need active a group in main map with new layers" ltn = self.qgisTView.currentNode() if not isinstance(ltn, QgsLayerTreeGroup) or ltn == self.root: self.messageBar.pushMessage(msg, QgsMessageBar.WARNING, 3) return if not self._syncGroupAddLayersQgis(ltn): self.messageBar.pushMessage(msg, QgsMessageBar.WARNING, 3) @pyqtSlot('QgsMapLayer') def onRemoveLayers(self, layer): self._connectVectorRefresh(layer, False) @pyqtSlot() def onNeedSelectLayer(self): self.messageBar.pushMessage("Need select layer(s)", QgsMessageBar.WARNING, 2) @pyqtSlot('QgsMapLayer') def onCurrentLayerQgis(self, layer): if layer is None: self.messageBar.pushMessage("Need active layer", QgsMessageBar.WARNING, 2) else: self.qgisTView.setCurrentLayer(layer) @pyqtSlot('QgsMapLayer') def onCurrentLayerChanged(self, layer): hasLayer = True if not layer is None else False selectName = "Select layer '%s'" % layer.name( ) if hasLayer else "None select layer" title = "#%d - %s" % (self.numWin, selectName) self.setWindowTitle(title) @pyqtSlot() def onClosedLegend(self): self.actLegend.setText("Show layers") @pyqtSlot() def onActionLegend(self): self.actLegend.setText("") self.dockLegend.show()
class AreaTool(QgsMapTool): """ Map tool class to select an area """ releasedSignal = pyqtSignal() def __init__(self, iface): """ Constructor :param iface: interface """ QgsMapTool.__init__(self, iface.mapCanvas()) self.__clear() def activate(self): """ When the action is selected """ QgsMapTool.activate(self) self.__rubber = QgsRubberBand(self.canvas(), QGis.Polygon) color = QColor("red") color.setAlphaF(0.6) self.__rubber.setBorderColor(color) color = QColor("orange") color.setAlphaF(0.3) self.__rubber.setFillColor(color) def deactivate(self): """ When the action is deselected """ self.__clear() QgsMapTool.deactivate(self) def __clear(self): """ To clear used variables """ self.__selecting = False self.__rubber = None self.first = None self.last = None self.geom = None def canvasMoveEvent(self, event): """ When the mouse is moved :param event: mouse event """ if self.__selecting: self.__rubber.reset() firstV2 = QgsPointV2(self.first) second = QgsPointV2(self.first.x(), event.mapPoint().y()) third = QgsPointV2(event.mapPoint()) fourth = QgsPointV2(event.mapPoint().x(), self.first.y()) lineV2 = QgsLineStringV2() lineV2.setPoints([firstV2, second, third, fourth, firstV2]) polygonV2 = QgsPolygonV2() polygonV2.setExteriorRing(lineV2) self.geom = QgsGeometry(polygonV2) self.__rubber.setToGeometry(self.geom, None) def canvasPressEvent(self, event): """ When the mouse is pressed :param event: mouse event """ self.__selecting = True self.first = event.mapPoint() def canvasReleaseEvent(self, event): """ When the mouse is clicked :param event: mouse event """ self.__selecting = False self.last = event.mapPoint() self.__rubber.reset() self.releasedSignal.emit()
class ObstacleAreaJigCreateArea(QgsMapTool): def __init__(self, canvas, areaType): QgsMapTool.__init__(self, canvas) self.mCanvas = canvas self.areaType = areaType self.annotation = None self.rubberBand = QgsRubberBand(canvas, QGis.Point) self.rubberBand.setColor(Qt.red) self.rubberBand.setWidth(10) self.rubberBandClick = QgsRubberBand(canvas, QGis.Point) self.rubberBandClick.setColor(Qt.green) self.rubberBandClick.setWidth(3) self.obstaclesLayerList = QgisHelper.getSurfaceLayers(SurfaceTypes.Obstacles) self.demLayerList = QgisHelper.getSurfaceLayers(SurfaceTypes.DEM) self.mRubberBand = None self.mRubberBand0 = QgsRubberBand( self.mCanvas, QGis.Polygon ) self.mCursor = Qt.ArrowCursor self.mFillColor = QColor( 254, 178, 76, 63 ) self.mBorderColour = QColor( 254, 58, 29, 100 ) self.mRubberBand0.setBorderColor( self.mBorderColour ) self.polygonGeom = None self.drawFlag = False self.mSnapper = QgsMapCanvasSnapper(canvas) self.resultPolylineArea = PolylineArea() # self.constructionLayer = constructionLayer self.menuString = "" self.isPrimaryPolylineStarted = False self.primaryPolyline = PolylineArea() def createContextMenu(self, areaType, isStarted = False): menu = QMenu() # h = QHBoxLayout(menu) # c = QCalendarWidget() # h.addWidget(c) if areaType == ProtectionAreaType.Primary: actionEnter = QgisHelper.createAction(menu, "Enter", self.menuEnterClick) actionCancel = QgisHelper.createAction(menu, "Cancel", self.menuCancelClick) actionArc = QgisHelper.createAction(menu, "Arc", self.menuArcClick) actionUndo = QgisHelper.createAction(menu, "Undo", self.menuUndoClick) menu.addAction( actionEnter ) menu.addAction( actionCancel ) menu.addAction( actionArc ) menu.addAction( actionUndo ) elif areaType == ProtectionAreaType.Secondary: if not isStarted: actionEnter = QgisHelper.createAction(menu, "Enter", self.menuEnterClick) actionCancel = QgisHelper.createAction(menu, "Cancel", self.menuCancelClick) actionUndo = QgisHelper.createAction(menu, "Undo", self.menuUndoClick) actionPrimatyPolylineStart = QgisHelper.createAction(menu, "Strat INNER edge of the secondary area", self.menuPrimaryStartClick) actionPrimatyPolylineEnd = QgisHelper.createAction(menu, "End INNER edge of the secondary area", self.menuPrimaryEndClick) menu.addAction( actionEnter ) menu.addAction( actionCancel ) menu.addAction( actionUndo ) menu.addAction( actionPrimatyPolylineStart ) menu.addAction( actionPrimatyPolylineEnd ) actionPrimatyPolylineStart.setEnabled(not self.isPrimaryPolylineStarted) actionPrimatyPolylineEnd.setEnabled(self.isPrimaryPolylineStarted) else: actionPrimatyPolylineStart = QgisHelper.createAction(menu, "Strat INNER edge of the secondary area", self.menuPrimaryStartClick) actionPrimatyPolylineEnd = QgisHelper.createAction(menu, "End INNER edge of the secondary area", self.menuPrimaryEndClick) menu.addAction( actionPrimatyPolylineStart ) menu.addAction( actionPrimatyPolylineEnd ) actionPrimatyPolylineStart.setEnabled(not self.isPrimaryPolylineStarted) actionPrimatyPolylineEnd.setEnabled(self.isPrimaryPolylineStarted) return menu def menuPrimaryStartClick(self): self.primaryPolyline = PolylineArea() self.isPrimaryPolylineStarted = True # self.menuString = "Enter" def menuPrimaryEndClick(self): self.isPrimaryPolylineStarted = False # self.menuString = "Enter" def menuEnterClick(self): self.menuString = "Enter" def menuCancelClick(self): self.menuString = "Cancel" def menuArcClick(self): self.menuString = "Arc" def menuUndoClick(self): self.menuString = "Undo" def reset(self): self.Point = None def canvasPressEvent( self, e ): define._messageLabel.setText("") self.menuString = "" pointBackground = e.pos() # self.Point = QgisHelper.snapPoint(e.pos(), self.mSnapper, define._canvas) self.Point, self.pointID, self.layer= self.snapPoint(e.pos()) self.selectedLayerFromSnapPoint = None if ( self.mRubberBand == None ): self.resultPolylineArea = PolylineArea() self.mRubberBand0.reset( QGis.Polygon ) # define._canvas.clearCache () self.mRubberBand = QgsRubberBand( self.mCanvas, QGis.Polygon ) self.mRubberBand0 = QgsRubberBand( self.mCanvas, QGis.Polygon ) self.mRubberBand.setFillColor( self.mFillColor ) self.mRubberBand.setBorderColor( self.mBorderColour ) self.mRubberBand0.setFillColor( QColor(255, 255, 255, 100) ) self.mRubberBand0.setBorderColor( QColor(0, 0, 0) ) if ( e.button() == Qt.LeftButton ): if self.Point == None: self.mRubberBand.addPoint( self.toMapCoordinates( e.pos() ) ) self.resultPolylineArea.Add(PolylineAreaPoint(self.toMapCoordinates( e.pos() ))) if self.isPrimaryPolylineStarted: self.primaryPolyline.Add(PolylineAreaPoint(self.toMapCoordinates( e.pos() ))) else: self.mRubberBand.addPoint( self.Point ) self.resultPolylineArea.Add(PolylineAreaPoint(self.Point)) if self.isPrimaryPolylineStarted: self.primaryPolyline.Add(PolylineAreaPoint(self.toMapCoordinates( e.pos() ))) else: menu = None if self.areaType == ProtectionAreaType.Secondary and len(self.resultPolylineArea) == 0: menu = self.createContextMenu(self.areaType, True) menu.exec_( define._canvas.mapToGlobal(e.pos() )) return if ( self.mRubberBand.numberOfVertices() > 2 ): self.polygonGeom = self.mRubberBand.asGeometry() else: return # QgsMapToolSelectUtils.setSelectFeatures( self.mCanvas, polygonGeom, e ) menu = self.createContextMenu(self.areaType) menu.exec_( define._canvas.mapToGlobal(e.pos() )) if self.menuString == "Cancel" or self.menuString == "Arc": return elif self.menuString == "Undo": if ( self.mRubberBand.numberOfVertices() > 0 ): self.mRubberBand = None QgisHelper.ClearRubberBandInCanvas(define._canvas) self.mRubberBand = QgsRubberBand( self.mCanvas, QGis.Polygon ) self.mRubberBand.setFillColor( self.mFillColor ) self.mRubberBand.setBorderColor( self.mBorderColour ) self.resultPolylineArea[self.resultPolylineArea.Count - 2].bulge = 0.0 self.resultPolylineArea.pop(self.resultPolylineArea.Count - 1) if self.isPrimaryPolylineStarted and len(self.primaryPolyline) > 0: self.primaryPolyline.pop(self.primaryPolyline.Count - 1) for pt in self.resultPolylineArea.method_14(): self.mRubberBand.addPoint(pt) return elif self.menuString == "Enter": # if self.areaType == ProtectionAreaType.Secondary: # if self.resultPolylineArea.Count != 4: # define._messageLabel.setText("The count of point of Secondary Area must be 4.") # return self.mRubberBand.reset( QGis.Polygon ) self.mRubberBand0.reset( QGis.Polygon ) # define._canvas.clearCache () self.mRubberBand0 = QgsRubberBand( self.mCanvas, QGis.Polygon ) self.mRubberBand0.setFillColor( QColor(255, 255, 255, 100) ) self.mRubberBand0.setBorderColor( QColor(0, 0, 0) ) for pt in self.resultPolylineArea.method_14(): self.mRubberBand0.addPoint(pt) # self.mRubberBand0.addGeometry(self.polygonGeom, None) n = self.mRubberBand0.numberOfVertices() self.mRubberBand0.show() self.mRubberBand = None area = None if self.areaType == ProtectionAreaType.Primary: area = PrimaryObstacleArea(self.resultPolylineArea) elif self.areaType == ProtectionAreaType.Secondary: if len(self.resultPolylineArea) == 4: area = SecondaryObstacleArea(self.resultPolylineArea[0].Position, self.resultPolylineArea[1].Position, self.resultPolylineArea[3].Position, self.resultPolylineArea[2].Position, MathHelper.getBearing(self.resultPolylineArea[0].Position, self.resultPolylineArea[1].Position)) else: if self.primaryPolyline.Count < 2: define._messageLabel.setText("The PrimaryLine in Secondary Area must exist.") return if self.isPrimaryPolylineStarted: define._messageLabel.setText("You must finish the input of PrimaryLine.") return area = SecondaryObstacleAreaWithManyPoints(self.resultPolylineArea, self.primaryPolyline) self.emit(SIGNAL("outputResult"), area, self.mRubberBand0) n = 0 def canvasMoveEvent( self, e ): self.rubberBand.reset(QGis.Point) # snapPoint = QgisHelper.snapPoint(e.pos(), self.mSnapper , define._canvas, True) snapPoint, snapPointID, layer = self.snapPoint(e.pos(), True) if snapPoint != None: self.rubberBand.addPoint(snapPoint) self.rubberBand.show() if ( self.mRubberBand == None ): return if ( self.mRubberBand.numberOfVertices() > 0 ): if self.menuString != "Undo": self.mRubberBand.removeLastPoint( 0 ) else: self.menuString = "" point2 = None if snapPoint != None: self.mRubberBand.addPoint( snapPoint) point2 = snapPoint else: self.mRubberBand.addPoint( self.toMapCoordinates( e.pos() ) ) point2 = self.toMapCoordinates( e.pos() ) if self.menuString == "Arc": point0 = self.resultPolylineArea[self.resultPolylineArea.Count - 2].Position point1 = self.resultPolylineArea[self.resultPolylineArea.Count - 1].Position # point2 = self.mRubberBand.getPoint(self.mRubberBand.numberOfVertices() - 1) bulge = MathHelper.smethod_60(point0, point1, point2) self.resultPolylineArea[self.resultPolylineArea.Count - 2].bulge = bulge self.mRubberBand = None QgisHelper.ClearRubberBandInCanvas(define._canvas) self.mRubberBand = QgsRubberBand( self.mCanvas, QGis.Polygon ) self.mRubberBand.setFillColor( self.mFillColor ) self.mRubberBand.setBorderColor( self.mBorderColour ) for pt in self.resultPolylineArea.method_14(): self.mRubberBand.addPoint(pt) self.mRubberBand.addPoint(point2) def snapPoint(self, p, bNone = False): if define._snapping == False: return (define._canvas.getCoordinateTransform().toMapCoordinates( p ), None, None) snappingResults = self.mSnapper.snapToBackgroundLayers( p ) if ( snappingResults[0] != 0 or len(snappingResults[1]) < 1 ): if bNone: return (None, None, None) else: return (define._canvas.getCoordinateTransform().toMapCoordinates( p ), None, None) else: return (snappingResults[1][0].snappedVertex, snappingResults[1][0].snappedAtGeometry, snappingResults[1][0].layer) def deactivate(self): self.rubberBand.reset(QGis.Point) QgsMapTool.deactivate(self) self.emit(SIGNAL("deactivated()"))
class ConnecMapTool(ParentMapTool): """ Button 20. User select connections from layer 'connec' Execute SQL function: 'gw_fct_connect_to_network' """ def __init__(self, iface, settings, action, index_action): """ Class constructor """ # Call ParentMapTool constructor super(ConnecMapTool, self).__init__(iface, settings, action, index_action) self.dragging = False # Vertex marker self.vertexMarker = QgsVertexMarker(self.canvas) self.vertexMarker.setColor(QColor(255, 25, 25)) self.vertexMarker.setIconSize(11) self.vertexMarker.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X self.vertexMarker.setPenWidth(5) # Rubber band self.rubberBand = QgsRubberBand(self.canvas, True) mFillColor = QColor(100, 0, 0) self.rubberBand.setColor(mFillColor) self.rubberBand.setWidth(3) mBorderColor = QColor(254, 58, 29) self.rubberBand.setBorderColor(mBorderColor) # Select rectangle self.selectRect = QRect() def reset(self): """ Clear selected features """ layer = self.layer_connec if layer is not None: layer.removeSelection() # Graphic elements self.rubberBand.reset() """ QgsMapTools inherited event functions """ def canvasMoveEvent(self, event): """ With left click the digitizing is finished """ if event.buttons() == Qt.LeftButton: if not self.dragging: self.dragging = True self.selectRect.setTopLeft(event.pos()) self.selectRect.setBottomRight(event.pos()) self.set_rubber_band() else: # Hide highlight self.vertexMarker.hide() # Get the click x = event.pos().x() y = event.pos().y() eventPoint = QPoint(x, y) # Snapping (retval, result) = self.snapper.snapToBackgroundLayers(eventPoint) # @UnusedVariable # That's the snapped point if result <> []: # Check Arc or Node for snapPoint in result: if snapPoint.layer == self.layer_connec: # Get the point point = QgsPoint(result[0].snappedVertex) # Add marker self.vertexMarker.setCenter(point) self.vertexMarker.show() break def canvasPressEvent(self, event): self.selectRect.setRect(0, 0, 0, 0) self.rubberBand.reset() def canvasReleaseEvent(self, event): """ With left click the digitizing is finished """ if event.button() == Qt.LeftButton: # Get the click x = event.pos().x() y = event.pos().y() eventPoint = QPoint(x, y) # Node layer layer = self.layer_connec # Not dragging, just simple selection if not self.dragging: # Snap to node (retval, result) = self.snapper.snapToBackgroundLayers(eventPoint) # @UnusedVariable # That's the snapped point if result <> [] and (result[0].layer.name() == self.layer_connec.name()): point = QgsPoint(result[0].snappedVertex) # @UnusedVariable layer.removeSelection() layer.select([result[0].snappedAtGeometry]) # Create link self.link_connec() # Hide highlight self.vertexMarker.hide() else: # Set valid values for rectangle's width and height if self.selectRect.width() == 1: self.selectRect.setLeft(self.selectRect.left() + 1) if self.selectRect.height() == 1: self.selectRect.setBottom(self.selectRect.bottom() + 1) self.set_rubber_band() selectGeom = self.rubberBand.asGeometry() # @UnusedVariable self.select_multiple_features(self.selectRectMapCoord) self.dragging = False # Create link self.link_connec() elif event.button() == Qt.RightButton: # Create link self.link_connec() def activate(self): # Check button self.action().setChecked(True) # Rubber band self.rubberBand.reset() # Store user snapping configuration self.snapperManager.storeSnappingOptions() # Clear snapping self.snapperManager.clearSnapping() # Set snapping to arc and node self.snapperManager.snapToConnec() # Change cursor self.canvas.setCursor(self.cursor) # Show help message when action is activated if self.show_help: message = ( "Right click to use current selection, select connec points by clicking or dragging (selection box)" ) self.controller.show_info(message, context_name="ui_message") # Control current layer (due to QGIS bug in snapping system) try: if self.canvas.currentLayer().type() == QgsMapLayer.VectorLayer: self.canvas.setCurrentLayer(self.layer_connec) except: self.canvas.setCurrentLayer(self.layer_connec) def deactivate(self): # Check button self.action().setChecked(False) # Rubber band self.rubberBand.reset() # Restore previous snapping self.snapperManager.recoverSnappingOptions() # Recover cursor self.canvas.setCursor(self.stdCursor) def link_connec(self): """ Link selected connec to the pipe """ # Get selected features (from layer 'connec') aux = "{" layer = self.layer_connec if layer.selectedFeatureCount() == 0: message = "You have to select at least one feature!" self.controller.show_warning(message, context_name="ui_message") return features = layer.selectedFeatures() for feature in features: connec_id = feature.attribute("connec_id") aux += str(connec_id) + ", " connec_array = aux[:-2] + "}" # Execute function function_name = "gw_fct_connect_to_network" sql = "SELECT " + self.schema_name + "." + function_name + "('" + connec_array + "');" self.controller.execute_sql(sql) # Refresh map canvas self.rubberBand.reset() self.iface.mapCanvas().refresh() def set_rubber_band(self): # Coordinates transform transform = self.canvas.getCoordinateTransform() # Coordinates ll = transform.toMapCoordinates(self.selectRect.left(), self.selectRect.bottom()) lr = transform.toMapCoordinates(self.selectRect.right(), self.selectRect.bottom()) ul = transform.toMapCoordinates(self.selectRect.left(), self.selectRect.top()) ur = transform.toMapCoordinates(self.selectRect.right(), self.selectRect.top()) # Rubber band self.rubberBand.reset() self.rubberBand.addPoint(ll, False) self.rubberBand.addPoint(lr, False) self.rubberBand.addPoint(ur, False) self.rubberBand.addPoint(ul, False) self.rubberBand.addPoint(ll, True) self.selectRectMapCoord = QgsRectangle(ll, ur) def select_multiple_features(self, selectGeometry): # Default choice behaviour = QgsVectorLayer.SetSelection # Modifiers modifiers = QApplication.keyboardModifiers() if modifiers == Qt.ControlModifier: behaviour = QgsVectorLayer.AddToSelection elif modifiers == Qt.ShiftModifier: behaviour = QgsVectorLayer.RemoveFromSelection if self.layer_connec is None: return # Change cursor QApplication.setOverrideCursor(Qt.WaitCursor) # Selection self.layer_connec.selectByRect(selectGeometry, behaviour) # Old cursor QApplication.restoreOverrideCursor()