def _getExtent(self, layer): def getTargetWindow(): nodes = doc.elementsByTagName('TargetWindow') node = nodes.item(0) targetWindow = {'ulX': None, 'ulY': None, 'lrX': None, 'lrY': None} labels = { 'UpperLeftX': 'ulX', 'UpperLeftY': 'ulY', 'LowerRightX': 'lrX', 'LowerRightY': 'lrY' } for key, value in labels.iteritems(): text = node.firstChildElement(key).text() if len(text) == 0: continue targetWindow[value] = float(text) return targetWindow doc = QtXml.QDomDocument() file = QtCore.QFile(layer.source()) doc.setContent(file) file.close() tw = getTargetWindow() return QgsCore.QgsRectangle(tw['ulX'], tw['lrY'], tw['lrX'], tw['ulY'])
def _alignRectangleToGrid(self, rect): """Aligns the given rectangle to the grid of the raster layer. Parameters ---------- rect : QGisCore.QgsRectangle Rectangle to align. Returns ------- QGisCore.QgsRectangle New rectangle, aligned to the grid of the raster layer. """ rasterExtent = self.rasterLayer.extent() newRect = QGisCore.QgsRectangle() newRect.setXMinimum(rasterExtent.xMinimum() + (round( (rect.xMinimum() - rasterExtent.xMinimum()) / self.pixelSizeX) * self.pixelSizeX)) newRect.setYMinimum(rasterExtent.yMinimum() + (round( (rect.yMinimum() - rasterExtent.yMinimum()) / self.pixelSizeY) * self.pixelSizeY)) newRect.setXMaximum(newRect.xMinimum() + (int(rect.width() / self.pixelSizeX) * self.pixelSizeX)) newRect.setYMaximum(newRect.yMinimum() + (int(rect.height() / self.pixelSizeY) * self.pixelSizeY)) return newRect
def getContextFeatures(self,point): dist = self.getDistanceBuffer() context = core.QgsRectangle(point.x()-dist,point.y()-dist,point.x()+dist,point.y()+dist) try: return self.infoIndex.intersects(context) except: return []
def rectangle(self): if self.start_point is None or self.end_point is None: self.resetLimites() return None elif self.start_point.x() == self.end_point.x() or self.start_point.y() == \ self.end_point.y(): self.resetLimites() return None return core.QgsRectangle(self.start_point, self.end_point)
def zoomExtent(self): """Zoom the map canvas to the extent of the listed parcels.""" if len(self.parcelList) < 1: return extent = QGisCore.QgsRectangle( self.parcelList[0].geometry().boundingBox()) for p in self.parcelList[1:]: extent.combineExtentWith(p.geometry().boundingBox()) self.main.iface.mapCanvas().setExtent(extent.buffer(10)) self.main.iface.mapCanvas().refresh()
def make_qgis_project_file(path): """Create a QGIS project file with the correct stuff in it. path: the desired path to .qgs project file, e.g.: /luigi/data/qgreenland/qgreenland.qgs Developed from examples: https://docs.qgis.org/testing/en/docs/pyqgis_developer_cookbook/intro.html#using-pyqgis-in-standalone-scripts """ # The qgis prefix path is two directories above the qgis executable. # See: # https://docs.qgis.org/testing/en/docs/pyqgis_developer_cookbook/intro.html#using-pyqgis-in-standalone-scripts qgis_path = subprocess.run( ['which', 'qgis'], stdout=subprocess.PIPE).stdout.decode('utf-8').strip('\n') qgis_prefix_path = os.path.abspath(os.path.join(qgis_path, '..', '..')) # Boilerplate QGIS initialization code; # - Suppresses "Application path not intialized" errors # - Enables Qt support for fonts used in layer styles (labels) qgs = qgc.QgsApplication([], False) qgs.initQgis() qgc.QgsApplication.setPrefixPath(qgis_prefix_path, True) # Create a new project; initializes basic structure project = qgc.QgsProject.instance() project.write(path) project_crs = qgc.QgsCoordinateReferenceSystem(CONFIG['project']['crs']) project.setCrs(project_crs) # Set the default extent. Eventually we may want to pull the extent directly # from the configured 'map frame' layer. view = project.viewSettings() background_extent = CONFIG['project']['extents']['data'] extent = qgc.QgsReferencedRectangle( qgc.QgsRectangle(*background_extent.values()), project_crs) view.setDefaultViewExtent(extent) _add_layers(project) _add_decorations(project) _set_groups_options(project) _add_empty_groups(project) # TODO: is it normal to write multiple times? project.write() # Release all file locks! If we don't do this, we won't be able to clean up # layer source files after zipping the project. project.clear()
def changeMarker(self, strListExtent): if not self.__showMarker: return # left, bottom, right, top left, bottom, right, top = [ float(item) for item in strListExtent.split(',') ] pointCenter = core.QgsRectangle(core.QgsPoint(left, top), core.QgsPoint(right, bottom)).center() srsCanvas = self.__canvas.mapRenderer().destinationSrs() if self.__srsOL != srsCanvas: coodTrans = core.QgsCoordinateTransform(self.__srsOL, srsCanvas) pointCenter = coodTrans.transform(pointCenter, core.QgsCoordinateTransform.ForwardTransform) self.__refresh(pointCenter)
def set_layer_extent(map_canvas, gpx_layer): """ Sets the layer extent and zooms in to 1:1 scale :param gpx_layer: GPX layer object :param map_canvas: Map canvas object :return: None :rtype: None """ x_min, x_max, y_min, y_max = gpx_layer.GetExtent() extent = q_core.QgsRectangle(x_min, y_min, x_max, y_max) extent.scale(1.1) map_canvas.setExtent(extent) map_canvas.refresh()
def _process(self): """Calculate the new, aligned, geometry. Loop over all raster cells within the bounding box of the geometry and check for each of them if they should be part of the new geometry. Build a new QgsGeometry from the matching cells. Also builds a dictionary of statistics for the new QgsGeometry: listing the count, sum and average (mean) values of the raster cells it contains. """ valSum = 0 valCnt = 0 noData = None if self.rasterLayer.dataProvider().srcHasNoDataValue(self.band): noData = self.rasterLayer.dataProvider().srcNoDataValue(self.band) for r in range(self.blockHeight): for c in range(self.blockWidth): cellRect = QGisCore.QgsRectangle() cellRect.setXMinimum(self.blockBbox.xMinimum() + (c * self.pixelSizeX)) cellRect.setYMinimum(self.blockBbox.yMaximum() - (r * self.pixelSizeY) - self.pixelSizeY) cellRect.setXMaximum(self.blockBbox.xMinimum() + (c * self.pixelSizeX) + self.pixelSizeX) cellRect.setYMaximum(self.blockBbox.yMaximum() - (r * self.pixelSizeY)) if self._rasterCellMatchesGeometry(cellRect): value = self.block.value(r, c) if noData and value == noData: continue valSum += self.block.value(r, c) valCnt += 1 if not self.newGeometry: self.newGeometry = QGisCore.QgsGeometry.fromRect( cellRect) else: self.newGeometry = self.newGeometry.combine( QGisCore.QgsGeometry.fromRect(cellRect)) if valCnt > 0: self.stats.clear() self.stats['sum'] = valSum self.stats['count'] = valCnt self.stats['avg'] = valSum / float(valCnt)
def place_rubberband(self, xmin, xmax, ymin, ymax): """place rubberband on the canvas""" try: self.rubberBand.reset() self.canvas.scene().removeItem(self.rubberBand) except: #pylint: disable=bare-except pass self.rubberBand = RH.init_rubberband('grid', self.canvas, 'polygon') tempRect = QC.QgsRectangle(QC.QgsPointXY(xmin, ymin), QC.QgsPointXY(xmax, ymax)) tempGeom = QC.QgsGeometry.fromRect(tempRect) crs = QC.QgsCoordinateReferenceSystem(GH.PROJECTCRS) self.rubberBand.reset() self.rubberBand.setToGeometry(tempGeom, crs) self.rubberBand.show()
def make_qgis_project_file(path: Path) -> None: """Create a QGIS project file with the correct stuff in it. path: the desired path to .qgs/.qgz project file, e.g.: /luigi/data/qgreenland/qgreenland.qgs Developed from examples: https://docs.qgis.org/testing/en/docs/pyqgis_developer_cookbook/intro.html#using-pyqgis-in-standalone-scripts """ config = get_config() # Create a new project; initializes basic structure project = qgc.QgsProject.instance() project.write(str(path)) project_crs = qgc.QgsCoordinateReferenceSystem(config.project.crs) project.setCrs(project_crs) # Set the map background color to be gray (same color as Quantarctica) project.setBackgroundColor(QColor(200, 200, 200)) # Set the default extent. Eventually we may want to pull the extent directly # from the configured 'map frame' layer. view = project.viewSettings() project_rectangle = qgc.QgsReferencedRectangle( qgc.QgsRectangle( config.project.boundaries['data'].bbox.min_x, config.project.boundaries['data'].bbox.min_y, config.project.boundaries['data'].bbox.max_x, config.project.boundaries['data'].bbox.max_y, ), project_crs, ) view.setDefaultViewExtent(project_rectangle) _add_decorations(project) package_layer_tree = prune_layers_not_in_package(config.layer_tree) _add_layers_and_groups(project, package_layer_tree) # TODO: is it normal to write multiple times? project.write() # Release all file locks! If we don't do this, we won't be able to clean up # layer source files after zipping the project. project.clear()
import os wd = os.path.dirname(__file__) vlayer = core.QgsVectorLayer(wd + "/../data/regioni.shp", "regioni", "ogr") vlayer.isValid() core.QgsMapLayerRegistry.instance().addMapLayer(vlayer) from PyQt4 import QtGui, QtCore img = QtGui.QImage(QtCore.QSize(800, 600), QtGui.QImage.Format_ARGB32_Premultiplied) p = QtGui.QPainter() p.begin(img) p.setRenderHint(QtGui.QPainter.Antialiasing) render = core.QgsMapRenderer() lst = [vlayer.getLayerID()] render.setLayerSet(lst) rect = core.QgsRectangle(render.fullExtent()) rect.scale(1.1) render.setExtent(rect) render.setOutputSize(img.size(), img.logicalDpiX()) img.size() p.isActive() render.render(p) p.end() img.save(wd + "/../images/regioni_qgis.png", "png")
def __init__(self, parent, boundingbox): super(ExtentDialog, self).__init__(parent) self.setupUi(self) self.superParent = None temp = self.parent() if platform.system() != "Linux": font = QFont() font.setFamily(u"Segoe UI Symbol") self.setFont(font) while self.superParent is None: if issubclass(type(temp), geographicinformationPanel.Ui_geographicinfo): self.superParent = temp else: temp = temp.parent() for info in self.findChildren(qwidgets.QPushButton, qcore.QRegExp('info_*')): info.setIcon(qgui.QIcon(':/resourcesFolder/icons/help_icon.svg')) info.setText('') info.pressed.connect(self.printHelp) self.layers = [] self.maxExt = None self.boundingbox = boundingbox self.outBB = False # Create MapCanvas self.canvas = gui.QgsMapCanvas(self) # Append to Dialog Layout self.toolBar = qwidgets.QToolBar() self.layout = qwidgets.QVBoxLayout(self.frame) self.layout.addWidget(self.toolBar) self.layout.addWidget(self.canvas) # Trigger on scaleChanged self.canvas.scaleChanged.connect(self.scaleChanged) # Trigger on renderStarting self.canvas.renderStarting.connect(self.renderStarting) # Create Map Tools actionFullExt = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/globe.svg'), "Mapa total", self) actionPan = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/pan.svg'), "Mover", self) actionZoomIn = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/zoom_in.svg'), "Aproximar", self) actionZoomOut = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/zoom_out.svg'), "Afastar", self) actionSelect = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/selection.svg'), 'Desenhar', self) actionFromLayer = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/layers.svg'), 'Obter de camada', self) actionFullExt.setCheckable(False) actionPan.setCheckable(True) actionZoomIn.setCheckable(True) actionZoomOut.setCheckable(True) actionSelect.setCheckable(True) actionFullExt.triggered.connect(self.fullext) actionPan.triggered.connect(self.pan) actionZoomIn.triggered.connect(self.zoomIn) actionZoomOut.triggered.connect(self.zoomOut) actionSelect.triggered.connect(self.select) actionFromLayer.triggered.connect(self.chooseLayer) # Add to created ToolBar self.toolBar.addAction(actionFullExt) self.toolBar.addSeparator() self.toolBar.addAction(actionPan) self.toolBar.addAction(actionZoomIn) self.toolBar.addAction(actionZoomOut) self.toolBar.addAction(actionSelect) self.toolBar.addAction(actionFromLayer) self.toolFullExtent = gui.QgsMapToolPan(self.canvas) self.toolFullExtent.setAction(actionFullExt) self.toolPan = gui.QgsMapToolPan(self.canvas) self.toolPan.setAction(actionPan) self.toolZoomIn = gui.QgsMapToolZoom(self.canvas, False) # false = in self.toolZoomIn.setAction(actionZoomIn) self.toolZoomOut = gui.QgsMapToolZoom(self.canvas, True) # true = out self.toolZoomOut.setAction(actionZoomOut) self.toolSelect = SelectionTool(self.canvas, self) self.resourcebox.setChecked(True) self.pan() lugin_path = utils.pluginDirectory('EditorMetadadosMarswInforbiomares') # Load Vector layerpath = os.path.join(plugin_path, "resourcesFolder/World.shp") llayer = core.QgsVectorLayer(layerpath, "WorldLayer", "ogr") # Set Layer Symbology props = { 'color_border': '0,0,0,125', 'style': 'no', 'style_border': 'solid' } #s = core.QgsFillSymbolV2.createSimple(props) s = core.QgsFillSymbol.createSimple(props) #llayer.setRendererV2(core.QgsSingleSymbolRendererV2(s)) llayer.setRenderer(core.QgsSingleSymbolRenderer(s)) # Set CRS - necessary to load Raster - it assumes this default CRS s = qcore.QSettings() oldValidation = str( s.value("/Projections/defaultBehaviour", "useGlobal")) s.setValue("/Projections/defaultBehaviour", "useGlobal") # Load Raster fileName = os.path.join(plugin_path, "resourcesFolder/GMRT.tif") fileInfo = qcore.QFileInfo(fileName) baseName = fileInfo.baseName() layer = core.QgsRasterLayer(fileName, baseName) layer.setCrs( core.QgsCoordinateReferenceSystem( 4326, core.QgsCoordinateReferenceSystem.EpsgCrsId)) s.setValue("/Projections/defaultBehaviour", oldValidation) # Set Raster ColorRamp # layer.setDrawingStyle("SingleBandPseudoColor") # deprecated remove in 2.1.0 please vmin = -5683.08 vmax = 2763.86 vrange = vmax - vmin vadd = vrange // 2 vint = vmin + vadd colDic = { 'brown': '#90330a', 'lightblue': '#d5f5f9', 'blue': '#2099d4' } valueList = [vmin, vint, vmax] lst = [core.QgsColorRampShader.ColorRampItem(valueList[0], qgui.QColor(colDic['blue'])), \ core.QgsColorRampShader.ColorRampItem(valueList[1], qgui.QColor(colDic['lightblue'])), \ core.QgsColorRampShader.ColorRampItem(valueList[2], qgui.QColor(colDic['brown']))] myRasterShader = core.QgsRasterShader() myColorRamp = core.QgsColorRampShader() myColorRamp.setColorRampItemList(lst) myColorRamp.setColorRampType(core.QgsColorRampShader.Interpolated) myRasterShader.setRasterShaderFunction(myColorRamp) myPseudoRenderer = core.QgsSingleBandPseudoColorRenderer( layer.dataProvider(), layer.type(), myRasterShader) layer.setRenderer(myPseudoRenderer) ## Add vector to map #core.QgsMapLayerRegistry.instance().addMapLayer(llayer, False) core.QgsProject.instance().addMapLayer(llayer, False) ## Add raster to map #core.QgsMapLayerRegistry.instance().addMapLayer(layer, False) core.QgsProject.instance().addMapLayer(layer, False) ## Save Max Extent self.maxExt = core.QgsRectangle(-180., -90., 180., 90.) # ---------------------------------- ## Set initial general extent to ZEE or, if one is selected, from the selected boundingbox if self.boundingbox.selectionModel().hasSelection() == False: ## Change button's title self.add_extent.setText(u"Adicionar") initialrect = core.QgsRectangle(-46.63064, 22.52146, 9.64473, 47.31826) else: ## Get selected bounding box coords and resource flag index = self.boundingbox.selectionModel().selectedRows()[0].row() row = self.boundingbox.model().matrix[index] minx = float(row[0].replace(',', '.')) miny = float(row[3].replace(',', '.')) maxx = float(row[1].replace(',', '.')) maxy = float(row[2].replace(',', '.')) if minx == 0. and miny == 0. and maxx == 0. and maxy == 0.: initialrect = core.QgsRectangle(-46.63064, 22.52146, 9.64473, 47.31826) else: ## Set fields with these values self.xMin.setValue(minx) self.xMax.setValue(maxx) self.yMin.setValue(miny) self.yMax.setValue(maxy) self.resourcebox.setChecked(bool(row[4])) ## Set the extent and add a bit of zoom out of the selected extent initialrect = core.QgsRectangle(minx - minx * 0.1, miny - miny * 0.1, maxx + maxx * 0.1, maxy + maxy * 0.1) ## Draw initial extent on the map self.toolSelect.drawRect(minx, miny, maxx, maxy) ## Change button's title self.add_extent.setText(u"Alterar") self.canvas.setExtent(initialrect) # ---------------------------------- ## Append layers to MapCanvas self.layers.append(llayer) self.layers.append(layer) #self.layers.append(gui.QgsMapCanvasLayer(llayer)) #self.layers.append(gui.QgsMapCanvasLayer(layer)) #self.canvas.setLayerSet(self.layers) self.canvas.setLayers([llayer, layer]) ## Set triggers to buttons self.add_extent.clicked.connect(self.add_new_extent) self.btn_close.clicked.connect(lambda: self.done(QDialog.Rejected)) self.finished.connect(self.cleanup) ## Disabled coord fields self.xMin.setEnabled(False) self.xMax.setEnabled(False) self.yMin.setEnabled(False) self.yMax.setEnabled(False)
progress.setInfo("Numero de linhas: " + str(rows)) progress.setInfo("Numero de colunas: " + str(cols)) for i in range(int(cols)): ringYtop = ringYtopOrigin ringYbottom = ringYbottomOrigin for j in range(int(rows)): points = [ QgsCore.QgsPoint(ringXleftOrigin, ringYtop), QgsCore.QgsPoint(ringXrightOrigin, ringYtop), QgsCore.QgsPoint(ringXrightOrigin, ringYbottom), QgsCore.QgsPoint(ringXleftOrigin, ringYbottom), QgsCore.QgsPoint(ringXleftOrigin, ringYtop) ] request = QgsCore.QgsFeatureRequest( QgsCore.QgsRectangle(ringXleftOrigin, ringYtop, ringXrightOrigin, ringYbottom)) for feature in lyrInput.getFeatures(request): square = QgsCore.QgsFeature() square.setGeometry(QgsCore.QgsGeometry.fromPolygon([points])) square.setAttributes([id]) perc = id / (cols * rows * 100) progress.setPercentage(perc) lyrIntermediate.dataProvider().addFeatures([square]) lyrIntermediate.updateExtents() id = id + 1 break ringYtop = ringYtop - gridHeight ringYbottom = ringYbottom - gridHeight ringXleftOrigin = ringXleftOrigin + gridWidth ringXrightOrigin = ringXrightOrigin + gridWidth
def intersects(self, xxyy): """ This should be made compatible with the regular RTree call... """ rect = qc.QgsRectangle(xxyy[0], xxyy[2], xxyy[1], xxyy[3]) results = self.qsi.intersects(rect) return results
def printAction(self): #export tmp imgs of qwebviews for imgFile,webview in {"tmpSV.png":self.view.SV,"tmpBE.png":self.view.BE}.items(): painter = QtGui.QPainter() img = QtGui.QImage(webview.size().width(), webview.size().height(), QtGui.QImage.Format_ARGB32) painter.begin(img) webview.page().mainFrame().render(painter) painter.end() img.save(os.path.join(self.dirPath,"tmp",imgFile)) # portion of code from: http://gis.stackexchange.com/questions/77848/programmatically-load-composer-from-template-and-generate-atlas-using-pyqgis # Load template myLayout = core.QgsLayout(core.QgsProject.instance()) myFile = os.path.join(os.path.dirname(__file__), 'res','go2SV_A4.qpt') myTemplateFile = open(myFile, 'rt') myTemplateContent = myTemplateFile.read() myTemplateFile.close() myDocument = QtXml.QDomDocument() myDocument.setContent(myTemplateContent) myLayout.loadFromTemplate(myDocument,core.QgsReadWriteContext()) #MAP mapFrame = sip.cast(myLayout.itemById('MAP'),core.QgsLayoutItemMap) mapFrameAspectRatio = mapFrame.extent().width()/mapFrame.extent().height() newMapFrameExtent = core.QgsRectangle() actualPosition = self.transformToCurrentSRS(core.QgsPointXY (float(self.actualPOV['lon']),float(self.actualPOV['lat']))) centerX = actualPosition.x() centerY = actualPosition.y() if float(self.actualPOV['heading']) > 360: head = float(self.actualPOV['heading'])-360 else: head = float(self.actualPOV['heading']) newMapFrameExtent.set(centerX - self.iface.mapCanvas().extent().height()*mapFrameAspectRatio/2,centerY - self.iface.mapCanvas().extent().height()/2,centerX + self.iface.mapCanvas().extent().height()*mapFrameAspectRatio/2,centerY + self.iface.mapCanvas().extent().height()/2) mapFrame.setExtent(newMapFrameExtent) mapFrame.setMapRotation(self.canvas.rotation()) mapFrame.redraw() #CURSOR mapFrameCursor = sip.cast(myLayout.itemById('CAMERA'),core.QgsLayoutItemPicture) mapFrameCursor.setPicturePath(os.path.join(os.path.dirname(__file__),'res', 'camera.svg')) mapFrameCursor.setItemRotation(head+self.canvas.rotation(), adjustPosition=True) #NORTH mapFrameNorth = sip.cast(myLayout.itemById('NORTH'),core.QgsLayoutItemPicture) mapFrameNorth.setPicturePath(os.path.join(os.path.dirname(__file__),'res', 'NorthArrow_01.svg')) mapFrameNorth.setPictureRotation(self.canvas.rotation()) #STREETVIEW AND GM PICS if self.view.SV.isHidden(): LargePic = os.path.join(os.path.dirname(__file__),'tmp', 'tmpBE.png') SmallPic = os.path.join(os.path.dirname(__file__),'tmp', 'tmpSV.png') else: LargePic = os.path.join(os.path.dirname(__file__),'tmp', 'tmpSV.png') SmallPic = os.path.join(os.path.dirname(__file__),'tmp', 'tmpBE.png') SVFrame = sip.cast(myLayout.itemById('LARGE'),core.QgsLayoutItemPicture) SVFrame.setPicturePath(LargePic) BEFrame = sip.cast(myLayout.itemById('SMALL'),core.QgsLayoutItemPicture) BEFrame.setPicturePath(SmallPic) #DESCRIPTION DescFrame = sip.cast(myLayout.itemById('DESC'),core.QgsLayoutItemLabel) info = self.snapshotOutput.getGeolocationInfo() DescFrame.setText("LAT: %s\nLON: %s\nHEAD: %s\nADDRESS:\n%s" % (info['lat'], info['lon'], head, info['address'])) workDir = core.QgsProject.instance().readPath("./") fileName, filter = QtWidgets.QFileDialog().getSaveFileName(None,"Save pdf", workDir, "*.pdf"); if fileName: if QtCore.QFileInfo(fileName).suffix() != "pdf": fileName += ".pdf" exporter = core.QgsLayoutExporter(myLayout) exporter.exportToPdf(fileName,core.QgsLayoutExporter.PdfExportSettings())
def addFeatures(self): def setGeorefImage(): ds = gdal.Open( pImgSel['filename'], GA_Update ) if gdal.GetLastErrorType() != 0: return { 'isOk': False, 'msg': gdal.GetLastErrorMsg() } xOrigin = yOrigin = None if isView: xOrigin = self.paramsImage['view']['extent'].xMinimum() yOrigin = self.paramsImage['view']['extent'].yMaximum() else: xOrigin = self.paramsImage['tiePoint'][0] yOrigin = self.paramsImage['tiePoint'][1] tiePointOrigin = ( xOrigin, yOrigin ) i = 0 xIni = tiePointOrigin[i] + pImgSel['tiePoint'][i] * self.paramsImage['res'][i] i = 1 yIni = tiePointOrigin[i] - pImgSel['tiePoint'][i] * self.paramsImage['res'][i] transform = ( xIni, self.paramsImage['res'][0], 0.0, yIni, 0.0, -1*self.paramsImage['res'][1] ) ds.SetGeoTransform( transform ) ds.SetProjection( self.paramsImage['wktProj'] ) band = ds.GetRasterBand( 1 ) band.SetNoDataValue( 0.0 ) ds = None return { 'isOk': True } def polygonizeSelectionImage(): ds_img = gdal.Open( pImgSel['filename'], GA_ReadOnly ) if gdal.GetLastErrorType() != 0: return { 'isOk': False, 'msg': gdal.GetLastErrorMsg() } band = ds_img.GetRasterBand( 1 ) # Sieve Band drv = gdal.GetDriverByName('MEM') ds_sieve = drv.Create( '', ds_img.RasterXSize, ds_img.RasterYSize,1, band.DataType ) ds_sieve.SetGeoTransform( ds_img.GetGeoTransform() ) ds_sieve.SetProjection( self.paramsImage['wktProj'] ) band_sieve = ds_sieve.GetRasterBand(1) p_threshold = self.paramsSieve['threshold'] p_connectedness = self.paramsSieve['connectedness'] gdal.SieveFilter( band, None, band_sieve, p_threshold, p_connectedness, [], callback=None ) ds_img = band = None if gdal.GetLastErrorType() != 0: return { 'isOk': False, 'msg': gdal.GetLastErrorMsg() } # Memory layer - Polygonize srs = osr.SpatialReference() srs.ImportFromWkt( self.paramsImage['wktProj'] ) drv_poly = ogr.GetDriverByName('MEMORY') ds_poly = drv_poly.CreateDataSource('memData') layer_poly = ds_poly.CreateLayer( 'memLayer', srs, ogr.wkbPolygon ) field = ogr.FieldDefn("dn", ogr.OFTInteger) layer_poly.CreateField( field ) idField = 0 gdal.Polygonize( band_sieve, None, layer_poly, idField, [], callback=None ) ds_sieve = band_sieve = None if gdal.GetLastErrorType() != 0: return { 'isOk': False, 'msg': gdal.GetLastErrorMsg() } # Get Geoms geoms = [] layer_poly.SetAttributeFilter("dn = 255") for feat in layer_poly: geoms.append( feat.GetGeometryRef().Clone() ) ds_poly = layer_poly = None return { 'isOk': True, 'geoms': geoms } def addAttribute(feat): self.idAdd += 1 sdatetime = datetime.datetime.now().strftime( "%Y-%m-%d %H:%M:%s") feat.setAttribute('image', self.paramsImage['filename'] ) feat.setAttribute('datetime', sdatetime ) feat.setAttribute('crs', self.paramsImage['desc_crs'] ) feat.setAttribute('id_add', self.idAdd ) def envelopGeoms(envFeats, geom): env = list( geom.GetEnvelope() ) # [ xmin, xmax, ymin, ymax ] if envFeats is None: return env for id in ( 0, 2 ): # Min if envFeats[id] > env[id]: envFeats[id] = env[id] for id in ( 1, 3 ): # Max if envFeats[id] < env[id]: envFeats[id] = env[id] return envFeats self.isKilled = False filename = self.paramsImage['filename'] isView = QtCore.Qt.Checked == self.paramsImage['view']['checkState'] if isView: filename = self.paramsImage['view']['filename'] msg = "Creating features in QGIS..." self.messageStatus.emit( { 'type': QgsGui.QgsMessageBar.INFO, 'msg': msg } ) pImgSel = self.getDataServer( 'create_selection_image', filename ) if not pImgSel['isOk']: self.finishedWarning( pImgSel['msg'] ) return if self.isKilled: self.finishedWarning( "Processing is stopped by user" ) os.remove( pImgSel['filename'] ) return vreturn = setGeorefImage() if not vreturn['isOk']: self.finishedWarning( vreturn['msg'] ) os.remove( pImgSel['filename'] ) return if self.isKilled: self.finishedWarning( "Processing is stopped by user" ) os.remove( pImgSel['filename'] ) return vreturn = polygonizeSelectionImage() os.remove( pImgSel['filename'] ) if not vreturn['isOk']: self.finishedWarning( vreturn['msg'] ) return if self.isKilled: self.finishedWarning( "Processing is stopped by user" ) return totalFeats = len( vreturn['geoms'] ) if totalFeats == 0: msg = "Not found features in selections ('%s')" % self.paramsImage['filename'] self.finishedWarning( msg ) return srsLayerPolygon = osr.SpatialReference() srsLayerPolygon.ImportFromWkt( self.layerPolygon.crs().toWkt() ) feat = QgsCore.QgsFeature( self.layerPolygon.pendingFields() ) addAttribute( feat ) isIniEditable = self.layerPolygon.isEditable() if not isIniEditable: self.layerPolygon.startEditing() p_iter = self.paramSmooth['iter'] p_offset = self.paramSmooth['offset'] envFeats = None # [ xmin, xmax, ymin, ymax ] for geom in vreturn['geoms']: geom.TransformTo( srsLayerPolygon ) envFeats = envelopGeoms( envFeats, geom ) geomLayer = QgsCore.QgsGeometry.fromWkt( geom.ExportToWkt() ).smooth( p_iter, p_offset ) geom.Destroy() feat.setGeometry( geomLayer ) self.layerPolygon.addFeature( feat ) del geomLayer feat = None self.layerPolygon.commitChanges() if isIniEditable: self.layerPolygon.startEditing() self.layerPolygon.updateExtents() msg = "Added %d features in '%s'" % ( totalFeats, self.layerPolygon.name() ) self.messageStatus.emit( { 'type': QgsGui.QgsMessageBar.INFO, 'msg': msg } ) bboxFeats = QgsCore.QgsRectangle( envFeats[0], envFeats[2], envFeats[1], envFeats[3] ) self.finished.emit( { 'isOk': True, 'bboxFeats': bboxFeats } )
def getCursorRect(self): p = gui.QgsMapTool(iface.mapCanvas()).toMapCoordinates( iface.mapCanvas().mouseLastXY()) w = iface.mapCanvas().mapUnitsPerPixel() * 10 return core.QgsRectangle(p.x() - w, p.y() - w, p.x() + w, p.y() + w)
def zoomToFeatureFunc(self): featureBox = self.selectedFeature.geometry().boundingBox() p1 = self.transformToCurrentSRS(core.QgsPointXY(featureBox.xMinimum(),featureBox.yMinimum()),self.selectedLayer.crs()) p2 = self.transformToCurrentSRS(core.QgsPointXY(featureBox.xMaximum(),featureBox.yMaximum()),self.selectedLayer.crs()) self.mapCanvas.setExtent(core.QgsRectangle(p1.x(),p1.y(),p2.x(),p2.y())) self.mapCanvas.refresh()
def zoomToLayerFunc(self): layerBox = self.selectedLayer.extent() p1 = self.transformToCurrentSRS(core.QgsPointXY(layerBox.xMinimum(),layerBox.yMinimum()),self.selectedLayer.crs()) p2 = self.transformToCurrentSRS(core.QgsPointXY(layerBox.xMaximum(),layerBox.yMaximum()),self.selectedLayer.crs()) self.mapCanvas.setExtent(core.QgsRectangle(p1.x(),p1.y(),p2.x(),p2.y())) self.mapCanvas.refresh()