def populateGps(self):
"""Populate the labels with the GPS coordinates of this parcel.
Set them based on the coordinates of the centroid of the parcel,
taking the degrees/dms settings into account.
"""
def rewriteText(t):
tl = [i for i in t.split(',')]
r = tl[1] + '<br>' + tl[0]
return r
if self.feature:
gpsGeom = QGisCore.QgsGeometry(self.feature.geometry().centroid())
gpsGeom.transform(
QGisCore.QgsCoordinateTransform(
QGisCore.QgsCoordinateReferenceSystem(
31370,
QGisCore.QgsCoordinateReferenceSystem.EpsgCrsId),
QGisCore.QgsCoordinateReferenceSystem(
4326,
QGisCore.QgsCoordinateReferenceSystem.EpsgCrsId)))
dms = self.main.qsettings.value(
'/Qgis/plugins/Erosiebezwaren/gps_dms', 'false')
if dms == 'true':
self.lbv_gps.setText(
rewriteText(gpsGeom.asPoint().toDegreesMinutesSeconds(2)))
else:
self.lbv_gps.setText(
rewriteText(gpsGeom.asPoint().toDegreesMinutes(3)))
else:
self.lbv_gps.clear()
def reprojectGeometry(self, geom):
# Defining the crs from src and destiny
iface = self.getIface()
canvas = iface.mapCanvas()
epsg = canvas.mapSettings().destinationCrs().authid()
crsSrc = core.QgsCoordinateReferenceSystem(epsg)
#getting srid from something like 'EPSG:31983'
layer = canvas.currentLayer()
srid = layer.crs().authid()
crsDest = core.QgsCoordinateReferenceSystem(srid) #here we have to put authid, not srid
if srid != epsg:
# Creating a transformer
coordinateTransformer = core.QgsCoordinateTransform(crsSrc, crsDest)
lyrType = iface.activeLayer().geometryType()
# Transforming the points
if lyrType == core.QGis.Line:
geomList = geom.asPolyline()
elif lyrType == core.QGis.Polygon:
geomList = geom.asPolygon()
newGeom = []
for j in xrange(len(geomList)):
if lyrType == core.QGis.Line:
newGeom.append(coordinateTransformer.transform(geomList[j]))
elif lyrType == core.QGis.Polygon:
line = geomList[j]
for i in xrange(len(line)):
point = line[i]
newGeom.append(coordinateTransformer.transform(point))
if lyrType == core.QGis.Line:
return core.QgsGeometry.fromPolyline(newGeom)
elif lyrType == core.QGis.Polygon:
return core.QgsGeometry.fromPolygon([newGeom])
return geom
def transformToCurrentSRS(self, pPoint):
# transformation from the current SRS to WGS84
crcMappaCorrente = self.iface.mapCanvas().mapSettings().destinationCrs() # get current crs
crsDest = crcMappaCorrente
crsSrc = core.QgsCoordinateReferenceSystem(4326) # WGS 84
xform = core.QgsCoordinateTransform(crsSrc, crsDest, core.QgsProject.instance())
return xform.transform(pPoint) # forward transformation: src -> dest
def simplifyGeometry(self, geom, tolerance):
#Método para simplificar geometria
#Parâmetro de entrada: geom (Geometria adquirida), tolerance (Tolerância para simplificação)
#Parâmetro de retorno: sGeom (Geometria simplificada)
parameters = self.getParametersFromConfig()
sGeom = geom
source_crs = self.iface.activeLayer().crs()
dest_crs = core.QgsCoordinateReferenceSystem(3857)
tr = core.QgsCoordinateTransform(source_crs, dest_crs,
core.QgsCoordinateTransformContext())
sGeom.transform(tr)
for x in range(int(parameters[u'algIterations'])):
sGeom = sGeom.simplify(float(tolerance))
try:
sGeom = sGeom.smooth(
int(parameters[u'freeHandSmoothIterations']),
float(parameters[u'freeHandSmoothOffset']))
except:
msg = QMessageBox().tr(
'Probably too many smoothing iteration, try reducing it (3 usually is enough). Geometry was not smoothened.'
)
QMessageBox.warning(self.iface.mainWindow(),
QMessageBox().tr('Error!'), msg)
QgsMessageLog.logMessage(msg, 'DSGTools Plugin', Qgis.Critical)
return geom
tr = core.QgsCoordinateTransform(dest_crs, source_crs,
core.QgsCoordinateTransformContext())
sGeom.transform(tr)
return sGeom
def create_shp(self, shpfile_path, crsID=None):
fileInfo = QFileInfo(shpfile_path)
baseName = fileInfo.baseName()
try:
layer = qgc.QgsVectorLayer(shpfile_path, baseName, "none")
except:
layer = qgc.QgsVectorLayer(shpfile_path, baseName, "none")
sourceCrs = layer.crs()
destCrs = None
if crsID == None:
destCrs = qgc.QgsCoordinateReferenceSystem(4326)
else:
destCrs = qgc.QgsCoordinateReferenceSystem(crsID)
return layer
def __signal_pbCopyKml_clicked(self, cheked):
# Extent Openlayers
action = "map.getExtent().toGeometry().toString();"
wkt = self.webViewMap.page().mainFrame().evaluateJavaScript(action).toString()
rect = core.QgsGeometry.fromWkt(wkt).boundingBox()
srsGE = core.QgsCoordinateReferenceSystem(4326, core.QgsCoordinateReferenceSystem.EpsgCrsId)
coodTrans = core.QgsCoordinateTransform(self.__srsOL, srsGE)
rect = coodTrans.transform(rect, core.QgsCoordinateTransform.ForwardTransform)
line = core.QgsGeometry.fromRect(rect).asPolygon()[0]
wkt = str(core.QgsGeometry.fromPolyline(line).exportToWkt() )
# Kml
proj4 = str( srsGE.toProj4() )
kmlLine = bindogr.exportKml(wkt, proj4)
kml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"\
"<kml xmlns=\"http://www.opengis.net/kml/2.2\" " \
"xmlns:gx=\"http://www.google.com/kml/ext/2.2\" " \
"xmlns:kml=\"http://www.opengis.net/kml/2.2\" " \
"xmlns:atom=\"http://www.w3.org/2005/Atom\">" \
"<Placemark>" \
"<name>KML from Plugin Openlayers Overview for QGIS</name>" \
"<description>Extent of openlayers map from Plugin Openlayers Overview for QGIS</description>"\
"%s" \
"</Placemark></kml>" % kmlLine
clipBoard = QtGui.QApplication.clipboard()
clipBoard.setText(kml)
def __init__(self, main):
u"""Initialisation.
Set the stored point, and as a consequence the initial coördinates, to
the center of the map canvas.
Parameters
----------
main : erosiebezwaren.Erosiebezwaren
Instance of main class.
"""
self.main = main
QtGui.QDialog.__init__(self, self.main.iface.mainWindow())
self.setupUi(self)
self.main.selectionManagerPoints.activate()
self.led_latDecDeg.setValidator(
RoundingDoubleValidator(self.led_latDecDeg, -90.0, 90.0, 10))
self.led_lonDecDeg.setValidator(
RoundingDoubleValidator(self.led_lonDecDeg, -180.0, 180.0, 10))
self.transform_31370_to_4326 = QGisCore.QgsCoordinateTransform(
QGisCore.QgsCoordinateReferenceSystem(
31370, QGisCore.QgsCoordinateReferenceSystem.EpsgCrsId),
QGisCore.QgsCoordinateReferenceSystem(
4326, QGisCore.QgsCoordinateReferenceSystem.EpsgCrsId))
self.transform_4326_to_31370 = QGisCore.QgsCoordinateTransform(
QGisCore.QgsCoordinateReferenceSystem(
4326, QGisCore.QgsCoordinateReferenceSystem.EpsgCrsId),
QGisCore.QgsCoordinateReferenceSystem(
31370, QGisCore.QgsCoordinateReferenceSystem.EpsgCrsId))
point = self.main.iface.mapCanvas().extent().center()
self.point = self.transform_31370_to_4326.transform(point)
self.connectChangedSignals()
QtCore.QObject.connect(self.btn_zoom, QtCore.SIGNAL('clicked(bool)'),
self.zoomTo)
QtCore.QObject.connect(self.btn_zoom, QtCore.SIGNAL('clicked(bool)'),
self.hide)
self.populate()
def transformToCurrentSRS(self, pPoint, srs):
# transformation from provided srs to the current SRS
crcMappaCorrente = self.iface.mapCanvas().mapSettings().destinationCrs() # get current crs
#print crcMappaCorrente.srsid()
crsDest = crcMappaCorrente
crsSrc = core.QgsCoordinateReferenceSystem(srs)
xform = core.QgsCoordinateTransform(crsSrc, crsDest, core.QgsProject.instance())
return xform.transform(pPoint) # forward transformation: src -> dest
def load(self, data):
layer = core.QgsVectorLayer(data['query'], data['nome'], "virtual")
doc = QDomDocument()
doc.setContent(data['qml'])
layer.importNamedStyle(doc)
layer.triggerRepaint()
layer.setCrs(core.QgsCoordinateReferenceSystem(int(data['epsg'])))
self.addMapLayer(layer, 0)
def __init__(self, hasValidPixels, wktSRS=None):
self.hasValidPixels = hasValidPixels
self.metadata = {}
self.srsTransform = self.crsDescripTransform = self.msgError = None
if not wktSRS is None:
self.srsTransform = osr.SpatialReference()
self.srsTransform.ImportFromWkt(wktSRS)
crs = QgsCore.QgsCoordinateReferenceSystem()
crs.createFromWkt(wktSRS)
self.crsDescripTransform = crs.description()
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 loadRaster(self, uri, name, epsg):
s = QtCore.QSettings()
defaultBehavior = s.value("Projections/defaultBehavior")
s.setValue("Projections/defaultBehavior", "useGlobal")
layer = core.QgsRasterLayer(uri, name)
layer.setCrs(core.QgsCoordinateReferenceSystem(int(epsg)))
s.setValue("Projections/defaultBehavior", defaultBehavior)
if not layer.isValid():
return False
self.addMapLayer(layer)
return True
def pointBuffer(self,p):
infoLayer = self.infoBoxManager.getInfolayer()
toInfoLayerProjection = core.QgsCoordinateTransform(self.iface.mapCanvas().mapSettings().destinationCrs(),infoLayer.crs(), core.QgsProject.instance())
toWGS84 = core.QgsCoordinateTransform(infoLayer.crs(),core.QgsCoordinateReferenceSystem(4326), core.QgsProject.instance())
# create layer and replicate fields
bufferLayer = core.QgsVectorLayer("Point?crs="+infoLayer.crs().toWkt(), "temporary_points", "memory")
#bufferLayer.setCrs(infoLayer.crs()) #This generates alert message
bufferLayer.startEditing()
bufferLayer.addAttribute(core.QgsField("id",QtCore.QVariant.String))
bufferLayer.addAttribute(core.QgsField("html",QtCore.QVariant.String))
bufferLayer.addAttribute(core.QgsField("icon",QtCore.QVariant.String))
bufferLayer.addAttribute(core.QgsField("fid",QtCore.QVariant.Int))
self.enableControlShape(toInfoLayerProjection.transform(core.QgsPointXY(p)))
fetched = 0
self.featsId = self.infoBoxManager.getContextFeatures(toInfoLayerProjection.transform(p))
for featId in self.featsId:
feat = infoLayer.getFeatures(core.QgsFeatureRequest(featId)).__next__()
if fetched < 200:
if infoLayer.geometryType() == core.QgsWkbTypes.PolygonGeometry:
fGeom = feat.geometry().pointOnSurface()
elif infoLayer.geometryType() == core.QgsWkbTypes.PointGeometry:
fGeom = feat.geometry()
if fGeom.isMultipart():
multipoint = fGeom.asMultiPoint()
point = multipoint[0]
else:
point = fGeom.asPoint()
fetched += 1
newGeom = core.QgsGeometry.fromPointXY(core.QgsPointXY(point))
newFeat = core.QgsFeature()
newFeat.setGeometry(newGeom)
newFeat.setAttributes([self.infoBoxManager.getInfoField(feat),self.infoBoxManager.getHtml(feat),self.infoBoxManager.getIconPath(feat),self.infoBoxManager.getFeatId(feat)])
bufferLayer.addFeature(newFeat)
else:
core.QgsMessageLog.logMessage("fetched too much features..... 200 max", tag="go2streetview", level=core.Qgis.Warning)
break
bufferLayer.commitChanges()
core.QgsMessageLog.logMessage("markers context rebuilt", tag="go2streetview", level=core.Qgis.Info)
#StreetView markers
tmpfile = os.path.join(self.dirPath,"tmp","tmp_markers.geojson")
core.QgsVectorFileWriter.writeAsVectorFormat (bufferLayer, tmpfile,"UTF8",toWGS84,"GeoJSON")
with open(tmpfile) as f:
geojson = f.read().replace('\n','')
os.remove(tmpfile)
#js = geojson.replace("'",'')
#js = js.replace("\n",'\n')
js = """this.markersJson = %s""" % json.dumps(geojson)
self.view.SV.page().mainFrame().evaluateJavaScript(js)
self.view.BE.page().mainFrame().evaluateJavaScript(js)
js = """this.readJson() """
self.view.SV.page().mainFrame().evaluateJavaScript(js)
self.view.BE.page().mainFrame().evaluateJavaScript(js)
core.QgsMessageLog.logMessage("webview markers refreshed", tag="go2streetview", level=core.Qgis.Info)
def projectReadAction(self):
#remove current sketches
self.infoBoxManager.restoreIni()
self.scanForCoverageLayer()
if self.infoBoxManager.isEnabled() and self.apdockwidget.widget() != self.dumView:
infoLayer = self.infoBoxManager.getInfolayer()
toInfoLayerProjection = core.QgsCoordinateTransform(core.QgsCoordinateReferenceSystem(4326),
infoLayer.crs(), core.QgsProject.instance())
self.enableControlShape(toInfoLayerProjection.transform(core.QgsPointXY(self.pointWgs84)))
self.infoBoxManager.show()
self.infoBoxManager.raise_()
QtGui.QGuiApplication.processEvents()
self.infoBoxManager.acceptInfoBoxState()
QtGui.QGuiApplication.processEvents()
def __init__(self, iface, dockwidget, olLayerTypeRegistry):
QtGui.QWidget.__init__(self)
Ui_Form.__init__(self)
self.setupUi(self)
self.__canvas = iface.mapCanvas()
self.__dockwidget = dockwidget
self.__olLayerTypeRegistry = olLayerTypeRegistry
self.__pathUrl = "file:///%s/html/%%s" % os.path.dirname( __file__ ).replace("\\", "/")
self.__initLayerOL = False
self.__fileNameImg = ''
self.__srsOL = core.QgsCoordinateReferenceSystem(900913, core.QgsCoordinateReferenceSystem.EpsgCrsId)
self.__marker = MarkerCursor(self.__canvas, self.__srsOL)
self.__manager = None # Need persist for PROXY
bindogr.initOgr()
self.__init()
def __init__(self, iface, dockwidget, olLayerTypeRegistry):
QWidget.__init__(self)
Ui_Form.__init__(self)
self.setupUi(self)
self.__canvas = iface.mapCanvas()
self.__dockwidget = dockwidget
self.__olLayerTypeRegistry = olLayerTypeRegistry
self.__initLayerOL = False
self.__fileNameImg = ''
self.__srsOL = core.QgsCoordinateReferenceSystem(
3857, core.QgsCoordinateReferenceSystem.EpsgCrsId)
self.__marker = MarkerCursor(self.__canvas, self.__srsOL)
self.__manager = None # Need persist for PROXY
bindogr.initOgr()
self.__init()
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()
def createShapefile(self, path):
fields = core.QgsFields()
fields.append(core.QgsField("date", QtCore.QVariant.String))
fields.append(core.QgsField("lon", QtCore.QVariant.String))
fields.append(core.QgsField("lat", QtCore.QVariant.String))
fields.append(core.QgsField("heading", QtCore.QVariant.String))
fields.append(core.QgsField("pitch", QtCore.QVariant.String))
fields.append(core.QgsField("address", QtCore.QVariant.String))
fields.append(core.QgsField("notes", QtCore.QVariant.String))
fields.append(core.QgsField("url", QtCore.QVariant.String, len=250))
srs = core.QgsCoordinateReferenceSystem()
srs.createFromProj4("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
writer = core.QgsVectorFileWriter(path, "ISO 8859-1", fields,
core.QgsWkbTypes.Point, srs,
"ESRI Shapefile")
del writer
def apdockChangeVisibility(self,vis):
if not vis:
self.position.reset()
self.aperture.reset()
self.disableControlShape()
try:
self.StreetviewAction.setIcon(QtGui.QIcon(":/plugins/go2streetview/res/icoStreetview_gray.png"))
#self.StreetviewAction.setDisabled(True)
except:
pass
else:
self.StreetviewAction.setEnabled(True)
self.StreetviewAction.setIcon(QtGui.QIcon(":/plugins/go2streetview/res/icoStreetview.png"))
self.setPosition()
if self.infoBoxManager.isEnabled() and self.apdockwidget.widget() != self.dumView:
infoLayer = self.infoBoxManager.getInfolayer()
toInfoLayerProjection = core.QgsCoordinateTransform(core.QgsCoordinateReferenceSystem(4326),infoLayer.crs(), core.QgsProject.instance())
self.enableControlShape(toInfoLayerProjection.transform(core.QgsPointXY(self.pointWgs84)))
def CreateTMS_GDAL_WMS(self):
@QtCore.pyqtSlot(dict)
def finished(message):
self.thread.quit()
self.worker.finished.disconnect(finished)
self._sortNameGroupCatalog()
self._endProcessing("Create TMS", message['totalError'])
self._setGroupCatalog('TMS')
r = self._startProcess(self.worker.kill)
if not r['isOk']:
return
iterFeat = r['iterFeat']
path_tms = os.path.join(self.settings['path'], 'tms')
if not os.path.exists(path_tms):
os.makedirs(path_tms)
cr3857 = QgsCore.QgsCoordinateReferenceSystem(
3857, QgsCore.QgsCoordinateReferenceSystem.EpsgCrsId)
ctTMS = QgsCore.QgsCoordinateTransform(self.layer.crs(), cr3857)
self.worker.finished.connect(finished)
data = {
'pluginName': CatalogPL.pluginName,
'getURL': API_PlanetLabs.getURL_TMS,
'user_pwd': {
'user': API_PlanetLabs.validKey,
'pwd': ''
},
'path': path_tms,
'ltgCatalog': self.catalog['ltg'],
'id_layer': self.layer.id(),
'ctTMS': ctTMS,
'iterFeat': iterFeat # feat: 'id', 'acquired', 'meta_json'
}
self.worker.setting(data)
self.worker.stepProgress.connect(self.mbcancel.step)
self.thread.start() # Start Worker
def chooseLayer(self):
self.dlg = ChooseLayerDialog()
self.dlg.show()
result = self.dlg.exec_()
if result:
# get layer instance from comboBox
layer = self.dlg.layer
# If "use selected features only" create extent from selected features
if self.dlg.selectionCheckBox.isChecked():
f_count = layer.selectedFeatureCount()
features = layer.selectedFeatures()
box = features[0].geometry().boundingBox()
for i in range(1, f_count):
fbbox = features[i].geometry().boundingBox()
box.combineExtentWith(fbbox)
else: # No features selected get bounding box of entire layer
box = layer.extent()
source_crs = layer.crs()
dest_crs = core.QgsCoordinateReferenceSystem(4326)
if source_crs != dest_crs:
transform = core.QgsCoordinateTransform(
source_crs, dest_crs, core.QgsProject.instance())
extent = transform.transformBoundingBox(box)
else:
extent = box
self.xMin.setValue(extent.xMinimum())
self.xMax.setValue(extent.xMaximum())
self.yMin.setValue(extent.yMinimum())
self.yMax.setValue(extent.yMaximum())
self.toolSelect.drawRect(extent.xMinimum(), extent.yMinimum(),
extent.xMaximum(), extent.yMaximum())
return
def draw(self, renderContext):
if self.CheckLayerExtent() == False :
self.setLatLonGridCrsAndExtent()
self.generateLatLonGrid()
mapToPixel = renderContext.mapToPixel()
proj = core.QgsProject.instance()
# Default CRS: 3452 == EPSG:4326
srid = proj.readNumEntry('SpatialRefSys', '/ProjectCRSID', 3452)[0]
crs = core.QgsCoordinateReferenceSystem(srid, core.QgsCoordinateReferenceSystem.InternalCrsId)
xform = core.QgsCoordinateTransform(self.crs(), crs)
self.dlg.symbol.startRender(renderContext)
for line in self.ll_grid:
polyline = QtGui.QPolygonF()
for vertex in line:
end = mapToPixel.transform(xform.transform(vertex))
polyline.append(QtCore.QPointF(end.x(), end.y()))
if QGis.QGIS_VERSION_INT < 10800:
self.dlg.symbol.renderPolyline(polyline, renderContext)
else:
self.dlg.symbol.renderPolyline(polyline, None, renderContext)
if QGis.QGIS_VERSION_INT > 20200 :
self.drawLabels(renderContext)
self.dlg.symbol.stopRender(renderContext)
return True
def lineBuffer(self,p,polygons = None):
dBuffer = self.infoBoxManager.getDistanceBuffer()
infoLayer = self.infoBoxManager.getInfolayer()
toInfoLayerProjection = core.QgsCoordinateTransform(self.iface.mapCanvas().mapSettings().destinationCrs(),infoLayer.crs(), core.QgsProject.instance())
toWGS84 = core.QgsCoordinateTransform(infoLayer.crs(),core.QgsCoordinateReferenceSystem(4326), core.QgsProject.instance())
# create layer and replicate fields
bufferLayer = core.QgsVectorLayer("LineString?crs="+infoLayer.crs().toWkt(), "temporary_lines", "memory")
#bufferLayer.setCrs(infoLayer.crs()) #This generates alert message
bufferLayer.startEditing()
bufferLayer.addAttribute(core.QgsField("id",QtCore.QVariant.String))
bufferLayer.addAttribute(core.QgsField("html",QtCore.QVariant.String))
bufferLayer.addAttribute(core.QgsField("icon",QtCore.QVariant.String))
bufferLayer.addAttribute(core.QgsField("fid",QtCore.QVariant.Int))
fetched = 0
cutBuffer = core.QgsGeometry.fromPointXY(toInfoLayerProjection.transform(core.QgsPointXY(p))).buffer(dBuffer*2,10)
self.enableControlShape(toInfoLayerProjection.transform(core.QgsPointXY(p)))
if not polygons:
self.featsId = self.infoBoxManager.getContextFeatures(toInfoLayerProjection.transform(p))
for featId in self.featsId:
feat = infoLayer.getFeatures(core.QgsFeatureRequest(featId)).__next__()
if fetched < 1500:
if infoLayer.geometryType() == core.QgsWkbTypes.PolygonGeometry:
fGeom = feat.geometry().convertToType(core.QgsWkbTypes.LineGeometry)
elif infoLayer.geometryType() == core.QgsWkbTypes.LineGeometry:
fGeom = feat.geometry()
if fGeom:
#break on closest point on segment to pov to improve visibility
closestResult = fGeom.closestSegmentWithContext(toInfoLayerProjection.transform(p));
fGeom.insertVertex(closestResult[1][0],closestResult[1][1],closestResult[2])
cGeom = fGeom.intersection(cutBuffer)
if cGeom.isMultipart():
multigeom = cGeom.asMultiPolyline()
for geom in multigeom:
newGeom = core.QgsGeometry.fromPolylineXY(geom)
newFeat = core.QgsFeature()
newFeat.setGeometry(newGeom)
newFeat.setAttributes([self.infoBoxManager.getInfoField(feat),self.infoBoxManager.getHtml(feat),self.infoBoxManager.getIconPath(feat),self.infoBoxManager.getFeatId(feat)])
bufferLayer.addFeature(newFeat)
else:
geom = cGeom.asPolyline()
newGeom = core.QgsGeometry.fromPolylineXY(geom)
newFeat = core.QgsFeature()
newFeat.setGeometry(newGeom)
newFeat.setAttributes([self.infoBoxManager.getInfoField(feat),self.infoBoxManager.getHtml(feat),self.infoBoxManager.getIconPath(feat),self.infoBoxManager.getFeatId(feat)])
bufferLayer.addFeature(newFeat)
fetched = fetched + len(newGeom.asPolyline())
else:
core.QgsMessageLog.logMessage("Null geometry!", tag="go2streetview", level=core.Qgis.Warning)
else:
core.QgsMessageLog.logMessage("fetched too much features..... 200 max", tag="go2streetview", level=core.Qgis.Warning)
break
bufferLayer.commitChanges()
core.QgsMessageLog.logMessage("line context rebuilt: %s features" % bufferLayer.featureCount(), tag="go2streetview", level=core.Qgis.Info)
#StreetView lines
tmpfile = os.path.join(self.dirPath, "tmp", "tmp_lines.geojson")
core.QgsVectorFileWriter.writeAsVectorFormat(bufferLayer, tmpfile,"UTF8", toWGS84, "GeoJSON")
with open(tmpfile) as f:
geojson = f.read().replace('\n', '')
os.remove(tmpfile)
js = """this.linesJson = %s""" % json.dumps(geojson)
self.view.SV.page().mainFrame().evaluateJavaScript(js)
self.view.BE.page().mainFrame().evaluateJavaScript(js)
js = """this.readLinesJson() """
self.view.SV.page().mainFrame().evaluateJavaScript(js)
self.view.BE.page().mainFrame().evaluateJavaScript(js)
core.QgsMessageLog.logMessage("webview lines refreshed", tag="go2streetview", level=core.Qgis.Info)
def transformToWGS84(self, pPoint, srs):
# transformation from the provided SRS to WGS84
crsSrc = core.QgsCoordinateReferenceSystem(srs)
crsDest = core.QgsCoordinateReferenceSystem(4326) # WGS 84
xform = core.QgsCoordinateTransform(crsSrc, crsDest, core.QgsProject.instance())
return xform.transform(pPoint) # forward transformation: src -> dest
"""
"""QMessageBox creates a message pop-up whereas QFileDialog creates a file selection dialog. Find out more uses and options in the documentations"""
runScript = QMessageBox.question(iface.mainWindow(), 'Habitat Analyzer', 'Do you want to run the script?', QMessageBox.Yes, QMessageBox.No)
if runScript == QMessageBox.Yes:
QMessageBox.information(iface.mainWindow(), "Habitat Analyzer", "Welcome to Habitat Analyzer")
QMessageBox.information(iface.mainWindow(), "File Select", "Select your Environment layer from a Geopackage")
envInput = QFileDialog.getOpenFileName(QFileDialog(), "Environment Layer Selection", "\\svm-c113.hsr.ch\zkang\Desktop\QGIS-Steilkurs_MSE_Maerz_2017\QGIS-Steilkurs_MSE_Maerz_2017\daten_autobahn")
envPath = envInput[0]
env = iface.addVectorLayer(envPath, 'Environment', 'ogr')
env.setName("Environment")
"""Setting CRS of Environment layer"""
my_crs = core.QgsCoordinateReferenceSystem(31467, core.QgsCoordinateReferenceSystem.EpsgCrsId)
QgsMapSettings().setDestinationCrs(my_crs)
iface.mapCanvas().refresh()
"""Now, change the stylization of the envrionment layer"""
QMessageBox.information(iface.mainWindow(), "", "Setting the layer color to RGB 200, 220, 135 and opacity to 0.5")
envL = iface.activeLayer()
renderer = envL.renderer()
symbol = renderer.symbol()
symbol.setColor(QColor(0, 200, 220, 135))
symbol.setOpacity(.5)
envL.triggerRepaint()
iface.layerTreeView().refreshLayerSymbology(envL.id())
"""Next, we add the line file of the Autobahn, set it to red and then create a buffer around it to represent its physical form"""
QMessageBox.information(iface.mainWindow(), "File Select", "Select your Autobahn layer from a Geopackage")
def run(self):
def setFeatureAttributes(feat, filename, metadata):
def getHtmlTreeMetadata(value, html):
if isinstance(value, dict):
html += "<ul>"
for key, val in sorted(value.iteritems()):
if not isinstance(val, dict):
html += "<li>%s: %s</li> " % (key, val)
else:
html += "<li>%s</li> " % key
html = getHtmlTreeMetadata(val, html)
html += "</ul>"
return html
return html
feat.setAttribute('filename', filename)
feat.setAttribute('name', os.path.basename(filename))
html = getHtmlTreeMetadata(metadata, '')
feat.setAttribute('meta_html', html)
vjson = json.dumps(metadata)
feat.setAttribute('meta_json', vjson)
feat.setAttribute('meta_jsize', len(vjson))
totalError = totalAdded = 0
for i in xrange(len(self.lstSources)):
feat = QgsCore.QgsFeature(self.featTemplate)
if self.foot.calculate(self.lstSources[i]):
geomLayer = QgsCore.QgsGeometry.fromWkt(
self.foot.metadata['wkt_geom'])
crs = QgsCore.QgsCoordinateReferenceSystem()
crs.createFromWkt(self.foot.metadata['wkt_sr'])
self.ct.setSourceCrs(crs)
if not geomLayer.transform(self.ct) == 0:
msgError = {
'_error': True,
'message_error': "Can't transform geometry"
}
setFeatureAttributes(feat, self.lstSources[i], msgError)
totalError += 1
geomLayer.Destroy()
del feat
continue
del self.foot.metadata['wkt_geom']
del self.foot.metadata['wkt_sr']
self.foot.metadata['crs']['description'] = crs.description()
self.foot.metadata['_error'] = False
setFeatureAttributes(feat, self.lstSources[i],
self.foot.metadata)
feat.setGeometry(geomLayer)
totalAdded += 1
del geomLayer
else:
msgError = {
'_error': True,
'message_error': self.foot.msgError
}
setFeatureAttributes(feat, self.lstSources[i], msgError)
totalError += 1
if self.isKilled:
del feat
break
self.processed.emit({'feats': [feat]})
data = {
'idWorker': self.idWorker,
'totalAdded': totalAdded,
'totalError': totalError
}
self.finished.emit(data)
def create_crs(self, crsID):
crs = qgc.QgsCoordinateReferenceSystem()
crs.createFromId(crsID)
return crs
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)
