本文整理汇总了Python中qgis.gui.QgsMapCanvas.refresh方法的典型用法代码示例。如果您正苦于以下问题:Python QgsMapCanvas.refresh方法的具体用法?Python QgsMapCanvas.refresh怎么用?Python QgsMapCanvas.refresh使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类qgis.gui.QgsMapCanvas
的用法示例。
在下文中一共展示了QgsMapCanvas.refresh方法的11个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: Dialog
# 需要导入模块: from qgis.gui import QgsMapCanvas [as 别名]
# 或者: from qgis.gui.QgsMapCanvas import refresh [as 别名]
class Dialog(QtGui.QWidget, Ui_DialogBase):
def __init__(self):
QtGui.QWidget.__init__(self)
self.setupUi(self)
self.widget = QgsMapCanvas()
self.show()
def on_pushButton_clicked(self):
"""Wow - an autoconnected slot!"""
print 'Click!'
myPath = os.path.join(
os.path.dirname(__file__),
'landsat.tif')
print myPath
layer = QgsRasterLayer(myPath, 'A Layer')
QgsMapLayerRegistry.instance().addMapLayers([layer])
layer.setGrayBandName(layer.bandName(1))
layer.setDrawingStyle(QgsRasterLayer.SingleBandPseudoColor)
layer.setColorShadingAlgorithm(QgsRasterLayer.PseudoColorShader)
layer.saveDefaultStyle()
self.widget.zoomToFullExtent()
print self.widget.extent().toString()
print layer.extent().toString()
self.widget.refresh()
示例2: testDeferredUpdate
# 需要导入模块: from qgis.gui import QgsMapCanvas [as 别名]
# 或者: from qgis.gui.QgsMapCanvas import refresh [as 别名]
def testDeferredUpdate(self):
""" test that map canvas doesn't auto refresh on deferred layer update """
canvas = QgsMapCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem(4326))
canvas.setFrameStyle(0)
canvas.resize(600, 400)
self.assertEqual(canvas.width(), 600)
self.assertEqual(canvas.height(), 400)
layer = QgsVectorLayer("Polygon?crs=epsg:4326&field=fldtxt:string",
"layer", "memory")
canvas.setLayers([layer])
canvas.setExtent(QgsRectangle(10, 30, 20, 35))
canvas.show()
# need to wait until first redraw can occur (note that we first need to wait till drawing starts!)
while not canvas.isDrawing():
app.processEvents()
while canvas.isDrawing():
app.processEvents()
self.assertTrue(self.canvasImageCheck('empty_canvas', 'empty_canvas', canvas))
# add polygon to layer
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(layer.dataProvider().addFeatures([f]))
# deferred update - so expect that canvas will not been refreshed
layer.triggerRepaint(True)
timeout = time.time() + 0.1
while time.time() < timeout:
# messy, but only way to check that canvas redraw doesn't occur
self.assertFalse(canvas.isDrawing())
# canvas should still be empty
self.assertTrue(self.canvasImageCheck('empty_canvas', 'empty_canvas', canvas))
# refresh canvas
canvas.refresh()
while not canvas.isDrawing():
app.processEvents()
while canvas.isDrawing():
app.processEvents()
# now we expect the canvas check to fail (since they'll be a new polygon rendered over it)
self.assertFalse(self.canvasImageCheck('empty_canvas', 'empty_canvas', canvas))
示例3: MirrorMap
# 需要导入模块: from qgis.gui import QgsMapCanvas [as 别名]
# 或者: from qgis.gui.QgsMapCanvas import refresh [as 别名]
class MirrorMap(QWidget):
def __init__(self, parent, iface):
QWidget.__init__(self, parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.iface = iface
self.layerId2canvasLayer = {}
self.canvasLayers = []
self.setupUi()
def closeEvent(self, event):
# self.scaleFactor.valueChanged.disconnect(self.onExtentsChanged)
QObject.disconnect(self.iface.mapCanvas(), SIGNAL("extentsChanged()"), self.onExtentsChanged)
QObject.disconnect(self.iface.mapCanvas().mapRenderer(), SIGNAL("destinationCrsChanged()"), self.onCrsChanged)
QObject.disconnect(self.iface.mapCanvas().mapRenderer(), SIGNAL("mapUnitsChanged()"), self.onCrsChanged)
QObject.disconnect(self.iface.mapCanvas().mapRenderer(), SIGNAL("hasCrsTransformEnabled(bool)"), self.onCrsTransformEnabled)
QObject.disconnect(QgsMapLayerRegistry.instance(), SIGNAL("layerWillBeRemoved(QString)"), self.delLayer)
QObject.disconnect(self.iface, SIGNAL("currentLayerChanged(QgsMapLayer *)"), self.refreshLayerButtons)
self.emit(SIGNAL("closed(PyQt_PyObject)"), self)
return QWidget.closeEvent(self, event)
def setupUi(self):
self.setObjectName("dockablemirrormap_mirrormap")
gridLayout = QGridLayout(self)
gridLayout.setContentsMargins(0, 0, gridLayout.verticalSpacing(), gridLayout.verticalSpacing())
self.canvas = QgsMapCanvas(self)
self.canvas.setCanvasColor(QColor(255, 255, 255))
settings = QSettings()
self.canvas.enableAntiAliasing(settings.value("/qgis/enable_anti_aliasing", False, type=bool))
self.canvas.useImageToRender(settings.value("/qgis/use_qimage_to_render", False, type=bool))
self.canvas.setWheelAction(3)
gridLayout.addWidget(self.canvas, 0, 0, 1, 5)
QObject.connect(self.iface.mapCanvas(), SIGNAL("extentsChanged()"), self.onExtentsChanged)
QObject.connect(self.iface.mapCanvas().mapRenderer(), SIGNAL("destinationCrsChanged()"), self.onCrsChanged)
QObject.connect(self.iface.mapCanvas().mapRenderer(), SIGNAL("mapUnitsChanged()"), self.onCrsChanged)
QObject.connect(self.iface.mapCanvas().mapRenderer(), SIGNAL("hasCrsTransformEnabled(bool)"), self.onCrsTransformEnabled)
QObject.connect(QgsMapLayerRegistry.instance(), SIGNAL("layerWillBeRemoved(QString)"), self.delLayer)
self.onExtentsChanged()
self.onCrsChanged()
self.onCrsTransformEnabled(self.iface.mapCanvas().hasCrsTransformEnabled())
def toggleRender(self, enabled):
self.canvas.setRenderFlag(enabled)
self.canvas.refresh()
self.canvas.repaint()
def onExtentsChanged(self):
try :
prevFlag = self.canvas.renderFlag()
self.canvas.setRenderFlag(False)
self.canvas.setExtent(self.iface.mapCanvas().extent())
# self.canvas.zoomByFactor( self.scaleFactor.value() )
self.canvas.setRenderFlag(prevFlag)
self.canvas.repaint()
self.canvas.refresh()
except Exception:
pass
def mirror_extent_changed(self):
logger.debug(self.canvas.extent())
logger.debug(self.iface.mapCanvas().extent())
if self.canvas.extent() != self.iface.mapCanvas().extent():
self.emit(SIGNAL("extentChanged( QgsRectangle )"), self.canvas.extent())
def onCrsChanged(self):
try:
prevFlag = self.canvas.renderFlag()
self.canvas.setRenderFlag(False)
renderer = self.iface.mapCanvas().mapRenderer()
self._setRendererCrs(self.canvas.mapRenderer(), self._rendererCrs(renderer))
self.canvas.mapRenderer().setMapUnits(renderer.mapUnits())
self.canvas.setRenderFlag(prevFlag)
self.canvas.repaint()
self.canvas.refresh()
except Exception:
pass
def onCrsTransformEnabled(self, enabled):
try:
prevFlag = self.canvas.renderFlag()
self.canvas.setRenderFlag(False)
self.canvas.mapRenderer().setProjectionsEnabled(enabled)
self.canvas.setRenderFlag(prevFlag)
self.canvas.repaint()
self.canvas.refresh()
except Exception:
#.........这里部分代码省略.........
示例4: testMapTheme
# 需要导入模块: from qgis.gui import QgsMapCanvas [as 别名]
# 或者: from qgis.gui.QgsMapCanvas import refresh [as 别名]
def testMapTheme(self):
canvas = QgsMapCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem(4326))
canvas.setFrameStyle(0)
canvas.resize(600, 400)
self.assertEqual(canvas.width(), 600)
self.assertEqual(canvas.height(), 400)
layer = QgsVectorLayer("Polygon?crs=epsg:4326&field=fldtxt:string",
"layer", "memory")
# add a polygon to layer
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(layer.dataProvider().addFeatures([f]))
# create a style
sym1 = QgsFillSymbol.createSimple({'color': '#ffb200'})
renderer = QgsSingleSymbolRenderer(sym1)
layer.setRenderer(renderer)
canvas.setLayers([layer])
canvas.setExtent(QgsRectangle(10, 30, 20, 35))
canvas.show()
# need to wait until first redraw can occur (note that we first need to wait till drawing starts!)
while not canvas.isDrawing():
app.processEvents()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# add some styles
layer.styleManager().addStyleFromLayer('style1')
sym2 = QgsFillSymbol.createSimple({'color': '#00b2ff'})
renderer2 = QgsSingleSymbolRenderer(sym2)
layer.setRenderer(renderer2)
layer.styleManager().addStyleFromLayer('style2')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme2', 'theme2', canvas))
layer.styleManager().setCurrentStyle('style1')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# OK, so all good with setting/rendering map styles
# try setting canvas to a particular theme
# make some themes...
theme1 = QgsMapThemeCollection.MapThemeRecord()
record1 = QgsMapThemeCollection.MapThemeLayerRecord(layer)
record1.currentStyle = 'style1'
record1.usingCurrentStyle = True
theme1.setLayerRecords([record1])
theme2 = QgsMapThemeCollection.MapThemeRecord()
record2 = QgsMapThemeCollection.MapThemeLayerRecord(layer)
record2.currentStyle = 'style2'
record2.usingCurrentStyle = True
theme2.setLayerRecords([record2])
QgsProject.instance().mapThemeCollection().insert('theme1', theme1)
QgsProject.instance().mapThemeCollection().insert('theme2', theme2)
canvas.setTheme('theme2')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme2', 'theme2', canvas))
canvas.setTheme('theme1')
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# add another layer
layer2 = QgsVectorLayer("Polygon?crs=epsg:4326&field=fldtxt:string",
"layer2", "memory")
f = QgsFeature()
f.setGeometry(QgsGeometry.fromRect(QgsRectangle(5, 25, 25, 45)))
self.assertTrue(layer2.dataProvider().addFeatures([f]))
# create a style
sym1 = QgsFillSymbol.createSimple({'color': '#b2ff00'})
renderer = QgsSingleSymbolRenderer(sym1)
layer2.setRenderer(renderer)
# rerender canvas - should NOT show new layer
canvas.refresh()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# test again - this time refresh all layers
canvas.refreshAllLayers()
canvas.waitWhileRendering()
self.assertTrue(self.canvasImageCheck('theme1', 'theme1', canvas))
# add layer 2 to theme1
record3 = QgsMapThemeCollection.MapThemeLayerRecord(layer2)
theme1.setLayerRecords([record3])
QgsProject.instance().mapThemeCollection().update('theme1', theme1)
#.........这里部分代码省略.........
示例5: ConflictDialog
# 需要导入模块: from qgis.gui import QgsMapCanvas [as 别名]
# 或者: from qgis.gui.QgsMapCanvas import refresh [as 别名]
#.........这里部分代码省略.........
self.updateSolveButton()
self.showGeoms()
def treeItemClicked(self):
item = self.conflictsTree.selectedItems()[0]
if self.lastSelectedItem == item:
return
if isinstance(item, ConflictItem):
self.lastSelectedItem = item
self.currentPath = item.conflict.path
self.updateCurrentPath()
self.solveLocalButton.setEnabled(True)
self.solveRemoteButton.setEnabled(True)
self.solveButton.setEnabled(False)
def updateCurrentPath(self):
self.solveButton.setEnabled(False)
self.solveLocalButton.setEnabled(False)
self.solveRemoteButton.setEnabled(False)
self.cleanCanvas()
self.showFeatureAttributes()
self.createLayers()
self.showGeoms()
self.zoomToFullExtent()
def zoomToFullExtent(self):
layers = [lay.extent() for lay in self.mapCanvas.layers() if lay.type() == lay.VectorLayer]
if layers:
ext = layers[0]
for layer in layers[1:]:
ext.combineExtentWith(layer)
self.mapCanvas.setExtent(ext)
self.mapCanvas.refresh()
def cleanCanvas(self):
self.mapCanvas.setLayerSet([])
layers = [self.oursLayer, self.theirsLayer]
for layer in layers:
if layer is not None:
QgsMapLayerRegistry.instance().removeMapLayer(layer.id())
self.oursLayer = None
self.theirsLayer = None
def solveAllRemote(self):
ret = QMessageBox.warning(self, "Solve conflict",
"Are you sure you want to solve all conflicts using the 'To merge' version?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes);
if ret == QMessageBox.Yes:
self.solved = True
self.resolvedConflicts = {c.path:self.REMOTE for c in self.conflicts}
self.close()
def solveAllLocal(self):
ret = QMessageBox.warning(self, "Solve conflict",
"Are you sure you want to solve all conflict using the 'Local' version?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes);
if ret == QMessageBox.Yes:
self.solved = True
self.resolvedConflicts = {c.path:self.LOCAL for c in self.conflicts}
self.close()
def _afterSolve(self, remove = True):
示例6: DiviPluginHistoryDialog
# 需要导入模块: from qgis.gui import QgsMapCanvas [as 别名]
# 或者: from qgis.gui.QgsMapCanvas import refresh [as 别名]
class DiviPluginHistoryDialog(QDialog, FORM_CLASS):
def __init__(self, plugin, parent=None):
"""Constructor."""
super(DiviPluginHistoryDialog, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.plugin = plugin
#self.iface = plugin.iface
self.setupUi(self)
self.initGui()
def initGui(self):
#Models
self.tblChanges.setModel( ChangeModel() )
proxyChanges = HistoryProxyModel()
proxyChanges.setSourceModel( HistoryModel() )
self.tblHistory.setModel( proxyChanges )
#Signals
self.plugin.tvIdentificationResult.model().sourceModel().on_history.connect( self.historyChanged )
self.tblHistory.selectionModel().currentChanged.connect( self.currentHistoryChanged )
#Widgets
settings = QSettings()
self.mapCanvas = QgsMapCanvas(self.vSplitter)
self.mapCanvas.setDestinationCrs( QgsCoordinateReferenceSystem('EPSG:4326') )
zoomFactor = settings.value( "/qgis/zoom_factor", 2.0, type=float )
action = settings.value( "/qgis/wheel_action", 0, type=int)
self.mapCanvas.setWheelFactor( zoomFactor )
self.mapCanvas.enableAntiAliasing( settings.value( "/qgis/enable_anti_aliasing", False, type=bool ))
#self.mapCanvas.useImageToRender( settings.value( "/qgis/use_qimage_to_render", False, type=bool ))
self.toolPan = QgsMapToolPan( self.mapCanvas )
self.mapCanvas.setMapTool( self.toolPan )
#Canvas items
self.new_geometry = QgsRubberBand(self.mapCanvas)
self.new_geometry.setWidth(2)
self.new_geometry.setIcon( QgsRubberBand.ICON_CIRCLE )
g = QColor(0, 128, 0, 100)
self.new_geometry.setColor( g )
self.old_geometry = QgsRubberBand(self.mapCanvas)
self.old_geometry.setWidth(2)
self.old_geometry.setIcon( QgsRubberBand.ICON_CIRCLE )
r = QColor(255, 0, 0, 100)
self.old_geometry.setColor( r )
def show(self, data=[]):
model = self.tblHistory.model().sourceModel()
model.addItems(data)
if data:
self.tblHistory.selectionModel().setCurrentIndex( model.index(0,0), QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows )
super(DiviPluginHistoryDialog, self).show()
def historyChanged(self):
""" Reaload data if window is visible """
if self.isVisible():
self.plugin.showHistoryDialog()
def currentHistoryChanged(self, current, previous):
self.new_geometry.reset()
self.old_geometry.reset()
self.tblChanges.model().removeRows()
if not current.isValid():
return
item = current.data(Qt.UserRole)
if item is None:
data = {}
else:
data = current.data(Qt.UserRole).getDetails()
with SetLocale_CtxDec():
extent = None
if data.get('new_geometry'):
wkt = CreateGeometryFromJson( json.dumps(data['new_geometry']) ).ExportToWkt()
geom = QgsGeometry.fromWkt( wkt )
l = QgsVectorLayer('Point?crs=epsg:4326', 'asd', 'memory')
self.new_geometry.setToGeometry( geom, l )
extent = QgsRectangle(geom.boundingBox())
if data.get('old_geometry'):
wkt = CreateGeometryFromJson( json.dumps(data['old_geometry']) ).ExportToWkt()
geom = QgsGeometry.fromWkt( wkt )
l = QgsVectorLayer('Point?crs=epsg:4326', 'asd', 'memory')
self.old_geometry.setToGeometry( geom, l )
if extent is None:
extent = QgsRectangle(geom.boundingBox())
else:
extent.combineExtentWith( geom.boundingBox() )
if extent is not None:
extent.grow(0.01)
self.mapCanvas.setExtent( extent )
self.mapCanvas.refresh()
if data.get('what_attributes', []):
self.tblChanges.model().insertRows( 0, data.get('what_attributes', []) )
示例7: run
# 需要导入模块: from qgis.gui import QgsMapCanvas [as 别名]
# 或者: from qgis.gui.QgsMapCanvas import refresh [as 别名]
#.........这里部分代码省略.........
<aas:Method>'''
text+=access_mode
text+='''</aas:Method>
<aas:Interval>'''
text+=str(interval)
text+='''</aas:Interval>
</aas:AccessibilitySettings>
<aas:LocationPoint>
<aas:Position>
<gml:Point xmlns:gml="http://www.opengis.net/gml" srsName="EPSG:4326">
<gml:pos>'''
text += start_point
text +='''</gml:pos>
</gml:Point>
</aas:Position>
</aas:LocationPoint>
</aas:Accessibility>
<aas:AccessibilityGeometryRequest>
<aas:PolygonPreference>Detailed</aas:PolygonPreference>
</aas:AccessibilityGeometryRequest>
</aas:DetermineAccessibilityRequest>
</aas:Request>
</aas:AAS>
'''
req = urllib2.Request(url=url, data=text, headers={'Content-Type': 'application/xml'})
response_poly=urllib2.urlopen(req).read()
newstr = response_poly.replace("\n", "")
response_poly = newstr.replace(" ", "")
xml_poly = ElementTree.fromstring(response_poly)
#first we need to make sure, that OTF projection is enabled
qgis.utils.iface.mapCanvas().mapRenderer().setProjectionsEnabled(True) # Enable on the fly reprojections
#come to the layer
layer = QgsVectorLayer('Polygon?crs=EPSG:4326', 'Accessibility', "memory")
pr = layer.dataProvider()
pr.addAttributes([QgsField("attribution", QVariant.String)])
pr.addAttributes([QgsField("time", QVariant.Int)])
pr.addAttributes([QgsField("area", QVariant.Double)])
layer.updateFields()
for poly in reversed(range(0,len(xml_poly[1][0][1]))):
fet = QgsFeature()
seg=[]
for i in range(0,len(xml_poly[1][0][1][poly][0][0][0][0])):
#print response_poly
#print float(xml_poly[1][0][1][poly][0].attrib['area'])
seg.append(QgsPoint(float(str.split(xml_poly[1][0][1][poly][0][0][0][0][i].text)[0]),float(str.split(xml_poly[1][0][1][poly][0][0][0][0][i].text)[1])))
fet.setGeometry(QgsGeometry.fromPolygon([seg]))
geom = fet.geometry()
fet.setAttributes(["route provided by openrouteservice.org", float(xml_poly[1][0][1][poly].attrib['time'])/60, float(xml_poly[1][0][1][poly][0].attrib['area'])])
pr.addFeatures([fet])
layer.updateExtents() #update it
features = layer.getFeatures()
QgsMapLayerRegistry.instance().addMapLayer(layer)
# now add a field fo the area:
#expression = QgsExpression("$area")
# This allows field lookup
#expression.prepare(layer.pendingFields())
#layer.startEditing()
#for feature in layer.getFeatures():
#value = expression.evaluate(feature)
#feature["area"] = value
#layer.updateFeature(feature)
#layer.commitChanges()
#as we have the layer we need to adjust the representation to make it a categorized layer.
import random
r = lambda: random.randint(0,255)
color = '#%02X%02X%02X' % (r(),r(),r())
list = {} # empty
categories = []
for i in reversed(range(0,len(xml_poly[1][0][1]))):
r = lambda: random.randint(0,255) #create random color
list.update({str(int(float(xml_poly[1][0][1][i].attrib['time'])/60)): ('#%02x%02x%02x' % (r(),r(),r()), str(int(float(xml_poly[1][0][1][i].attrib['time'])/60)))})
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
symbol.setColor(QColor('#%02x%02x%02x' % (r(),r(),r())))
category = QgsRendererCategoryV2(str(int(float(xml_poly[1][0][1][i].attrib['time'])/60)), symbol, str(int(float(xml_poly[1][0][1][i].attrib['time'])/60)))
categories.append(category)
expression = 'time' # field name
renderer = QgsCategorizedSymbolRendererV2(expression, categories)
layer.setRendererV2(renderer)
layer.setLayerTransparency(50)
from qgis.gui import QgsMapCanvas
canvas = QgsMapCanvas()
canvas.refresh()
# Do something useful here - delete the line containing pass and
# substitute with your code.
if int(numberOfHits_via) >1:
print "routing finished between " + start_address + "(" + start_point + ") and " + stop_address + "(" + stop_point + ") via " + via_address + "(" + via_point + ")"
else:
print "routing finished between " + start_address + "(" + start_point + ") and " + stop_address + "(" + stop_point + ")"
if int(numberOfHits_start) >1:
print "multiple locations for start location"
if int(numberOfHits_stop) >1:
print "multiple locations for stop location"
if int(numberOfHits_via) >1:
print "multiple locations for via location"
end = time.clock()
#print "time needed to calculate: " + str(end - start) + "Distance: " + str(float(xml_route[1][0][0][1].attrib['value'])) + " from " + start_address + " to " + stop_address
pass
示例8: globalQgis
# 需要导入模块: from qgis.gui import QgsMapCanvas [as 别名]
# 或者: from qgis.gui.QgsMapCanvas import refresh [as 别名]
QgsCoordinateReferenceSystem,
QgsPoint,
QgsRectangle,
QgsFeature)
from qgis.gui import QgsMapCanvas, QgsMapCanvasLayer
from qgisinterface import QgisInterface
from utilities_test import globalQgis
from bucketfill import BucketFill
# Get QGis app handle
QGISAPP = globalQgis()
# Set form to test against
PARENT = QtGui.QWidget()
CANVAS = QgsMapCanvas(PARENT)
CANVAS.resize(QtCore.QSize(400, 400))
CANVAS.refresh()
# QgisInterface is a stub implementation of the QGIS plugin interface
IFACE = QgisInterface(CANVAS)
GUI_CONTEXT_FLAG = False
GEOCRS = 4326 # constant for EPSG:GEOCRS Geographic CRS id
GOOGLECRS = 900913 # constant for EPSG:GOOGLECRS Google Mercator id
TEST_BOX = (106.773659284, -6.13591899755, 106.776649984, -6.1329282975)
def loadLayers():
"""
Helper function to load layers into the dialog.
"""
# First unload any layers that may already be loaded
示例9: FeatureOfInterestDefinerConfigurationWidget
# 需要导入模块: from qgis.gui import QgsMapCanvas [as 别名]
# 或者: from qgis.gui.QgsMapCanvas import refresh [as 别名]
#.........这里部分代码省略.........
QtCore.SIGNAL('clicked(bool)'),
self.close)
self.mainLayout.addWidget(self.crsGroupBox)
self.mainLayout.addWidget(self.bbGroupBox)
self.mainLayout.addWidget(self.asTxtGroupBox)
self.mainLayout.addWidget(self.MapGroupBox)
self.mainLayout.addWidget(self.finishGroupBox)
# set signals
self.connect(self.crsChooseButton, QtCore.SIGNAL('clicked(bool)'), self.getSRS)
self.connect(self.bbToMapButton, QtCore.SIGNAL('clicked(bool)'), self.bbToMapBB)
self.connect(self.asTxtToMapButton, QtCore.SIGNAL('clicked(bool)'), self.bbToMapTxt)
self.connect(actionAddLayer, QtCore.SIGNAL("activated()"), self.addLayer)
self.connect(actionZoomIn, QtCore.SIGNAL("activated()"), self.zoomIn)
self.connect(actionZoomOut, QtCore.SIGNAL("activated()"), self.zoomOut)
self.connect(actionPan, QtCore.SIGNAL("activated()"), self.pan)
self.connect(actionIdentify, QtCore.SIGNAL("triggered()"), self.identifyFeature)
#load a backdrop layer
self.mapCanvasLayers = []
fname = self.path_bkgimg + '/bluemarblemerged.img'
fileInfo = QtCore.QFileInfo(fname)
baseName = fileInfo.baseName()
self.bmLayer = QgsRasterLayer(fname, baseName)
QgsMapLayerRegistry.instance().addMapLayer(self.bmLayer)
self.cl = QgsMapCanvasLayer(self.bmLayer)
self.mapCanvasLayers.append(self.cl)
# Set extent to the extent of our layer
self.canvas.setExtent(self.bmLayer.extent())
self.canvas.enableAntiAliasing(True)
self.canvas.freeze(False)
self.canvas.setLayerSet(self.mapCanvasLayers)
self.canvas.refresh()
#now, add a container layer for our text based/ digitised or selected geoms
self.addMemoryLayer()
#self.update()
def center(self):
"""TO DO - add docstring"""
screen = QtGui.QDesktopWidget().screenGeometry()
size = self.geometry()
self.move((screen.width() - size.width()) / 2,
(screen.height() - size.height()) / 2)
def getSRS(self):
# retruns the description and proj4 string of the chosen SRS, from the SRSDialog
srsdlg = SRSChooserDialog("Choose SRS")
if srsdlg.exec_():
self.crsTextAsProj4.setText(srsdlg.getProjection())
def bbToMapBB(self):
self.bbToMap(fullWkt=False)
def bbToMapTxt(self):
self.bbToMap(fullWkt=True)
def bbToMap(self, fullWkt=False):
'''takes bounding box coords and puts them on the map'''
#if self.foi_type == "AreaOfInterestDefiner":
if not fullWkt:
ix = self.bbMinXText.text()
iy = self.bbMinYText.text()
ax = self.bbMaxXText.text()
示例10: GeometryDiffViewerDialog
# 需要导入模块: from qgis.gui import QgsMapCanvas [as 别名]
# 或者: from qgis.gui.QgsMapCanvas import refresh [as 别名]
#.........这里部分代码省略.........
self.crs = crs
self.initGui()
def initGui(self):
layout = QVBoxLayout()
self.tab = QTabWidget()
self.table = QTableView()
self.setLayout(layout)
self.canvas = QgsMapCanvas()
self.canvas.setCanvasColor(Qt.white)
settings = QSettings()
self.canvas.enableAntiAliasing(settings.value("/qgis/enable_anti_aliasing", False, type = bool))
self.canvas.useImageToRender(settings.value("/qgis/use_qimage_to_render", False, type = bool))
self.canvas.mapSettings().setDestinationCrs(self.crs)
action = settings.value("/qgis/wheel_action", 0, type = float)
zoomFactor = settings.value("/qgis/zoom_factor", 2, type = float)
self.canvas.setWheelAction(QgsMapCanvas.WheelAction(action), zoomFactor)
self.panTool = QgsMapToolPan(self.canvas)
self.canvas.setMapTool(self.panTool)
execute(self.createLayers)
model = GeomDiffTableModel(self.data)
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.table.resizeRowsToContents()
self.tab.addTab(self.canvas, "Map view")
self.tab.addTab(self.table, "Table view")
layout.addWidget(self.tab)
self.resize(600, 500)
self.setWindowTitle("Geometry comparison")
def createLayers(self):
textGeometries = []
for geom in self.geoms:
text = geom.exportToWkt()
valid = " -1234567890.,"
text = "".join([c for c in text if c in valid])
textGeometries.append(text.split(","))
lines = difflib.Differ().compare(textGeometries[0], textGeometries[1])
self.data = []
for line in lines:
if line.startswith("+"):
self.data.append([None, line[2:]])
if line.startswith("-"):
self.data.append([line[2:], None])
if line.startswith(" "):
self.data.append([line[2:], line[2:]])
types = [("LineString", lineBeforeStyle, lineAfterStyle),
("Polygon", polygonBeforeStyle, polygonAfterStyle)]
layers = []
extent = self.geoms[0].boundingBox()
for i, geom in enumerate(self.geoms):
geomtype = types[int(geom.type() - 1)][0]
style = types[int(geom.type() - 1)][i + 1]
layer = loadLayerNoCrsDialog(geomtype + "?crs=" + self.crs.authid(), "layer", "memory")
pr = layer.dataProvider()
feat = QgsFeature()
feat.setGeometry(geom)
pr.addFeatures([feat])
layer.loadNamedStyle(style)
layer.updateExtents()
layers.append(layer)
QgsMapLayerRegistry.instance().addMapLayer(layer, False)
extent.combineExtentWith(geom.boundingBox())
layer = loadLayerNoCrsDialog("Point?crs=%s&field=changetype:string" % self.crs.authid(), "points", "memory")
pr = layer.dataProvider()
feats = []
for coords in self.data:
coord = coords[0] or coords[1]
feat = QgsFeature()
x, y = coord.strip().split(" ")
x, y = (float(x), float(y))
pt = QgsGeometry.fromPoint(QgsPoint(x, y))
feat.setGeometry(pt)
if coords[0] is None:
changetype = "A"
elif coords[1] is None:
changetype = "R"
else:
changetype = "U"
feat.setAttributes([changetype])
feats.append(feat)
pr.addFeatures(feats)
layer.loadNamedStyle(pointsStyle)
QgsMapLayerRegistry.instance().addMapLayer(layer, False)
layers.append(layer)
self.mapLayers = [QgsMapCanvasLayer(lay) for lay in layers]
self.canvas.setLayerSet(self.mapLayers)
self.canvas.setExtent(extent)
self.canvas.refresh()
def reject(self):
QDialog.reject(self)
示例11: WidgetResult
# 需要导入模块: from qgis.gui import QgsMapCanvas [as 别名]
# 或者: from qgis.gui.QgsMapCanvas import refresh [as 别名]
#.........这里部分代码省略.........
self.zoomToLayer(self.map_layers[self.LAYER_NAMES.index(cur_layer_name)])
@logUICall
@pyqtSlot()
def mapEditTheme(self):
""" event handler for btn_edit - identify item on map """
cur_layer_name = self.ui.cb_layer_selector.currentText()
if cur_layer_name.isEmpty():
return
try:
cur_layer_idx = self.LAYER_NAMES.index(cur_layer_name)
# build layer render property Dialog for selected layer
dlg_render = QDialog()
dlg_render.setWindowTitle(get_ui_string('widget.result.renderer.settings'))
dlg_render.setModal(True)
dlg_render.setFixedSize(530, 370)
dlg_render.renderer = QgsRendererV2PropertiesDialog(self.map_layers[cur_layer_idx], self.style, True)
dlg_render.renderer.setParent(dlg_render)
dlg_render.renderer.setGeometry(QRect(10, 10, 510, 325))
dlg_render.buttonBox = QDialogButtonBox(dlg_render)
dlg_render.buttonBox.setGeometry(QRect(10, 335, 510, 25))
dlg_render.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
dlg_render.buttonBox.accepted.connect(dlg_render.accept)
dlg_render.buttonBox.accepted.connect(dlg_render.renderer.onOK)
dlg_render.buttonBox.rejected.connect(dlg_render.reject)
dlg_render.setVisible(True)
# get user input and update renderer
answer = dlg_render.exec_()
if answer == QDialog.Accepted:
self.map_layer_renderer[cur_layer_idx] = None
self.map_layer_renderer[cur_layer_idx] = self.map_layers[cur_layer_idx].rendererV2().clone()
self.canvas.refresh()
dlg_render.destroy()
del dlg_render
except Exception as err:
# thematic is not-critical, allow continue on exception
logUICall.log(str(err), logUICall.WARNING)
@logUICall
@pyqtSlot()
def searchFeature(self):
cur_layer_name = self.ui.cb_layer_selector.currentText()
if cur_layer_name.isEmpty():
return
try:
cur_layer_idx = self.LAYER_NAMES.index(cur_layer_name)
layer = self.map_layers[cur_layer_idx]
fields = []
for fidx in layer.dataProvider().fields():
fields.append(layer.dataProvider().fields()[fidx].name())
dlg_search = DialogSearchFeature(fields)
answer = dlg_search.exec_()
if answer == QDialog.Accepted:
extent = self.findFeatureExtentByAttribute(layer, dlg_search.attribute, dlg_search.value)
if extent is not None:
self.zoomToExtent(extent)
else:
logUICall.log(get_ui_string("widget.result.info.notfound"), logUICall.WARNING)
dlg_search.destroy()
except Exception as err:
# thematic is not-critical, allow continue on exception
logUICall.log(str(err), logUICall.WARNING)
@logUICall