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