def saveLayer(self):
destCrs = None
ct = QgsCoordinateTransform()
if self.ui.txtSavePath.text() == "":
QMessageBox.warning(self, "Error", "Please input save file path")
return
else:
if self.ui.cmbCrs.currentIndex() == 0:
if self.baseLayer.crs() is None:
destCrs = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
# er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", destCrs, self.ui.cmbFormat.currentText())
else:
destCrs = self.baseLayer.crs()
print destCrs.authid()
# er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", self.baseLayer.crs(), self.ui.cmbFormat.currentText())
elif self.ui.cmbCrs.currentIndex() == 1:
destCrs = define._canvas.mapSettings().destinationCrs()
if destCrs is None:
destCrs = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
# er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", destCrs, self.ui.cmbFormat.currentText())
# else:
# er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", destCrs, self.ui.cmbFormat.currentText())
else:
destCrs = QgsCoordinateReferenceSystem(self.mCRS, QgsCoordinateReferenceSystem.InternalCrsId)
if destCrs != self.baseLayer.crs():
ct = QgsCoordinateTransform( self.baseLayer.crs(), destCrs )
er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", destCrs, self.ui.cmbFormat.currentText())
# er = QgsVectorFileWriter.writeAsVectorFormat(self.baseLayer, self.ui.txtSavePath.text(), "utf-8", self.crs, self.ui.cmbFormat.currentText())
QMessageBox.information(self, "Successful", "Export to vector file has been completed. ")
QDialog.accept(self)
def gdal_crs_string(crs: QgsCoordinateReferenceSystem) -> str:
"""
Converts a QgsCoordinateReferenceSystem to a string understandable
by GDAL
:param crs: crs to convert
:return: gdal friendly string
"""
if crs.authid().upper().startswith('EPSG:'):
return crs.authid()
# fallback to proj4 string
return crs.toProj4()
def gdal_crs_string(crs: QgsCoordinateReferenceSystem) -> str:
"""
Converts a QgsCoordinateReferenceSystem to a string understandable
by GDAL
:param crs: crs to convert
:return: gdal friendly string
"""
if crs.authid().upper().startswith('EPSG:'):
return crs.authid()
# fallback to proj4 string
return crs.toProj4()
def updateRaster(self):
if self.mcboRasterLayer.currentLayer() is None: return
layer = self.mcboRasterLayer.currentLayer()
provider = layer.dataProvider()
if provider.sourceHasNoDataValue(1):
self.lneNoDataVal.setText(str(provider.sourceNoDataValue(1)))
elif len(provider.userNoDataValues(1)) > 0:
self.lneNoDataVal.setText(str(provider.userNoDataValues(1)[0].min()))
else:
self.lneNoDataVal.clear()
# add a band list to the drop down box
bandCount = self.mcboRasterLayer.currentLayer().bandCount()
band_list = ['Band {: >2}'.format(i) for i in range(1, bandCount + 1)]
self.cboBand.setMaxCount(bandCount + 1)
self.cboBand.clear()
self.cboBand.addItems(sorted(band_list))
#set default coordinate system
rast_crs = layer.crs()
if rast_crs.authid()== '':
# Convert from the older style strings
rast_crs = QgsCoordinateReferenceSystem()
if not rast_crs.createFromProj(layer.crs().toWkt()):
rast_crs = layer.crs()
rast_crs = get_UTM_Coordinate_System(layer.extent().xMinimum(),
layer.extent().yMinimum(),
rast_crs.authid())
self.mCRSoutput.setCrs(rast_crs)
def newVectorLayer(filename,
fields,
geometryType,
crs,
name=None,
encoding=encoding):
"""
Creates a new vector layer
@param filename: The filename to store the file. The extensions determines the type of file.
If extension is not among the supported ones, a shapefile will be created and the file will
get an added '.shp' to its path.
If the filename is None, a memory layer will be created
@param fields: the fields to add to the layer. Accepts a QgsFields object or a list of tuples (field_name, field_type)
Accepted field types are basic Python types str, float, int and bool
@param geometryType: The type of geometry of the layer to create.
@param crs: The crs of the layer to create. Accepts a QgsCoordinateSystem object or a string with the CRS authId.
@param encoding: The layer encoding
"""
if isinstance(crs, str):
crs = QgsCoordinateReferenceSystem(crs)
if filename is None:
uri = geometryType
if crs.isValid():
uri += "?crs=" + crs.authid() + "&"
fieldsdesc = ["field=" + f for f in fields]
fieldsstring = "&".join(fieldsdesc)
uri += fieldsstring
if name is None:
name = "mem_layer"
layer = QgsVectorLayer(uri, name, "memory")
else:
formats = QgsVectorFileWriter.supportedFiltersAndFormats()
OGRCodes = {}
for (key, value) in formats.items():
extension = str(key)
extension = extension[extension.find("*.") + 2:]
extension = extension[:extension.find(" ")]
OGRCodes[extension] = value
extension = os.path.splitext(filename)[1][1:]
if extension not in OGRCodes:
extension = "shp"
filename = filename + ".shp"
if isinstance(fields, QgsFields):
qgsfields = fields
else:
qgsfields = QgsFields()
for field in fields:
qgsfields.append(_toQgsField(field))
QgsVectorFileWriter(filename, encoding, qgsfields, geometryType, crs,
OGRCodes[extension])
layer = QgsVectorLayer(filename, os.path.basename(filename), "ogr")
return layer
def bbox_to_string(bbox, crs=None):
""" Transforms BBox object into string
"""
target_crs = QgsCoordinateReferenceSystem(
crs if crs else Settings.parameters['crs'])
if target_crs.authid() == WGS84:
precision = 6
bbox_list = [
bbox.yMinimum(),
bbox.xMinimum(),
bbox.yMaximum(),
bbox.xMaximum()
]
else:
precision = 2
bbox_list = [
bbox.xMinimum(),
bbox.yMinimum(),
bbox.xMaximum(),
bbox.yMaximum()
]
return ','.join(
map(lambda coord: str(round(coord, precision)), bbox_list))
def newVectorLayer(filename,
fields,
geometryType,
crs,
name=None,
encoding="utf-8"):
'''
Creates a new vector layer
:param filename: The filename to store the file. The extensions determines the type of file.
If extension is not among the supported ones, a shapefile will be created and the file will
get an added '.shp' to its path.
If the filename is None, a memory layer will be created
:param fields: the fields to add to the layer. Accepts a QgsFields object or a list of tuples (field_name, field_type)
Accepted field types are basic Python types str, float, int and bool
:param geometryType: The type of geometry of the layer to create.
:param crs: The crs of the layer to create. Accepts a QgsCoordinateSystem object or a string with the CRS authId.
:param encoding: The layer encoding
'''
if isinstance(crs, basestring):
crs = QgsCoordinateReferenceSystem(crs)
if filename is None:
uri = GEOM_TYPE_MAP[geometryType]
if crs.isValid():
uri += '?crs=' + crs.authid() + '&'
fieldsdesc = ['field=' + f for f in fields]
fieldsstring = '&'.join(fieldsdesc)
uri += fieldsstring
if name is None:
name = "mem_layer"
layer = QgsVectorLayer(uri, name, 'memory')
else:
formats = QgsVectorFileWriter.supportedFiltersAndFormats()
OGRCodes = {}
for (key, value) in formats.items():
extension = unicode(key)
extension = extension[extension.find('*.') + 2:]
extension = extension[:extension.find(' ')]
OGRCodes[extension] = value
extension = os.path.splitext(filename)[1][1:]
if extension not in OGRCodes:
extension = 'shp'
filename = filename + '.shp'
if isinstance(fields, QgsFields):
qgsfields = fields
else:
qgsfields = QgsFields()
for field in fields:
qgsfields.append(_toQgsField(field))
QgsVectorFileWriter(filename, encoding, qgsfields, geometryType, crs,
OGRCodes[extension])
layer = QgsVectorLayer(filename, os.path.basename(filename), 'ogr')
return layer
def test_ExpressionFieldEllipsoidLengthCalculation(self):
#create a temporary layer
temp_layer = QgsVectorLayer("LineString?crs=epsg:3111&field=pk:int", "vl", "memory")
self.assertTrue(temp_layer.isValid())
f1 = QgsFeature(temp_layer.dataProvider().fields(), 1)
f1.setAttribute("pk", 1)
f1.setGeometry(QgsGeometry.fromPolyline([QgsPoint(2484588, 2425722), QgsPoint(2482767, 2398853)]))
temp_layer.dataProvider().addFeatures([f1])
# set project CRS and ellipsoid
srs = QgsCoordinateReferenceSystem(3111, QgsCoordinateReferenceSystem.EpsgCrsId)
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSProj4String", srs.toProj4())
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSID", srs.srsid())
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCrs", srs.authid())
QgsProject.instance().writeEntry("Measure", "/Ellipsoid", "WGS84")
QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(QGis.Meters))
idx = temp_layer.addExpressionField('$length', QgsField('length', QVariant.Double)) # NOQA
# check value
f = next(temp_layer.getFeatures())
expected = 26932.156
self.assertAlmostEqual(f['length'], expected, 3)
# change project length unit, check calculation respects unit
QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(QGis.Feet))
f = next(temp_layer.getFeatures())
expected = 88360.0918635
self.assertAlmostEqual(f['length'], expected, 3)
def run(self):
"""Run method that performs all the real work"""
# show the dialog
self.dlg.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.dlg.mQgsProjectionSelectionWidget.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
cursor = QCursor()
cursor.setShape(Qt.WaitCursor)
QApplication.instance().setOverrideCursor(cursor)
dbhost = self.dlg.lineEditHost.text()
dbuser = self.dlg.lineEditUsername.text()
dbpasswd = self.dlg.lineEditPassword.text()
dbport = int(self.dlg.lineEditPort.text())
dbschema = self.dlg.lineEditDB.text()
loadfile = self.dlg.lineEditFile.text()
crs = QgsCoordinateReferenceSystem.authid(self.dlg.mQgsProjectionSelectionWidget.crs())
os.chdir(os.path.dirname(os.path.abspath(loadfile)))
fname = os.path.basename(loadfile)
try:
thisdb = MySQLdb.connect(host=dbhost, port=dbport, user=dbuser, passwd=dbpasswd, db=dbschema)
command = 'ogr2ogr -f "MySQL" MYSQL:"' + dbschema + ',host=' + dbhost + ',user='******',password='******',port=' + str(dbport) + '" -a_srs "' + crs + '" -lco engine=MYISAM "' + fname + '"'
subprocess.check_call(command, shell=True)
except MySQLdb.Error:
QApplication.instance().restoreOverrideCursor()
self.iface.messageBar().pushMessage("Error:", "Could not connect to database with these parameters! Please check your settings and try again. Nothing has been imported.", level=QgsMessageBar.CRITICAL)
finally:
thisdb.close()
self.dlg.lineEditFile.clear()
QApplication.instance().restoreOverrideCursor()
QMessageBox.information(self.iface.mainWindow(), "MySQL/MariaDB Import", "The file " + fname + " has been imported successfully.")
def test_ExpressionFieldEllipsoidLengthCalculation(self):
#create a temporary layer
temp_layer = QgsVectorLayer("LineString?crs=epsg:3111&field=pk:int", "vl", "memory")
self.assertTrue(temp_layer.isValid())
f1 = QgsFeature(temp_layer.dataProvider().fields(), 1)
f1.setAttribute("pk", 1)
f1.setGeometry(QgsGeometry.fromPolyline([QgsPoint(2484588, 2425722), QgsPoint(2482767, 2398853)]))
temp_layer.dataProvider().addFeatures([f1])
# set project CRS and ellipsoid
srs = QgsCoordinateReferenceSystem(3111, QgsCoordinateReferenceSystem.EpsgCrsId)
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSProj4String", srs.toProj4())
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSID", srs.srsid())
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCrs", srs.authid())
QgsProject.instance().writeEntry("Measure", "/Ellipsoid", "WGS84")
QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(QGis.Meters))
idx = temp_layer.addExpressionField('$length', QgsField('length', QVariant.Double)) # NOQA
# check value
f = temp_layer.getFeatures().next()
expected = 26932.156
self.assertAlmostEqual(f['length'], expected, 3)
# change project length unit, check calculation respects unit
QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(QGis.Feet))
f = temp_layer.getFeatures().next()
expected = 88360.0918635
self.assertAlmostEqual(f['length'], expected, 3)
def test_ExpressionFieldEllipsoidAreaCalculation(self):
#create a temporary layer
temp_layer = QgsVectorLayer("Polygon?crs=epsg:3111&field=pk:int", "vl", "memory")
self.assertTrue(temp_layer.isValid())
f1 = QgsFeature(temp_layer.dataProvider().fields(), 1)
f1.setAttribute("pk", 1)
f1.setGeometry(QgsGeometry.fromPolygon([[QgsPoint(2484588, 2425722), QgsPoint(2482767, 2398853), QgsPoint(2520109, 2397715), QgsPoint(2520792, 2425494), QgsPoint(2484588, 2425722)]]))
temp_layer.dataProvider().addFeatures([f1])
# set project CRS and ellipsoid
srs = QgsCoordinateReferenceSystem(3111, QgsCoordinateReferenceSystem.EpsgCrsId)
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSProj4String", srs.toProj4())
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSID", srs.srsid())
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCrs", srs.authid())
QgsProject.instance().writeEntry("Measure", "/Ellipsoid", "WGS84")
QgsProject.instance().writeEntry("Measurement", "/AreaUnits", QgsUnitTypes.encodeUnit(QgsUnitTypes.SquareMeters))
idx = temp_layer.addExpressionField('$area', QgsField('area', QVariant.Double)) # NOQA
# check value
f = next(temp_layer.getFeatures())
expected = 1009089817.0
self.assertAlmostEqual(f['area'], expected, delta=1.0)
# change project area unit, check calculation respects unit
QgsProject.instance().writeEntry("Measurement", "/AreaUnits", QgsUnitTypes.encodeUnit(QgsUnitTypes.SquareMiles))
f = next(temp_layer.getFeatures())
expected = 389.6117565069
self.assertAlmostEqual(f['area'], expected, 3)
def test_projection(self):
"""Test that QGIS properly parses a wkt string.
"""
crs = QgsCoordinateReferenceSystem()
wkt = (
'GEOGCS["WGS 84",DATUM["WGS_1984",'
'SPHEROID["WGS 84",6378137,298.257223563,'
'AUTHORITY["EPSG","7030"]],'
'AUTHORITY["EPSG","6326"]],'
'PRIMEM["Greenwich",0,'
'AUTHORITY["EPSG","8901"]],'
'UNIT["degree",0.0174532925199433,'
'AUTHORITY["EPSG","9122"]],'
'AUTHORITY["EPSG","4326"]]'
)
crs.createFromWkt(wkt)
auth_id = crs.authid()
expected_auth_id = 'EPSG:4326'
self.assertEqual(auth_id, expected_auth_id)
# now test for a loaded layer
path = os.path.join(os.path.dirname(__file__), 'tenbytenraster.asc')
title = 'TestRaster'
layer = QgsRasterLayer(path, title)
auth_id = layer.crs().authid()
self.assertEqual(auth_id, expected_auth_id)
def test_ExpressionFieldEllipsoidAreaCalculation(self):
#create a temporary layer
temp_layer = QgsVectorLayer("Polygon?crs=epsg:3111&field=pk:int", "vl", "memory")
self.assertTrue(temp_layer.isValid())
f1 = QgsFeature(temp_layer.dataProvider().fields(), 1)
f1.setAttribute("pk", 1)
f1.setGeometry(QgsGeometry.fromPolygon([[QgsPoint(2484588, 2425722), QgsPoint(2482767, 2398853), QgsPoint(2520109, 2397715), QgsPoint(2520792, 2425494), QgsPoint(2484588, 2425722)]]))
temp_layer.dataProvider().addFeatures([f1])
# set project CRS and ellipsoid
srs = QgsCoordinateReferenceSystem(3111, QgsCoordinateReferenceSystem.EpsgCrsId)
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSProj4String", srs.toProj4())
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSID", srs.srsid())
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCrs", srs.authid())
QgsProject.instance().writeEntry("Measure", "/Ellipsoid", "WGS84")
QgsProject.instance().writeEntry("Measurement", "/AreaUnits", QgsUnitTypes.encodeUnit(QgsUnitTypes.SquareMeters))
idx = temp_layer.addExpressionField('$area', QgsField('area', QVariant.Double)) # NOQA
# check value
f = temp_layer.getFeatures().next()
expected = 1009089817.0
self.assertAlmostEqual(f['area'], expected, delta=1.0)
# change project area unit, check calculation respects unit
QgsProject.instance().writeEntry("Measurement", "/AreaUnits", QgsUnitTypes.encodeUnit(QgsUnitTypes.SquareMiles))
f = temp_layer.getFeatures().next()
expected = 389.6117565069
self.assertAlmostEqual(f['area'], expected, 3)
def CrsId2AuthID(self, crsid=0):
toconvert = QgsCoordinateReferenceSystem()
if crsid=="" or crsid==0 or crsid is None:
converted=""
else:
toconvert.createFromId(int(crsid), QgsCoordinateReferenceSystem.InternalCrsId)
converted=toconvert.authid()
return converted.lower()
def test_projection(self):
"""Test that QGIS properly parses a wkt string.
"""
crs = QgsCoordinateReferenceSystem()
wkt = ('GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",'
'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
'PRIMEM["Greenwich",0.0],UNIT["Degree",'
'0.0174532925199433]]')
crs.createFromWkt(wkt)
auth_id = crs.authid()
expected_auth_id = 'EPSG:4326'
self.assertEqual(auth_id, expected_auth_id)
def test_projection(self):
"""Test that QGIS properly parses a wkt string.
"""
crs = QgsCoordinateReferenceSystem()
wkt = (
'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",'
'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
'PRIMEM["Greenwich",0.0],UNIT["Degree",'
'0.0174532925199433]]')
crs.createFromWkt(wkt)
auth_id = crs.authid()
expected_auth_id = 'EPSG:4326'
self.assertEqual(auth_id, expected_auth_id)
def init(self, config): # called from tool
try:
self.debug = config.get('debug', False)
if self.debug: self.info.log("init")
#status
self.layer = self.iface.activeLayer()
self.prj = QgsProject.instance()
self.cboCoordSystems.clear()
# tooldata
self.coords = config.get('coordinatereferences', self.coords)
self.pointScale = config.get('point_scale', self.pointScale)
self.buffer_scale = config.get("buffer_scale", self.buffer_scale)
self.minimum_scale = config.get("minimum_scale",
self.minimum_scale)
if not self.coords:
self.cboCoordSystems.setHidden(True)
self.projectWid.setHidden(False)
self.projectWid.setCrs(self.prj.crs())
cbos = self.projectWid.findChildren(QComboBox)
for cbo in cbos:
cbo.setMaximumHeight(self.iface.iconSize().height())
else:
self.projectWid.setHidden(True)
self.cboCoordSystems.setHidden(False)
crs = self.prj.crs()
self.cboCoordSystems.addItem(
"Project CRS: " + crs.authid() + " - " + crs.description(),
crs)
for crsID in self.coords:
try:
crs = QgsCoordinateReferenceSystem(crsID)
self.cboCoordSystems.addItem(
crs.authid() + " - " + crs.description(), crs)
except Exception as e:
self.info.err(e)
#ui stuff
btns = self.findChildren(QToolButton)
for btn in btns:
btn.setIconSize(self.iface.iconSize())
#start
self.fillCombo(self.layer)
self.fillTable(True)
except Exception as e:
self.info.err(e)
def test_projection(self):
"""Test that QGIS properly parses a wkt string.
"""
crs = QgsCoordinateReferenceSystem()
wkt = ('GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",'
'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
'PRIMEM["Greenwich",0.0],UNIT["Degree",'
'0.0174532925199433]]')
crs.createFromWkt(wkt)
auth_id = crs.authid()
self.assertIn(auth_id, ('EPSG:4326', 'OGC:CRS84'))
# now test for a loaded layer
path = os.path.join(os.path.dirname(__file__), 'tenbytenraster.asc')
title = 'TestRaster'
layer = QgsRasterLayer(path, title)
auth_id = layer.crs().authid()
self.assertIn(auth_id, ('EPSG:4326', 'OGC:CRS84'))
def test_projection(self):
"""QGIS properly parses a wkt string"""
crs = QgsCoordinateReferenceSystem()
wkt = (
'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",'
'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
'PRIMEM["Greenwich",0.0],UNIT["Degree",'
'0.0174532925199433]]')
crs.createFromWkt(wkt)
auth_id = crs.authid()
expected_auth_id = 'EPSG:4326'
self.assertEqual(auth_id, expected_auth_id)
# now test for a loaded layer
path = os.path.join(os.path.dirname(__file__), 'tenbytenraster.asc')
title = 'TestRaster'
layer = QgsRasterLayer(path, title)
auth_id = layer.crs().authid()
self.assertEqual(auth_id, expected_auth_id)
def on_mcboLineLayer_layerChanged(self):
# set default coordinate system
layer = self.mcboLineLayer.currentLayer()
if layer is None:
return
line_crs = layer.crs()
if line_crs.authid() == '':
# Convert from the older style strings
line_crs = QgsCoordinateReferenceSystem()
if not line_crs.createFromProj(layer.crs().toWkt()):
line_crs = layer.crs()
line_crs = get_UTM_Coordinate_System(layer.extent().xMinimum(),
layer.extent().yMinimum(),
line_crs.authid())
self.mCRSoutput.setCrs(line_crs)
def testProjInterpretation(self):
"""Test that QGIS properly parses a proj4 string.
see https://github.com/AIFDR/inasafe/issues/349
"""
myCrs = QgsCoordinateReferenceSystem()
myProj4 = ('GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",'
'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
'PRIMEM["Greenwich",0.0],UNIT["Degree",'
'0.0174532925199433]]')
myCrs.createFromWkt(myProj4)
myAuthId = myCrs.authid()
myExpectedAuthId = 'EPSG:4326'
self.assertEqual(myAuthId, myExpectedAuthId)
# now test for a loaded layer
myPath = os.path.join(EXPDATA, 'glp10ag.asc')
myTitle = 'people'
myLayer = QgsRasterLayer(myPath, myTitle)
myAuthId = myLayer.crs().authid()
self.assertEqual(myAuthId, myExpectedAuthId)
def convert_feature_service_workspace(
name, workspace_name: WorkspaceName, base: str,
crs: QgsCoordinateReferenceSystem, subset: str,
context: Context) -> DataSourceProperties:
"""
Convert FeatureServiceWorkspaceFactory
"""
# todo -- auto create auth service?
crs_text = crs.authid()
if not crs_text:
crs_text = 'WKT:{}'.format(crs.toWkt())
uri = "crs='{}' url='{}/{}'".format(crs_text, workspace_name.name,
name.name)
if context.ignore_online_sources:
uri = ''
provider = 'arcgisfeatureserver'
wkb_type = DatasetNameConverter.geometry_type_to_wkb(name.shape_type)
return DataSourceProperties(uri=uri,
wkb_type=wkb_type,
provider=provider)
def test_projection(self):
"""Tests that QGIS properly parses a WKT string."""
crs = QgsCoordinateReferenceSystem()
wkt = ('GEOGCS["GCS_WGS_1984",'
'DATUM["D_WGS_1984",'
'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
'PRIMEM["Greenwich",0.0],'
'UNIT["Degree",0.0174532925199433]]')
crs.createFromWkt(wkt)
auth_id = crs.authid()
exp_auth_id = 'EPSG:4326'
self.assertEqual(auth_id, exp_auth_id)
# test for a loaded layer
path = os.path.join(os.path.dirname(__file__), 'tenbytenraster.asc')
lyr = QgsRasterLayer(path, 'TestRaster')
auth_id = lyr.crs().authid()
self.assertEqual(auth_id, exp_auth_id)
def updateRaster(self):
"""Update form elements based on raster metadata elements"""
if self.mcboRasterLayer.currentLayer() is None: return
rast_layer = self.mcboRasterLayer.currentLayer()
provider = rast_layer.dataProvider()
if provider.sourceHasNoDataValue(1):
self.lneNoDataVal.setText(str(provider.sourceNoDataValue(1)))
elif len(provider.userNoDataValues(1)) > 0:
self.lneNoDataVal.setText(str(provider.userNoDataValues(1)[0].min()))
else:
self.lneNoDataVal.setText('0')
# add a band list to the drop down box
bandCount = self.mcboRasterLayer.currentLayer().bandCount()
band_list = ['Band {: >2}'.format(i) for i in range(1, bandCount + 1)]
for obj in [self.cboBandRed, self.cboBandGreen, self.cboBandIR, self.cboBandRedEdge, self.cboBandNonVine]:
obj.setMaxCount(bandCount + 1)
obj.clear()
obj.addItems([u''] + sorted(band_list))
# clear the coordinate system
self.mCRSoutput.setCrs(QgsCoordinateReferenceSystem())
# set default coordinate system
rast_crs = rast_layer.crs()
if rast_crs.authid() == '':
# Convert from the older style strings
rast_crs = QgsCoordinateReferenceSystem()
if not rast_crs.createFromProj(rast_layer.crs().toWkt()):
rast_crs = rast_layer.crs()
else:
self.mcboRasterLayer.currentLayer().setCrs(rast_crs)
rast_crs = get_UTM_Coordinate_System(rast_layer.extent().xMinimum(),
rast_layer.extent().yMinimum(),
rast_crs.authid())
self.mCRSoutput.setCrs(rast_crs)
def test_proj_interpretation(self):
"""Test that QGIS properly parses a proj4 string.
see https://github.com/AIFDR/inasafe/issues/349
"""
# noinspection PyCallingNonCallable
crs = QgsCoordinateReferenceSystem()
proj4 = ('GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",'
'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
'PRIMEM["Greenwich",0.0],UNIT["Degree",'
'0.0174532925199433]]')
crs.createFromWkt(proj4)
auth_id = crs.authid()
expected_auth_id = 'EPSG:4326'
self.assertEqual(auth_id, expected_auth_id)
# now test for a loaded layer
path = standard_data_path('hazard', 'jakarta_flood_design.tif')
title = 'Jakarta Flood'
# noinspection PyCallingNonCallable
layer = QgsRasterLayer(path, title)
auth_id = layer.crs().authid()
self.assertEqual(auth_id, expected_auth_id)
def bbox_to_string(bbox, crs):
""" Transforms a bounding box into string a string of comma-separated values
"""
target_crs = QgsCoordinateReferenceSystem(crs)
if target_crs.authid() == CrsType.WGS84:
precision = 6
bbox_list = [
bbox.yMinimum(),
bbox.xMinimum(),
bbox.yMaximum(),
bbox.xMaximum()
]
else:
precision = 2
bbox_list = [
bbox.xMinimum(),
bbox.yMinimum(),
bbox.xMaximum(),
bbox.yMaximum()
]
return ','.join(map(lambda coord: str(round(coord, precision)), bbox_list))
def test_proj_interpretation(self):
"""Test that QGIS properly parses a proj4 string.
see https://github.com/AIFDR/inasafe/issues/349
"""
# noinspection PyCallingNonCallable
crs = QgsCoordinateReferenceSystem()
proj4 = (
'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",'
'SPHEROID["WGS_1984",6378137.0,298.257223563]],'
'PRIMEM["Greenwich",0.0],UNIT["Degree",'
'0.0174532925199433]]')
crs.createFromWkt(proj4)
auth_id = crs.authid()
expected_auth_id = 'EPSG:4326'
self.assertEqual(auth_id, expected_auth_id)
# now test for a loaded layer
path = standard_data_path('hazard', 'jakarta_flood_design.tif')
title = 'Jakarta Flood'
# noinspection PyCallingNonCallable
layer = QgsRasterLayer(path, title)
auth_id = layer.crs().authid()
self.assertEqual(auth_id, expected_auth_id)
def added(self): # widget was added to parent
try:
self.crs_transform = self.prj.crs()
self.crs_layer = self.iface.activeLayer().crs()
# set crs widget
if self.coordinatereferences is None:
# qgis transform
self.cboCoordSys.setHidden(True)
self.cboCoordSystems = self.mQgsProjectionSelectionWidget
self.cboCoordSystems.setMinimumWidth(460)
self.cboCoordSystems.setOptionVisible(QgsProjectionSelectionWidget.ProjectCrs, True)
self.cboCoordSystems.setCrs(self.prj.crs())
self.setCrs(self.cboCoordSystems.crs())
self.cboCoordSystems.crsChanged.connect(self.setCrs)
else:
# custom transform
self.mQgsProjectionSelectionWidget.setHidden(True)
self.cboCoordSystems = self.cboCoordSys
self.cboCoordSystems.setMinimumWidth(400)
self.cboCoordSystems.currentIndexChanged.connect(
lambda: self.setCrs(self.cboCoordSystems.currentData()))
self.cboCoordSystems.addItem(
"Projekt CRS: " + self.crs_transform.authid() + " - " + self.crs_transform.description(),
self.crs_transform)
for crsID in self.coordinatereferences:
try:
crs = QgsCoordinateReferenceSystem(crsID)
self.cboCoordSystems.addItem(crs.authid() + " - " + crs.description(), crs)
except Exception as e:
self.info.err(e)
self.cboCoordSystems.setCurrentIndex(0)
# here we know which type is cboCoordSystems!
self.setIconSizes()
except Exception as e:
self.info.err(e)
class MapBiomasAlertRequest(QObject):
killProcess = pyqtSignal()
currentProcess = pyqtSignal(str)
finishedProcess = pyqtSignal()
showExtentProcess = pyqtSignal()
message = pyqtSignal(Qgis.MessageLevel, str)
def __init__(self, canvas):
super().__init__()
self.nameCatalog = 'mapbiomas_alert_valid'
self.apiMB = API_MapbiomasAlert()
self.killProcess.connect(self.apiMB.kill)
self.canvas = canvas
self.project = QgsProject.instance()
self.layerTreeRoot = self.project.layerTreeRoot()
self.mapCanvasGeom = MapCanvasGeometry()
self.pluginName = 'MapBiomas'
self.crsCatalog = QgsCoordinateReferenceSystem('EPSG:4674')
self.styleFile = 'mapbiomas_alert.qml'
self.alert = None
self.alert_id = None
self.response = None
self.isRunning = None
def __del__(self):
self.killProcess.disconnect(self.apiMB.kill)
def _createCatalog(self):
key_value = lambda k: "field={key}:{value}".format(
key=k, value=self.apiMB.fields[k]['definition'])
l_fields = [key_value(k) for k in self.apiMB.fields.keys()]
l_fields.insert(
0, "Multipolygon?crs={}".format(self.crsCatalog.authid().lower()))
l_fields.append('index=yes')
uri = '&'.join(l_fields)
self.alert = QgsVectorLayer(uri, self.nameCatalog, 'memory')
self.alert.loadNamedStyle(
os.path.join(os.path.dirname(__file__), self.styleFile))
self.alert_id = self.alert.id()
def _responseFinished(self, response):
self.response = response
def actionsForm(self, nameAction, feature_id=None):
"""
Run action defined in layer, provide by style file
:param nameAction: Name of action
:params feature_id: Feature ID
"""
# Actions functions
def flash(feature_id):
geom = self.alert.getFeature(feature_id).geometry()
self.mapCanvasGeom.flash([geom], self.alert)
return {'isOk': True}
def zoom(feature_id):
geom = self.alert.getFeature(feature_id).geometry()
self.mapCanvasGeom.zoom([geom], self.alert)
return {'isOk': True}
def report(feature_id):
feat = self.alert.getFeature(feature_id)
alerta_id = feat['alerta_id']
cars_ids = feat['cars']
if len(cars_ids) == 0:
url = "{}/{}".format(API_MapbiomasAlert.urlReport, alerta_id)
QDesktopServices.openUrl(QUrl(url))
else:
for car_id in cars_ids.split('\n'):
url = "{}/{}/car/{}".format(API_MapbiomasAlert.urlReport,
alerta_id, car_id)
QDesktopServices.openUrl(QUrl(url))
return {'isOk': True}
actionsFunc = {'flash': flash, 'zoom': zoom, 'report': report}
if not nameAction in actionsFunc.keys():
return {
'isOk': False,
'message': "Missing action '{}'".format(nameAction)
}
return actionsFunc[nameAction](feature_id)
def requestPopulateCatalog(self):
def getWktExtent():
crsCanvas = self.canvas.mapSettings().destinationCrs()
ct = QgsCoordinateTransform(crsCanvas, self.crsCatalog,
self.project)
extent = self.canvas.extent(
) if crsCanvas == self.crsCatalog else ct.transform(
self.canvas.extent())
return extent.asWktPolygon()
def populate(features):
provider = self.alert.dataProvider()
for item in features:
atts = [item[k] for k in self.apiMB.fields]
feat = QgsFeature()
feat.setAttributes(atts)
geom = item['geometry']
if not geom is None:
feat.setGeometry(geom)
provider.addFeature(feat)
del item
def finished(response):
self.response = response
if not response['isOk']:
self.message.emit(Qgis.Critical, response['message'])
return
if len(self.response['features']) == 0:
self.message.emit(Qgis.Warning,
"Inside this view don't have alerts")
del response['features']
return
populate(response['features'])
del response['features']
self.message.emit(Qgis.Success, 'Finished OK')
def closeTableAttribute():
layer_id = self.alert_id
widgets = QApplication.instance().allWidgets()
for tb in filter(
lambda w: isinstance(w, QDialog) and layer_id in w.
objectName(), widgets):
tb.close()
self.currentProcess.emit('Populate Catalog')
existsCatalog = not self.alert is None and not self.project.mapLayer(
self.alert_id) is None
if not existsCatalog:
self._createCatalog()
else:
name = "Receiving... - {}".format(self.nameCatalog)
self.alert.setName(name)
self.alert.dataProvider().truncate() # Delete all features
closeTableAttribute()
self.response = None
self.calculateMetadata = True
self.message.emit(Qgis.Info, 'Request features...')
url = self.apiMB.getUrlAlerts(getWktExtent())
self.apiMB.getAlerts(url, finished)
self.calculateMetadata = False
if self.response['isOk']:
if not existsCatalog:
self.project.addMapLayer(self.alert, addToLegend=False)
root = self.project.layerTreeRoot()
root.insertLayer(0, self.alert).setCustomProperty(
"showFeatureCount", True)
else:
self.alert.setName(self.nameCatalog)
self.alert.triggerRepaint()
else:
root = self.project.layerTreeRoot()
if not root.findLayer(self.alert) is None:
root.removeLayer(self.alert)
def searchAlert(self):
self.currentProcess.emit('Check server')
self.apiMB.isHostLive(self._responseFinished)
if not self.response['isOk']:
self.message.emit(Qgis.Critical, 'MapBioma server is out')
self.finishedProcess.emit()
return
self.currentProcess.emit('Search alerts')
if self.canvas.layerCount() == 0:
msg = 'Need layer(s) in map'
self.message.emit(Qgis.Warning, msg)
else:
self.apiMB.access.isKill = False
self.showExtentProcess.emit()
self.requestPopulateCatalog()
self.finishedProcess.emit()
@pyqtSlot()
def onCancel(self):
self.killProcess.emit()
class Qdraw(object):
def __init__(self, iface):
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
os.path.dirname(__file__),
'i18n',
'qdraw_{}.qm'.format(locale))
self.translator = None
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
self.iface = iface
self.sb = self.iface.statusBarIface()
self.tool = None
self.toolname = None
self.bGeom = None
self.actions = []
self.menu = '&Qdraw'
self.toolbar = self.iface.addToolBar('Qdraw')
self.toolbar.setObjectName('Qdraw')
self.settings = QdrawSettings()
def unload(self):
for action in self.actions:
self.iface.removePluginVectorMenu('&Qdraw', action)
self.iface.removeToolBarIcon(action)
del self.toolbar
def tr(self, message):
return QCoreApplication.translate('Qdraw', message)
def add_action(
self,
icon_path,
text,
callback,
enabled_flag=True,
checkable=False,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
menu=None,
parent=None):
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
action.setCheckable(checkable)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if menu is not None:
action.setMenu(menu)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToVectorMenu(
self.menu,
action)
self.actions.append(action)
return action
def initGui(self):
pointMenu = QMenu()
pointMenu.addAction(
QIcon(':/plugins/Qgeric/resources/icon_DrawPtXY.png'),
self.tr('XY Point drawing tool'), self.drawXYPoint)
pointMenu.addAction(
QIcon(':/plugins/Qgeric/resources/icon_DrawPtDMS.png'),
self.tr('DMS Point drawing tool'), self.drawDMSPoint)
icon_path = ':/plugins/Qgeric/resources/icon_DrawPt.png'
self.add_action(
icon_path,
text=self.tr('Point drawing tool'),
checkable=True,
menu=pointMenu,
callback=self.drawPoint,
parent=self.iface.mainWindow()
)
icon_path = ':/plugins/Qgeric/resources/icon_DrawL.png'
self.add_action(
icon_path,
text=self.tr('Line drawing tool'),
checkable=True,
callback=self.drawLine,
parent=self.iface.mainWindow()
)
icon_path = ':/plugins/Qgeric/resources/icon_DrawR.png'
self.add_action(
icon_path,
text=self.tr('Rectangle drawing tool'),
checkable=True,
callback=self.drawRect,
parent=self.iface.mainWindow()
)
icon_path = ':/plugins/Qgeric/resources/icon_DrawC.png'
self.add_action(
icon_path,
text=self.tr('Circle drawing tool'),
checkable=True,
callback=self.drawCircle,
parent=self.iface.mainWindow()
)
icon_path = ':/plugins/Qgeric/resources/icon_DrawP.png'
self.add_action(
icon_path,
text=self.tr('Polygon drawing tool'),
checkable=True,
callback=self.drawPolygon,
parent=self.iface.mainWindow()
)
bufferMenu = QMenu()
polygonBufferAction = QAction(
QIcon(':/plugins/Qgeric/resources/icon_DrawTP.png'),
self.tr('Polygon buffer drawing tool on the selected layer'),
bufferMenu)
polygonBufferAction.triggered.connect(self.drawPolygonBuffer)
bufferMenu.addAction(polygonBufferAction)
icon_path = ':/plugins/Qgeric/resources/icon_DrawT.png'
self.add_action(
icon_path,
text=self.tr('Buffer drawing tool on the selected layer'),
checkable=True,
menu=bufferMenu,
callback=self.drawBuffer,
parent=self.iface.mainWindow()
)
icon_path = ':/plugins/Qgeric/resources/icon_Settings.png'
self.add_action(
icon_path,
text=self.tr('Settings'),
callback=self.showSettingsWindow,
parent=self.iface.mainWindow()
)
def drawPoint(self):
if self.tool:
self.tool.reset()
self.tool = DrawPoint(self.iface, self.settings.getColor())
self.tool.setAction(self.actions[0])
self.tool.selectionDone.connect(self.draw)
self.iface.mapCanvas().setMapTool(self.tool)
self.drawShape = 'point'
self.toolname = 'drawPoint'
self.resetSB()
def drawXYPoint(self):
tuple, ok = XYDialog().getPoint(
self.iface.mapCanvas().mapSettings().destinationCrs())
point = tuple[0]
self.XYcrs = tuple[1]
if ok:
if point.x() == 0 and point.y() == 0:
QMessageBox.critical(
self.iface.mainWindow(),
self.tr('Error'), self.tr('Invalid input !'))
else:
self.drawPoint()
self.tool.rb = QgsRubberBand(
self.iface.mapCanvas(), QgsWkbTypes.PointGeometry)
self.tool.rb.setColor(self.settings.getColor())
self.tool.rb.setWidth(3)
self.tool.rb.addPoint(point)
self.drawShape = 'XYpoint'
self.draw()
def drawDMSPoint(self):
point, ok = DMSDialog().getPoint()
self.XYcrs = QgsCoordinateReferenceSystem(4326)
if ok:
if point.x() == 0 and point.y() == 0:
QMessageBox.critical(
self.iface.mainWindow(),
self.tr('Error'), self.tr('Invalid input !'))
else:
self.drawPoint()
self.tool.rb = QgsRubberBand(
self.iface.mapCanvas(), QgsWkbTypes.PointGeometry)
self.tool.rb.setColor(self.settings.getColor())
self.tool.rb.setWidth(3)
self.tool.rb.addPoint(point)
self.drawShape = 'XYpoint'
self.draw()
def drawLine(self):
if self.tool:
self.tool.reset()
self.tool = DrawLine(self.iface, self.settings.getColor())
self.tool.setAction(self.actions[1])
self.tool.selectionDone.connect(self.draw)
self.tool.move.connect(self.updateSB)
self.iface.mapCanvas().setMapTool(self.tool)
self.drawShape = 'line'
self.toolname = 'drawLine'
self.resetSB()
def drawRect(self):
if self.tool:
self.tool.reset()
self.tool = DrawRect(self.iface, self.settings.getColor())
self.tool.setAction(self.actions[2])
self.tool.selectionDone.connect(self.draw)
self.tool.move.connect(self.updateSB)
self.iface.mapCanvas().setMapTool(self.tool)
self.drawShape = 'polygon'
self.toolname = 'drawRect'
self.resetSB()
def drawCircle(self):
if self.tool:
self.tool.reset()
self.tool = DrawCircle(self.iface, self.settings.getColor(), 40)
self.tool.setAction(self.actions[3])
self.tool.selectionDone.connect(self.draw)
self.tool.move.connect(self.updateSB)
self.iface.mapCanvas().setMapTool(self.tool)
self.drawShape = 'polygon'
self.toolname = 'drawCircle'
self.resetSB()
def drawPolygon(self):
if self.tool:
self.tool.reset()
self.tool = DrawPolygon(self.iface, self.settings.getColor())
self.tool.setAction(self.actions[4])
self.tool.selectionDone.connect(self.draw)
self.tool.move.connect(self.updateSB)
self.iface.mapCanvas().setMapTool(self.tool)
self.drawShape = 'polygon'
self.toolname = 'drawPolygon'
self.resetSB()
def drawBuffer(self):
self.bGeom = None
if self.tool:
self.tool.reset()
self.tool = SelectPoint(self.iface, self.settings.getColor())
self.actions[5].setIcon(
QIcon(':/plugins/Qgeric/resources/icon_DrawT.png'))
self.actions[5].setText(
self.tr('Buffer drawing tool on the selected layer'))
self.actions[5].triggered.disconnect()
self.actions[5].triggered.connect(self.drawBuffer)
self.actions[5].menu().actions()[0].setIcon(
QIcon(':/plugins/Qgeric/resources/icon_DrawTP.png'))
self.actions[5].menu().actions()[0].setText(
self.tr('Polygon buffer drawing tool on the selected layer'))
self.actions[5].menu().actions()[0].triggered.disconnect()
self.actions[5].menu().actions()[0].triggered.connect(
self.drawPolygonBuffer)
self.tool.setAction(self.actions[5])
self.tool.select.connect(self.selectBuffer)
self.tool.selectionDone.connect(self.draw)
self.iface.mapCanvas().setMapTool(self.tool)
self.drawShape = 'polygon'
self.toolname = 'drawBuffer'
self.resetSB()
def drawPolygonBuffer(self):
self.bGeom = None
if self.tool:
self.tool.reset()
self.tool = DrawPolygon(self.iface, self.settings.getColor())
self.actions[5].setIcon(
QIcon(':/plugins/Qgeric/resources/icon_DrawTP.png'))
self.actions[5].setText(
self.tr('Polygon buffer drawing tool on the selected layer'))
self.actions[5].triggered.disconnect()
self.actions[5].triggered.connect(self.drawPolygonBuffer)
self.actions[5].menu().actions()[0].setIcon(
QIcon(':/plugins/Qgeric/resources/icon_DrawT.png'))
self.actions[5].menu().actions()[0].setText(
self.tr('Buffer drawing tool on the selected layer'))
self.actions[5].menu().actions()[0].triggered.disconnect()
self.actions[5].menu().actions()[0].triggered.connect(self.drawBuffer)
self.tool.setAction(self.actions[5])
self.tool.selectionDone.connect(self.selectBuffer)
self.iface.mapCanvas().setMapTool(self.tool)
self.drawShape = 'polygon'
self.toolname = 'drawBuffer'
self.resetSB()
def showSettingsWindow(self):
self.settings.settingsChanged.connect(self.settingsChangedSlot)
self.settings.show()
# triggered when a setting is changed
def settingsChangedSlot(self):
if self.tool:
self.tool.rb.setColor(self.settings.getColor())
def resetSB(self):
message = {
'drawPoint': 'Left click to place a point.',
'drawLine': 'Left click to place points. Right click to confirm.',
'drawRect': 'Maintain the left click to draw a rectangle.',
'drawCircle': 'Maintain the left click to draw a circle. \
Simple Left click to give a perimeter.',
'drawPolygon': 'Left click to place points. Right click to \
confirm.',
'drawBuffer': 'Select a vector layer in the Layer Tree, \
then select an entity on the map.'
}
self.sb.showMessage(self.tr(message[self.toolname]))
def updateSB(self):
g = self.geomTransform(
self.tool.rb.asGeometry(),
self.iface.mapCanvas().mapSettings().destinationCrs(),
QgsCoordinateReferenceSystem(2154))
if self.toolname == 'drawLine':
if g.length() >= 0:
self.sb.showMessage(
self.tr('Length') + ': ' + str("%.2f" % g.length()) + " m")
else:
self.sb.showMessage(self.tr('Length')+': '+"0 m")
else:
if g.area() >= 0:
self.sb.showMessage(
self.tr('Area')+': '+str("%.2f" % g.area())+" m"+u'²')
else:
self.sb.showMessage(self.tr('Area')+': '+"0 m"+u'²')
self.iface.mapCanvas().mapSettings().destinationCrs().authid()
def geomTransform(self, geom, crs_orig, crs_dest):
g = QgsGeometry(geom)
crsTransform = QgsCoordinateTransform(
crs_orig, crs_dest, QgsCoordinateTransformContext()) # which context ?
g.transform(crsTransform)
return g
def selectBuffer(self):
rb = self.tool.rb
if isinstance(self.tool, DrawPolygon):
rbSelect = self.tool.rb
else:
rbSelect = self.tool.rbSelect
layer = self.iface.layerTreeView().currentLayer()
if layer is not None and layer.type() == QgsMapLayer.VectorLayer \
and self.iface.layerTreeView().currentNode().isVisible():
# rubberband reprojection
g = self.geomTransform(
rbSelect.asGeometry(),
self.iface.mapCanvas().mapSettings().destinationCrs(),
layer.crs())
features = layer.getFeatures(QgsFeatureRequest(g.boundingBox()))
rbGeom = []
for feature in features:
geom = feature.geometry()
try:
if g.intersects(geom):
rbGeom.append(feature.geometry())
except:
# there's an error but it intersects
# fix_print_with_import
print('error with '+layer.name()+' on '+str(feature.id()))
rbGeom.append(feature.geometry())
if len(rbGeom) > 0:
for geometry in rbGeom:
if rbGeom[0].combine(geometry) is not None:
if self.bGeom is None:
self.bGeom = geometry
else:
self.bGeom = self.bGeom.combine(geometry)
rb.setToGeometry(self.bGeom, layer)
if isinstance(self.tool, DrawPolygon):
self.draw()
def draw(self):
rb = self.tool.rb
g = rb.asGeometry()
ok = True
warning = False
errBuffer_noAtt = False
errBuffer_Vertices = False
layer = self.iface.layerTreeView().currentLayer()
if self.toolname == 'drawBuffer':
if self.bGeom is None:
warning = True
errBuffer_noAtt = True
else:
perim, ok = QInputDialog.getDouble(
self.iface.mainWindow(), self.tr('Perimeter'),
self.tr('Give a perimeter in m:')
+ '\n'+self.tr('(works only with metric crs)'),
min=0)
g = self.bGeom.buffer(perim, 40)
rb.setToGeometry(g, QgsVectorLayer(
"Polygon?crs="+layer.crs().authid(), "", "memory"))
if g.length() == 0 and ok:
warning = True
errBuffer_Vertices = True
if self.toolname == 'drawCopies':
if g.length() < 0:
warning = True
errBuffer_noAtt = True
if ok and not warning:
name = ''
ok = True
add = False
index = 0
layers = []
while not name.strip() and not add and ok:
dlg = QDrawLayerDialog(self.iface, self.drawShape)
name, add, index, layers, ok = dlg.getName(
self.iface, self.drawShape)
if ok and not warning:
layer = None
if add:
layer = layers[index]
if self.drawShape in ['point', 'XYpoint']:
g = g.centroid()
else:
if self.drawShape == 'point':
layer = QgsVectorLayer("Point?crs="+self.iface.mapCanvas().mapSettings().destinationCrs().authid()+"&field="+self.tr('Drawings')+":string(255)", name, "memory")
g = g.centroid() # force geometry as point
elif self.drawShape == 'XYpoint':
layer = QgsVectorLayer("Point?crs="+self.XYcrs.authid()+"&field="+self.tr('Drawings')+":string(255)", name, "memory")
g = g.centroid()
elif self.drawShape == 'line':
layer = QgsVectorLayer("LineString?crs="+self.iface.mapCanvas().mapSettings().destinationCrs().authid()+"&field="+self.tr('Drawings')+":string(255)", name, "memory")
# fix_print_with_import
print("LineString?crs="+self.iface.mapCanvas().mapSettings().destinationCrs().authid()+"&field="+self.tr('Drawings')+":string(255)")
else:
layer = QgsVectorLayer("Polygon?crs="+self.iface.mapCanvas().mapSettings().destinationCrs().authid()+"&field="+self.tr('Drawings')+":string(255)", name, "memory")
layer.startEditing()
symbols = layer.renderer().symbols(QgsRenderContext()) # todo which context ?
symbols[0].setColor(self.settings.getColor())
feature = QgsFeature()
feature.setGeometry(g)
feature.setAttributes([name])
layer.dataProvider().addFeatures([feature])
layer.commitChanges()
if not add:
pjt = QgsProject.instance()
pjt.addMapLayer(layer, False)
if pjt.layerTreeRoot().findGroup(self.tr('Drawings')) is None:
pjt.layerTreeRoot().insertChildNode(
0, QgsLayerTreeGroup(self.tr('Drawings')))
group = pjt.layerTreeRoot().findGroup(
self.tr('Drawings'))
group.insertLayer(0, layer)
self.iface.layerTreeView().refreshLayerSymbology(layer.id())
self.iface.mapCanvas().refresh()
else:
if warning:
if errBuffer_noAtt:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('You didn\'t click on a layer\'s attribute !'))
elif errBuffer_Vertices:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('You must give a non-null value for a \
point\'s or line\'s perimeter !'))
else:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('There is no selected layer, or it is not \
vector nor visible !'))
self.tool.reset()
self.resetSB()
self.bGeom = None
class vectorLayerPropertyDlg(QDialog):
'''
classdocs
'''
def __init__(self, parent, layer):
'''
Constructor
'''
QDialog.__init__(self, parent)
self.ui = Ui_VectorLayerProPertyDialog()
self.ui.setupUi(self)
self.ui.txtLayerName.setText(layer.name())
self.ui.txtLayerSource.setText(layer.source())
self.ui.txtCrs.setText(layer.crs().authid() + " - " +
layer.crs().description())
self.ui.btnCrsSelect.clicked.connect(self.selectCrs)
self.mCrs = layer.crs()
self.vLayer = layer
self.ui.mOptionsListWidget.currentRowChanged.connect(
self.changeStackWidget)
''' init RenderV2 Widget'''
self.mRendererDialog = QgsRendererV2PropertiesDialog(
self.vLayer, QgsStyleV2.defaultStyle(), True)
self.ui.stackedWidget.insertWidget(1, self.mRendererDialog)
self.ui.buttonBox.accepted.connect(self.OK)
frame_Label = QFrame()
verticalLayout_Label = QVBoxLayout(frame_Label)
self.mLabelWidget = QgsFieldExpressionWidget()
self.mLabelWidget.setLayer(layer)
verticalLayout_Label.addWidget(self.mLabelWidget)
spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
verticalLayout_Label.addItem(spacerItem)
frame_Label.setLayout(verticalLayout_Label)
self.ui.stackedWidget.insertWidget(2, frame_Label)
# self.ui.buttonBox.accepted.connect(self.OK)
def selectCrs(self):
projectionDlg = QgsGenericProjectionSelector(self)
projectionDlg.setSelectedAuthId(self.mCrs.authid())
if projectionDlg.exec_():
self.mCrs = QgsCoordinateReferenceSystem(
projectionDlg.selectedCrsId(),
QgsCoordinateReferenceSystem.InternalCrsId)
self.ui.txtCrs.setText(self.mCrs.authid() + " - " +
self.mCrs.description())
def changeStackWidget(self, index):
self.ui.stackedWidget.setCurrentIndex(index)
def OK(self):
self.vLayer.setCrs(self.mCrs)
self.mRendererDialog.apply()
self.vLayer.triggerRepaint()
if self.ui.stackedWidget.currentIndex(
) == 2 and self.mLabelWidget.currentText() != "":
self.vLayer.setCustomProperty("labeling", "pal")
self.vLayer.setCustomProperty("labeling/enabled", "true")
self.vLayer.setCustomProperty("labeling/fontFamily", "Arial")
self.vLayer.setCustomProperty("labeling/fontSize", "8")
self.vLayer.setCustomProperty("labeling/fieldName",
self.mLabelWidget.currentText())
# palLayerSetting = QgsPalLayerSettings()
# palLayerSetting.readFromLayer(self.vLayer)
# palLayerSetting.enabled = True
# palLayerSetting.fieldName = self.mLabelWidget.currentText()
# palLayerSetting.isExpression = True
if self.vLayer.geometryType() == QGis.Line:
self.vLayer.setCustomProperty("labeling/placement", "2")
self.vLayer.setCustomProperty(
"labeling/placementFlags",
str(QgsPalLayerSettings.AboveLine))
# palLayerSetting.placement = QgsPalLayerSettings.Line
# palLayerSetting.placementFlags = QgsPalLayerSettings.AboveLine
elif self.vLayer.geometryType() == QGis.Point:
self.vLayer.setCustomProperty("labeling/placement", "0")
self.vLayer.setCustomProperty(
"labeling/placementFlags",
str(QgsPalLayerSettings.AroundPoint))
# self.vLayer.setCustomProperty("labeling/placementFlags", "0")
# palLayerSetting.placement = QgsPalLayerSettings.Points
# palLayerSetting.placementFlags = QgsPalLayerSettings.AroundPoint
else:
self.vLayer.setCustomProperty("labeling/placement", "3")
self.vLayer.setCustomProperty(
"labeling/placementFlags",
str(QgsPalLayerSettings.AboveLine))
# palLayerSetting.placement = QgsPalLayerSettings.PolygonBoundary
# palLayerSetting.placementFlags = QgsPalLayerSettings.AboveLine
# palLayerSetting.setDataDefinedProperty(QgsPalLayerSettings.Size, True, True, '8', "")
# palLayerSetting.writeToLayer(self.vLayer)
elif self.ui.stackedWidget.currentIndex(
) == 2 and self.mLabelWidget.currentText() == "":
self.vLayer.setCustomProperty("labeling", "")
QgsProject.instance().dirty(True)
QDialog.accept(self)
def runAlgorithm(self):
start = timeit.default_timer()
self._id = str(np.random.randint(1, 5000))
logMessageFile = open(
os.path.dirname(__file__) + "/logLCP" + self._id + ".txt", "w")
logMessage = "LCPNetwork plugin init - loading points and base raster layers with id: " + self._id
QgsMessageLog.logMessage(logMessage, tag="LCPNetwork", level=Qgis.Info)
logMessageFile.write(logMessage + "\n")
origins, destinations = self.loadPoints()
baseRaster = self.loadBaseRaster()
logMessage = "computing " + str(
origins.featureCount()) + " origin points towards " + str(
destinations.featureCount()) + " destinations"
QgsMessageLog.logMessage(logMessage, tag="LCPNetwork", level=Qgis.Info)
logMessageFile.write(logMessage + "\n")
self.transform = baseRaster.GetGeoTransform()
self.projection = baseRaster.GetProjection()
nodata = baseRaster.GetRasterBand(1).GetNoDataValue()
logMessage = "loading cost map with nodata value " + str(nodata)
QgsMessageLog.logMessage(logMessage, tag="LCPNetwork", level=Qgis.Info)
logMessageFile.write(logMessage + "\n")
topLeft = QgsPointXY(self.transform[0], self.transform[3])
pointsListO = []
for point in origins.getFeatures():
pointsListO.append(point.geometry().asPoint())
pointsListD = []
for point in destinations.getFeatures():
pointsListD.append(point.geometry().asPoint())
## create the list of lcps
lcps = []
numThreads = os.cpu_count()
logMessage = "creating " + str(numThreads) + " threads"
QgsMessageLog.logMessage(logMessage, tag="LCPNetwork", level=Qgis.Info)
logMessageFile.write(logMessage + "\n")
pool = futures.ThreadPoolExecutor(numThreads)
index = 0
results = []
for source in pointsListO:
results.append(
pool.submit(self.computeOnePath, source, index, start,
baseRaster, pointsListD, lcps, logMessageFile))
index = index + 1
for future in futures.as_completed(results):
logMessageFile.write(future.result() + "\n")
logMessage = "all lcps computed at time: " + str(
"%.2f" % (timeit.default_timer() - start))
QgsMessageLog.logMessage(logMessage, tag="LCPNetwork", level=Qgis.Info)
logMessageFile.write(logMessage + "\n")
# same CRS than base raster cost map
crs = QgsCoordinateReferenceSystem()
crs.createFromString(baseRaster.GetProjection())
for i in range(index):
outputName = os.path.dirname(
__file__) + "/distances" + self._id + "_" + str(i) + ".tif"
newRasterQGIS = QgsRasterLayer(
outputName, "distances" + self._id + "_" + str(i))
newRasterQGIS.setContrastEnhancement(
QgsContrastEnhancement.StretchToMinimumMaximum)
newRasterQGIS.setCrs(crs)
QgsProject.instance().addMapLayer(newRasterQGIS)
# add the list of lcps to the network layer
network = self.iface.addVectorLayer("LineString?crs=" + crs.authid(),
"least cost path network",
"memory")
network.dataProvider().addFeatures(lcps)
logMessage = "LCPNetwork plugin finished! time (sec.): " + str(
"%.2f" % (timeit.default_timer() - start))
QgsMessageLog.logMessage(logMessage, tag="LCPNetwork", level=Qgis.Info)
logMessageFile.write(logMessage + "\n")
logMessageFile.close()
""""
https://docs.qgis.org/2.18/en/docs/pyqgis_developer_cookbook/crs.html
"""
from qgis.core import QgsCoordinateReferenceSystem
from osgeo import osr
if __name__ == '__console__':
print("-----------------------------------------------\n\n")
# PostGIS SRID 4326 is allocated for WGS84
# If not specified otherwise in second parameter, PostGIS SRID is used by default.
crs = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.PostgisCrsId)
print("Valid: ", crs.isValid())
print("QGIS CRS ID:", crs.srsid())
print("EPSG ID:", crs.authid())
print("Description:", crs.description())
print("Projection Acronym:", crs.projectionAcronym())
print("Ellipsoid Acronym:", crs.ellipsoidAcronym())
print("Proj4 String:", crs.toProj4())
# check whether it's geographic or projected coordinate system
print("Is geographic:", crs.geographicFlag())
# check type of map units in this CRS (values defined in QGis::units enum)
print("Map units:", crs.mapUnits())
print("-----------------------------------------------\n\n")
wkt = '''GEOGCS["WGS84", DATUM["WGS84", SPHEROID["WGS84", 6378137.0, 298.257223563]],
PRIMEM["Greenwich", 0.0],
UNIT["degree", 0.017453292519943295],
AXIS["Longitude", EAST], AXIS["Latitude", NORTH]]'''
crs = QgsCoordinateReferenceSystem(wkt)
print("Valid: ", crs.isValid())
class Dialog(QDialog, Ui_Dialog):
def __init__(self, iface):
QDialog.__init__(self, iface.mainWindow())
self.iface = iface
self.setupUi(self)
self.toolOut.setEnabled(False)
self.toolOut.setVisible(False)
self.outShape.setEnabled(False)
self.outShape.setVisible(False)
self.label_2.setVisible(False)
self.label_2.setEnabled(False)
self.setWindowTitle(self.tr("Define current projection"))
self.buttonOk = self.buttonBox_2.button(QDialogButtonBox.Ok)
QObject.connect(self.btnProjection, SIGNAL("clicked()"), self.outProjFile)
QObject.connect(self.inShape, SIGNAL("currentIndexChanged(QString)"), self.updateProj1)
QObject.connect(self.cmbLayer, SIGNAL("currentIndexChanged(QString)"), self.updateProj2)
# populate layer list
self.progressBar.setValue(0)
layers = ftools_utils.getLayerNames([QGis.Point, QGis.Line, QGis.Polygon])
self.inShape.addItems(layers)
self.cmbLayer.addItems(layers)
self.crs = None
def updateProj1(self, layerName):
self.inRef.clear()
tempLayer = ftools_utils.getVectorLayerByName(layerName)
crs = tempLayer.dataProvider().crs()
if crs.isValid():
self.inRef.insert(crs.authid() + " - " + crs.description())
else:
self.inRef.insert(self.tr("Missing or invalid CRS"))
def updateProj2(self, layerName):
self.outRef.clear()
tempLayer = ftools_utils.getVectorLayerByName(layerName)
crs = tempLayer.dataProvider().crs()
if crs.isValid():
self.outRef.insert(crs.authid() + " - " + crs.description())
else:
self.outRef.insert(self.tr("Missing or invalid CRS"))
def accept(self):
self.buttonOk.setEnabled(False)
if self.inShape.currentText() == "":
QMessageBox.information(self, self.tr("Define current projection"), self.tr("No input shapefile specified"))
elif self.txtProjection.text() == "" and self.rdoProjection.isChecked():
QMessageBox.information(self, self.tr("Define current projection"), self.tr("Please specify spatial reference system"))
elif self.cmbLayer.currentText() == "" and self.rdoLayer.isChecked():
QMessageBox.information(self, self.tr("Define current projection"), self.tr("Please specify spatial reference system"))
else:
self.progressBar.setValue(5)
inName = self.inShape.currentText()
self.progressBar.setValue(10)
vLayer = ftools_utils.getVectorLayerByName(inName)
self.progressBar.setValue(30)
if vLayer == "Error":
QMessageBox.information(self, self.tr("Define current projection"), self.tr("Cannot define projection for PostGIS data...yet!"))
else:
srsDefine = None
if self.rdoProjection.isChecked():
srsDefine = self.crs
else:
destLayer = ftools_utils.getVectorLayerByName(self.cmbLayer.currentText())
srsDefine = destLayer.crs()
if srsDefine == vLayer.crs():
responce = QMessageBox.question(self, self.tr("Define current projection"),
self.tr("Identical output spatial reference system chosen\n\nAre you sure you want to proceed?"),
QMessageBox.Yes, QMessageBox.No, QMessageBox.NoButton)
if responce == QMessageBox.No:
self.progressBar.setValue(0)
self.buttonOk.setEnabled(True)
return
provider = vLayer.dataProvider()
self.progressBar.setValue(35)
inPath = provider.dataSourceUri()
p = re.compile("\|.*")
inPath = p.sub("", inPath)
self.progressBar.setValue(40)
if inPath.endswith(".shp"):
inPath = inPath[:-4]
self.progressBar.setValue(55)
if not srsDefine.isValid():
QMessageBox.information(self, self.tr("Define current projection"), self.tr("Output spatial reference system is not valid"))
else:
self.progressBar.setValue(60)
outputWkt = srsDefine.toWkt()
self.progressBar.setValue(65)
outputFile = QFile(inPath + ".prj")
outputFile.open(QIODevice.WriteOnly | QIODevice.Text)
outputPrj = QTextStream(outputFile)
outputPrj << outputWkt
outputPrj.flush()
outputFile.close()
self.progressBar.setValue(70)
checkFile = QFile(inPath + ".qpj")
if checkFile.exists():
checkFile.open(QIODevice.WriteOnly | QIODevice.Text)
outputPrj = QTextStream(checkFile)
outputPrj << outputWkt
outputPrj.flush()
checkFile.close()
self.progressBar.setValue(95)
vLayer.setCrs(srsDefine)
self.progressBar.setValue(100)
QMessageBox.information(self, self.tr("Define current projection"),
self.tr("Defined Projection For:\n%s.shp") % (inPath))
self.progressBar.setValue(0)
self.buttonOk.setEnabled(True)
def outProjFile(self):
header = "Define layer CRS:"
sentence1 = self.tr("Please select the projection system that defines the current layer.")
sentence2 = self.tr("Layer CRS information will be updated to the selected CRS.")
projSelector = QgsGenericProjectionSelector(self)
projSelector.setMessage("<h2>%s</h2>%s <br/> %s" % (header, sentence1, sentence2))
if projSelector.exec_():
self.crs = QgsCoordinateReferenceSystem(projSelector.selectedCrsId(), QgsCoordinateReferenceSystem.InternalCrsId)
print "AUTHID", projSelector.selectedAuthId()
if len(projSelector.selectedAuthId()) == 0:
QMessageBox.information(self, self.tr("Export to new projection"), self.tr("No Valid CRS selected"))
return
else:
self.txtProjection.clear()
self.txtProjection.insert(self.crs.authid() + " - " + self.crs.description())
else:
return
class rasterLayerPropertyDlg(QDialog):
'''
classdocs
'''
def __init__(self, parent, layer):
'''
Constructor
'''
QDialog.__init__(self, parent)
self.resize(200, 200)
self.rasterLayer = layer
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(sizePolicy)
verticalLayout = QVBoxLayout(self)
verticalLayout.setObjectName("verticalLayout")
stackedWidget = QStackedWidget(self)
stackedWidget.setObjectName("stackedWidget")
pageRender = QWidget(stackedWidget)
pageRender.setObjectName("pageRender")
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(pageRender.sizePolicy().hasHeightForWidth())
pageRender.setSizePolicy(sizePolicy)
horizontalLayout = QHBoxLayout(pageRender)
horizontalLayout.setObjectName("horizontalLayout")
frameRender = QFrame(pageRender)
frameRender.setObjectName("frameRender")
frameRender.setFrameShape(QFrame.StyledPanel)
frameRender.setFrameShadow(QFrame.Raised)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(frameRender.sizePolicy().hasHeightForWidth())
frameRender.setSizePolicy(sizePolicy)
self.vLayoutFrameRender = QVBoxLayout(frameRender)
self.vLayoutFrameRender.setObjectName("vLayoutFrameRender")
horizontalLayout.addWidget(frameRender)
self.cmbRendererType = ComboBoxPanel(frameRender)
self.cmbRendererType.Caption = "Render Type"
self.cmbRendererType.LabelWidth = 70
self.cmbRendererType.Items = ["Mutiband color", "Paletted", "Singleband gray", "Singleband pseudocolor"]
self.connect(self.cmbRendererType, SIGNAL("Event_0"), self.cmbRendererType_currentIndexChanged)
self.vLayoutFrameRender.addWidget(self.cmbRendererType)
self.gbRenderer = GroupBox(frameRender)
self.gbRenderer.Caption = self.cmbRendererType.SelectedItem
self.vLayoutFrameRender.addWidget(self.gbRenderer)
self.qgsMultiBandColorRendererWidget = QgsMultiBandColorRendererWidget(self.rasterLayer)
self.qgsPalettedRendererWidget = QgsPalettedRendererWidget(self.rasterLayer)
self.qgsSingleBandGrayRendererWidget = QgsSingleBandGrayRendererWidget(self.rasterLayer)
self.qgsSingleBandPseudoColorRendererWidget = QgsSingleBandPseudoColorRendererWidget(self.rasterLayer)
self.gbRenderer.Add = self.qgsMultiBandColorRendererWidget
self.gbRenderer.Add = self.qgsPalettedRendererWidget
self.gbRenderer.Add = self.qgsSingleBandGrayRendererWidget
self.gbRenderer.Add = self.qgsSingleBandPseudoColorRendererWidget
self.qgsPalettedRendererWidget.setVisible(False)
self.qgsSingleBandGrayRendererWidget.setVisible(False)
self.qgsSingleBandPseudoColorRendererWidget.setVisible(False)
stackedWidget.addWidget(pageRender)
# page_2 = QWidget()
# page_2.setObjectName("page_2")
# stackedWidget.addWidget(page_2)
verticalLayout.addWidget(stackedWidget)
buttonBox = QDialogButtonBox(self)
buttonBox.setObjectName("buttonBox")
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok | QDialogButtonBox.Apply)
btnApply = buttonBox.button(QDialogButtonBox.Apply)
btnApply.clicked.connect(self.btnApply_clicked)
verticalLayout.addWidget(buttonBox)
# retranslateUi(Dialog)
buttonBox.accepted.connect(self.OK)
buttonBox.rejected.connect(self.reject)
if self.rasterLayer.renderer().bandCount() == 1:
self.cmbRendererType.SelectedIndex = 2
elif self.rasterLayer.renderer().bandCount() > 1:
self.cmbRendererType.SelectedIndex = 0
# QObject.connect(buttonBox, SIGNAL("accepted()"), self, SLOT(accept()))
# QObject.connect(buttonBox, SIGNAL("rejected()"), self, SLOT(reject()))
def cmbRendererType_currentIndexChanged(self):
if self.cmbRendererType.SelectedIndex == 0:
self.qgsPalettedRendererWidget.setVisible(False)
self.qgsSingleBandGrayRendererWidget.setVisible(False)
self.qgsSingleBandPseudoColorRendererWidget.setVisible(False)
# self.resize(200, 200)
self.qgsMultiBandColorRendererWidget.setVisible(True)
elif self.cmbRendererType.SelectedIndex == 1:
self.qgsMultiBandColorRendererWidget.setVisible(False)
self.qgsSingleBandGrayRendererWidget.setVisible(False)
self.qgsSingleBandPseudoColorRendererWidget.setVisible(False)
# self.resize(200, 200)
self.qgsPalettedRendererWidget.setVisible(True)
elif self.cmbRendererType.SelectedIndex == 2:
self.qgsMultiBandColorRendererWidget.setVisible(False)
self.qgsPalettedRendererWidget.setVisible(False)
self.qgsSingleBandPseudoColorRendererWidget.setVisible(False)
# self.resize(200, 200)
self.qgsSingleBandGrayRendererWidget.setVisible(True)
else:
self.qgsMultiBandColorRendererWidget.setVisible(False)
self.qgsPalettedRendererWidget.setVisible(False)
self.qgsSingleBandGrayRendererWidget.setVisible(False)
self.qgsSingleBandPseudoColorRendererWidget.setVisible(True)
self.resize(200, 200)
self.gbRenderer.Caption = self.cmbRendererType.SelectedItem
def selectCrs(self):
projectionDlg = QgsGenericProjectionSelector(self)
projectionDlg.setSelectedAuthId(self.mCrs.authid())
if projectionDlg.exec_():
self.mCrs = QgsCoordinateReferenceSystem(projectionDlg.selectedCrsId(), QgsCoordinateReferenceSystem.InternalCrsId)
self.ui.txtCrs.setText(self.mCrs.authid() + " - " + self.mCrs.description())
def changeStackWidget(self, index):
self.ui.stackedWidget.setCurrentIndex(index)
def btnApply_clicked(self):
if self.cmbRendererType.SelectedIndex == 0:
self.rasterLayer.setRenderer(self.qgsMultiBandColorRendererWidget.renderer())
elif self.cmbRendererType.SelectedIndex == 1:
self.rasterLayer.setRenderer(self.qgsPalettedRendererWidget.renderer())
elif self.cmbRendererType.SelectedIndex == 2:
self.rasterLayer.setRenderer(self.qgsSingleBandGrayRendererWidget.renderer())
else:
self.rasterLayer.setRenderer(self.qgsSingleBandPseudoColorRendererWidget.renderer())
self.rasterLayer.triggerRepaint()
def OK(self):
self.btnApply_clicked()
QDialog.accept(self)
class QGISRedLayerManagementDialog(QDialog, FORM_CLASS):
# Common variables
iface = None
NetworkName = ""
ProjectDirectory = ""
def __init__(self, parent=None):
"""Constructor."""
super(QGISRedLayerManagementDialog, self).__init__(parent)
self.setupUi(self)
self.btAccept.clicked.connect(self.accept)
self.btSelectCRS.clicked.connect(self.selectCRS)
self.btPipes.clicked.connect(lambda: self.createElement("Pipes"))
self.btJunctions.clicked.connect(
lambda: self.createElement("Junctions"))
self.btTanks.clicked.connect(lambda: self.createElement("Tanks"))
self.btReservoirs.clicked.connect(
lambda: self.createElement("Reservoirs"))
self.btValves.clicked.connect(lambda: self.createElement("Valves"))
self.btPumps.clicked.connect(lambda: self.createElement("Pumps"))
self.btDemands.clicked.connect(
lambda: self.createElement("Demands", True))
self.btSources.clicked.connect(
lambda: self.createElement("Sources", True))
self.btIsolatedValves.clicked.connect(
lambda: self.createElement("IsolationValves", True))
self.btHydrants.clicked.connect(
lambda: self.createElement("Hydrants", True))
self.btPurgeValves.clicked.connect(
lambda: self.createElement("WashoutValves", True))
self.btAirReleases.clicked.connect(
lambda: self.createElement("AirReleaseValves", True))
self.btConnections.clicked.connect(
lambda: self.createElement("ServiceConnections", True))
self.btMeters.clicked.connect(
lambda: self.createElement("Meters", True))
def config(self, ifac, direct, netw, parent):
self.iface = ifac
self.parent = parent
utils = QGISRedUtils(direct, netw, ifac)
self.crs = utils.getProjectCrs()
self.originalCrs = self.crs
self.tbCRS.setText(self.crs.description())
self.NetworkName = netw
self.ProjectDirectory = direct
self.setProperties()
def setProperties(self):
dirList = os.listdir(self.ProjectDirectory)
# Visibilities
self.btPipes.setVisible(not self.NetworkName + "_Pipes.shp" in dirList)
self.btJunctions.setVisible(not self.NetworkName +
"_Junctions.shp" in dirList)
self.btTanks.setVisible(not self.NetworkName + "_Tanks.shp" in dirList)
self.btReservoirs.setVisible(not self.NetworkName +
"_Reservoirs.shp" in dirList)
self.btValves.setVisible(not self.NetworkName +
"_Valves.shp" in dirList)
self.btPumps.setVisible(not self.NetworkName + "_Pumps.shp" in dirList)
self.btDemands.setVisible(not self.NetworkName +
"_Demands.shp" in dirList)
self.btSources.setVisible(not self.NetworkName +
"_Sources.shp" in dirList)
self.btIsolatedValves.setVisible(not self.NetworkName +
"_IsolationValves.shp" in dirList)
self.btHydrants.setVisible(not self.NetworkName +
"_Hydrants.shp" in dirList)
self.btPurgeValves.setVisible(not self.NetworkName +
"_WashoutValves.shp" in dirList)
self.btAirReleases.setVisible(not self.NetworkName +
"_AirReleaseValves.shp" in dirList)
self.btConnections.setVisible(not self.NetworkName +
"_ServiceConnections.shp" in dirList)
self.btMeters.setVisible(not self.NetworkName +
"_Meters.shp" in dirList)
# Enables
self.cbDemands.setEnabled(self.NetworkName + "_Demands.shp" in dirList)
self.cbSources.setEnabled(self.NetworkName + "_Sources.shp" in dirList)
self.cbIsolatedValves.setEnabled(self.NetworkName +
"_IsolationValves.shp" in dirList)
self.cbHydrants.setEnabled(self.NetworkName +
"_Hydrants.shp" in dirList)
self.cbPurgeValves.setEnabled(self.NetworkName +
"_WashoutValves.shp" in dirList)
self.cbAirReleases.setEnabled(self.NetworkName +
"_AirReleaseValves.shp" in dirList)
self.cbConnections.setEnabled(self.NetworkName +
"_ServiceConnections.shp" in dirList)
self.cbMeters.setEnabled(self.NetworkName + "_Meters.shp" in dirList)
# Los básicos: Enables and checked
utils = QGISRedUtils(self.ProjectDirectory, self.NetworkName,
self.iface)
hasLayer = utils.isLayerOpened("Pipes")
self.cbPipes.setChecked(hasLayer)
self.cbPipes.setEnabled(self.NetworkName + "_Pipes.shp" in dirList
and not hasLayer)
hasLayer = utils.isLayerOpened("Junctions")
self.cbJunctions.setChecked(hasLayer)
self.cbJunctions.setEnabled(
self.NetworkName + "_Junctions.shp" in dirList and not hasLayer)
hasLayer = utils.isLayerOpened("Tanks")
self.cbTanks.setChecked(hasLayer)
self.cbTanks.setEnabled(self.NetworkName + "_Tanks.shp" in dirList
and not hasLayer)
hasLayer = utils.isLayerOpened("Reservoirs")
self.cbReservoirs.setChecked(hasLayer)
self.cbReservoirs.setEnabled(
self.NetworkName + "_Reservoirs.shp" in dirList and not hasLayer)
hasLayer = utils.isLayerOpened("Valves")
self.cbValves.setChecked(hasLayer)
self.cbValves.setEnabled(self.NetworkName + "_Valves.shp" in dirList
and not hasLayer)
hasLayer = utils.isLayerOpened("Pumps")
self.cbPumps.setChecked(hasLayer)
self.cbPumps.setEnabled(self.NetworkName + "_Pumps.shp" in dirList
and not hasLayer)
# Checked
self.cbDemands.setChecked(utils.isLayerOpened("Demands"))
self.cbSources.setChecked(utils.isLayerOpened("Sources"))
self.cbIsolatedValves.setChecked(
utils.isLayerOpened("IsolationValves"))
self.cbHydrants.setChecked(utils.isLayerOpened("Hydrants"))
self.cbPurgeValves.setChecked(utils.isLayerOpened("WashoutValves"))
self.cbAirReleases.setChecked(utils.isLayerOpened("AirReleaseValves"))
self.cbConnections.setChecked(
utils.isLayerOpened("ServiceConnections"))
self.cbMeters.setChecked(utils.isLayerOpened("Meters"))
def selectCRS(self):
projSelector = QgsGenericProjectionSelector()
if projSelector.exec_():
crsId = projSelector.crs().srsid()
if not crsId == 0:
self.crs = QgsCoordinateReferenceSystem()
self.crs.createFromId(
crsId, QgsCoordinateReferenceSystem.InternalCrsId)
self.tbCRS.setText(self.crs.description())
def getLayerPath(self, layer):
return QGISRedUtils().getLayerPath(layer)
def generatePath(self, folder, fileName):
return QGISRedUtils().generatePath(folder, fileName)
def getLayers(self):
return QGISRedUtils().getLayers()
def isInLegend(self, layerName):
openedLayers = self.getLayers()
for layer in openedLayers:
layerPath = self.generatePath(
self.ProjectDirectory,
self.NetworkName + "_" + layerName + ".shp")
if self.getLayerPath(layer) == layerPath:
return True
return False
def createElementsList(self):
if self.cbPipes.isChecked():
self.layers.append("Pipes")
if self.cbJunctions.isChecked():
self.layers.append("Junctions")
if self.cbTanks.isChecked():
self.layers.append("Tanks")
if self.cbReservoirs.isChecked():
self.layers.append("Reservoirs")
if self.cbValves.isChecked():
self.layers.append("Valves")
if self.cbPumps.isChecked():
self.layers.append("Pumps")
def createComplementaryList(self):
if self.cbDemands.isChecked():
self.layers.append("Demands")
if self.cbSources.isChecked():
self.layers.append("Sources")
if self.cbIsolatedValves.isChecked():
self.layers.append("Isolation Valves")
if self.cbHydrants.isChecked():
self.layers.append("Hydrants")
if self.cbPurgeValves.isChecked():
self.layers.append("Washout Valves")
if self.cbAirReleases.isChecked():
self.layers.append("AirRelease Valves")
if self.cbConnections.isChecked():
self.layers.append("Service Connections")
if self.cbMeters.isChecked():
self.layers.append("Meters")
def createElement(self, layerName, complementary=False):
layer = "" if complementary else layerName
complLayer = layerName if complementary else ""
# Process
QApplication.setOverrideCursor(Qt.WaitCursor)
resMessage = GISRed.CreateLayer(self.ProjectDirectory,
self.NetworkName, layer, complLayer)
QApplication.restoreOverrideCursor()
if resMessage == "True":
self.parent.openElementLayer(layerName)
elif resMessage == "False":
self.iface.messageBar().pushMessage(
"Warning",
"Some issues occurred in the process",
level=1,
duration=5)
else:
self.iface.messageBar().pushMessage("Error",
resMessage,
level=2,
duration=5)
self.close()
def accept(self):
self.layers = []
self.createElementsList()
self.createComplementaryList()
epsg = None
if not self.crs.srsid() == self.originalCrs.srsid():
epsg = self.crs.authid().replace("EPSG:", "")
self.parent.openRemoveSpecificLayers(self.layers, epsg)
self.close()
def getAuthority(crs):
if not isinstance(crs, QgsCoordinateReferenceSystem):
defCRS = "WKT:{}".format(crs)
crs = QgsCoordinateReferenceSystem(defCRS)
isProjected = not crs.isGeographic()
return {'auth': crs.authid(), 'isProjected': isProjected}
class GNSS3DCaptureDockWidget(QtGui.QDockWidget, FORM_CLASS):
closingPlugin = pyqtSignal()
def __init__(self, iface, parent=None):
"""Constructor."""
super(GNSS3DCaptureDockWidget, 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.setupUi(self)
self.iface = iface
self.initialize()
def closeEvent(self, event):
self.closingPlugin.emit()
event.accept()
def finishProcess(self):
self.capturePointGroupBox.setEnabled(False)
self.nameLineEdit.clear()
self.numberLineEdit.clear()
self.codeLineEdit.clear()
self.firstCoordinateLineEdit.clear()
self.secondCoordinateLineEdit.clear()
self.heightAntennaLineEdit.clear()
self.heightGpsLineEdit.clear()
self.heightGroundLineEdit.clear()
self.heightGeoidLineEdit.clear()
self.heightFromGeoidLineEdit.clear()
self.configurePushButton.setEnabled(True)
self.startPushButton.setEnabled(False)
self.finishPushButton.setEnabled(False)
def getGeoidInterpolatedValue(self, gpsLongitude, gpsLatitude):
geoidPoint = QgsPoint(gpsLongitude, gpsLatitude)
geoidPoint = self.crsOperationFromGpsToGeoid.transform(geoidPoint)
geoidHeight = constants.CONST_GNSS_3D_CAPTURE_GEOIDS_NO_VALUE
if not self.geoidModel.extent().contains(geoidPoint):
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("Point out of Geoid Model extension:\n",
self.geoidModelFileName)
msgBox.exec_()
return geoidHeight
firstCoordinate = geoidPoint.x()
secondCoordinate = geoidPoint.y()
dbl_column = (firstCoordinate - self.geoidMinimumFirstCoordinate
) / self.geoidStepFirstCoordinate
dbl_row = (secondCoordinate - self.geoidMaximumSecondCoordinate
) / self.geoidStepSecondCoordinate
inc_column = dbl_column - floor(dbl_column)
inc_row = dbl_row - floor(dbl_row)
f00 = self.getGeoidPixelValue(firstCoordinate, secondCoordinate)
if f00 == constants.CONST_GNSS_3D_CAPTURE_GEOIDS_NO_VALUE:
return geoidHeight
f10 = self.getGeoidPixelValue(
firstCoordinate + self.geoidStepFirstCoordinate, secondCoordinate)
if f10 == constants.CONST_GNSS_3D_CAPTURE_GEOIDS_NO_VALUE:
return geoidHeight
f01 = self.getGeoidPixelValue(
firstCoordinate, secondCoordinate + self.geoidStepSecondCoordinate)
if f01 == constants.CONST_GNSS_3D_CAPTURE_GEOIDS_NO_VALUE:
return geoidHeight
f11 = self.getGeoidPixelValue(
firstCoordinate + self.geoidStepFirstCoordinate,
secondCoordinate + self.geoidStepSecondCoordinate)
if f11 == constants.CONST_GNSS_3D_CAPTURE_GEOIDS_NO_VALUE:
return geoidHeight
geoidHeight = (1.0 - inc_row) * (1.0 - inc_column) * f00
geoidHeight += inc_column * (1.0 - inc_row) * f10
geoidHeight += (1.0 - inc_column) * inc_row * f01
geoidHeight += inc_column * inc_row * f11
return geoidHeight
def getGeoidPixelValue(self, gpsLongitude, gpsLatitude):
geoidPoint = QgsPoint(gpsLongitude, gpsLatitude)
geoidPoint = self.crsOperationFromGpsToGeoid.transform(geoidPoint)
geoidHeight = constants.CONST_GNSS_3D_CAPTURE_GEOIDS_NO_VALUE
if not self.geoidModel.extent().contains(geoidPoint):
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("Point out of Geoid Model extension:\n",
self.geoidModelFileName)
msgBox.exec_()
return geoidHeight
firstCoordinate = geoidPoint.x()
secondCoordinate = geoidPoint.y()
ident = self.geoidModel.dataProvider().identify(
geoidPoint, QgsRaster.IdentifyFormatValue)
if ident.isValid():
values = ident.results()
geoidHeight = values[1]
else:
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("Error getting value in Geoid Model:\n",
self.geoidModelFileName)
msgBox.exec_()
return geoidHeight
def initialize(self):
aux_path_plugin = 'python/plugins/' + constants.CONST_GNSS_3D_CAPTURE_NAME
qgisUserDbFilePath = QgsApplication.qgisUserDbFilePath()
self.path_plugin = os.path.join(
QFileInfo(QgsApplication.qgisUserDbFilePath()).path(),
aux_path_plugin)
path_file_qsettings = self.path_plugin + '/' + constants.CONST_GNSS_3D_CAPTURE_SETTINGS_FILE_NAME
self.settings = QSettings(path_file_qsettings, QSettings.IniFormat)
self.lastPath = self.settings.value("last_path")
if not self.lastPath:
self.lastPath = QDir.currentPath()
self.settings.setValue("last_path", self.lastPath)
self.settings.sync()
self.crsAuthId = self.settings.value("crsAuthId")
if not self.crsAuthId:
self.crsAuthId = self.iface.mapCanvas().mapRenderer(
).destinationCrs().authid()
self.settings.setValue("crsAuthId", self.crsAuthId)
self.settings.sync()
self.crs = QgsCoordinateReferenceSystem()
self.crs.createFromUserInput(self.crsAuthId)
if self.crs.geographicFlag():
self.firstCoordinateLabel.setText("Longitude")
self.secondCoordinateLabel.setText("Latitude")
else:
self.firstCoordinateLabel.setText("Easting")
self.secondCoordinateLabel.setText("Northing")
self.iface.mapCanvas().mapRenderer().setProjectionsEnabled(True)
self.startPushButton.setEnabled(False)
self.finishPushButton.setEnabled(False)
self.capturePointGroupBox.setEnabled(False)
QtCore.QObject.connect(self.configurePushButton,
QtCore.SIGNAL("clicked(bool)"),
self.selectConfigure)
# QtCore.QObject.connect(self.crsPushButton,QtCore.SIGNAL("clicked(bool)"),self.selectCrs)
# QtCore.QObject.connect(self.geoidCheckBox,QtCore.SIGNAL("clicked(bool)"),self.activateGeoid)
QtCore.QObject.connect(self.startPushButton,
QtCore.SIGNAL("clicked(bool)"),
self.startProcess)
QtCore.QObject.connect(self.updatePositionPushButton,
QtCore.SIGNAL("clicked(bool)"),
self.updatePosition)
QtCore.QObject.connect(self.finishPushButton,
QtCore.SIGNAL("clicked(bool)"),
self.finishProcess)
QtCore.QObject.connect(self.savePointPushButton,
QtCore.SIGNAL("clicked(bool)"), self.savePoint)
QtCore.QObject.connect(self.codePushButton,
QtCore.SIGNAL("clicked(bool)"), self.selectCode)
QtCore.QObject.connect(self.namePushButton,
QtCore.SIGNAL("clicked(bool)"), self.selectName)
QtCore.QObject.connect(self.numberPushButton,
QtCore.SIGNAL("clicked(bool)"),
self.selectNumber)
QtCore.QObject.connect(self.heightAntennaPushButton,
QtCore.SIGNAL("clicked(bool)"),
self.selectAntennaHeight)
self.pointNumbers = []
#self.configureDialog = None
self.configureDialog = GNSS3DCaptureDialog(self.iface, self.lastPath,
self.crs)
self.num_format = re.compile(r'^\-?[1-9][0-9]*\.?[0-9]*')
def savePoint(self):
connectionRegistry = QgsGPSConnectionRegistry().instance()
connectionList = connectionRegistry.connectionList()
if connectionList == []:
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText(
"GPS connection not detected.\nConnect a GPS and try again")
msgBox.exec_()
return
csvFile = QFile(self.csvFileName)
if not csvFile.open(QIODevice.Append | QIODevice.Text):
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("Error opening for writting file:\n" +
self.csvFileName)
msgBox.exec_()
return
csvTextStream = QTextStream(csvFile)
csvTextStream << "\n"
fieldValues = {}
fieldNumber = 0
listFieldValues = []
if self.useName:
name = self.nameLineEdit.text()
csvTextStream << name << ","
#fieldValues[fieldNumber]=QVariant(name)
fieldValues[fieldNumber] = name
fieldNumber = fieldNumber + 1
listFieldValues.append(name)
if self.useNumber:
number = self.numberLineEdit.text()
csvTextStream << number << ","
#fieldValues[fieldNumber]=QVariant(number)
fieldValues[fieldNumber] = number
fieldNumber = fieldNumber + 1
listFieldValues.append(number)
GPSInfo = connectionList[0].currentGPSInformation()
firstCoordinate = GPSInfo.longitude
secondCoordinate = GPSInfo.latitude
pointCrsGps = QgsPoint(firstCoordinate, secondCoordinate)
pointCrs = self.crsOperationFromGps.transform(pointCrsGps)
firstCoordinate = pointCrs.x()
secondCoordinate = pointCrs.y()
if self.crs.geographicFlag():
strFirstCoordinate = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_LONGITUDE_PRECISION.format(
firstCoordinate)
strSecondCoordinate = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_LATITUDE_PRECISION.format(
secondCoordinate)
else:
strFirstCoordinate = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_EASTING_PRECISION.format(
firstCoordinate)
strSecondCoordinate = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_NORTHING_PRECISION.format(
secondCoordinate)
csvTextStream << strFirstCoordinate << ","
csvTextStream << strSecondCoordinate
#fieldValues[fieldNumber]=QVariant(firstCoordinate)
fieldValues[fieldNumber] = firstCoordinate
listFieldValues.append(firstCoordinate)
fieldNumber = fieldNumber + 1
#fieldValues[fieldNumber]=QVariant(secondCoordinate)
fieldValues[fieldNumber] = secondCoordinate
listFieldValues.append(secondCoordinate)
fieldNumber = fieldNumber + 1
if self.useHeight:
antennaHeight = float(self.heightAntennaLineEdit.text())
height = GPSInfo.elevation
height = height - antennaHeight
if self.useGeoidModel:
geoidHeight = self.getGeoidInterpolatedValue(
GPSInfo.longitude, GPSInfo.latitude)
if geoidHeight == constants.CONST_GNSS_3D_CAPTURE_GEOIDS_NO_VALUE:
return
height = height - geoidHeight
strHeight = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_HEIGHT_PRECISION.format(
height)
csvTextStream << "," << strHeight
#fieldValues[fieldNumber]=QVariant(height)
fieldValues[fieldNumber] = height
listFieldValues.append(height)
fieldNumber = fieldNumber + 1
if self.useCode:
code = self.codeLineEdit.text()
csvTextStream << "," << code
#fieldValues[fieldNumber]=QVariant(code)
fieldValues[fieldNumber] = code
listFieldValues.append(code)
csvFile.close()
fet = QgsFeature()
fet.setGeometry(
QgsGeometry.fromPoint(QgsPoint(firstCoordinate, secondCoordinate)))
#fet.setAttributeMap(fieldValues)
fet.setAttributes(listFieldValues)
self.memoryLayerDataProvider.addFeatures([fet])
self.memoryLayer.commitChanges()
self.memoryLayerName.triggerRepaint()
if self.useNumber:
self.pointNumbers.append(int(number))
candidateValue = self.pointNumbers[len(self.pointNumbers) - 1] + 1
if self.pointNumbers.count(candidateValue) != 0:
control = True
while control:
candidateValue = candidateValue + 1
if self.pointNumbers.count(candidateValue) == 0:
control = False
self.numberLineEdit.setText(str(candidateValue))
self.accept()
def selectCode(self):
oldText = self.codeLineEdit.text()
label = "Input Point Code:"
title = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_WINDOW_TITLE
[text, ok] = QInputDialog.getText(self, title, label, QLineEdit.Normal,
oldText)
if ok and text:
text = text.strip()
if not text == oldText:
self.codeLineEdit.setText(text)
def selectAntennaHeight(self):
strCandidateValue = self.heightAntennaLineEdit.text()
label = "Input Antenna Height:"
title = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_WINDOW_TITLE
ok = False
while not ok:
[text,
ok] = QInputDialog.getText(self, title, label, QLineEdit.Normal,
strCandidateValue)
if ok and text:
value = 0.0
text = text.strip()
if text.isdigit() or re.match(self.num_format, text):
value = float(text)
if (value < constants.
CONST_GNSS_3D_CAPTURE_SAVE_POINT_ANTENNA_HEIGHT_MINIMUM_VALUE
or value > constants.
CONST_GNSS_3D_CAPTURE_SAVE_POINT_ANTENNA_HEIGHT_MAXIMUM_VALUE
):
ok = False
else:
ok = False
if ok:
strValue = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_ANTENNA_HEIGHT_PRECISION.format(
value)
self.heightAntennaLineEdit.setText(strValue)
self.updatePosition()
else:
if not ok:
ok = True
def selectConfigure(self):
# if self.configureDialog == None:
# self.configureDialog = GNSS3DCaptureDialog(self.iface,self.lastPath,self.crs)
# self.configureDialog.show() # show the dialog
# result = self.configureDialog.exec_() # Run the dialog
# yo =1
# else:
# self.configureDialog.show() # show the dialog
# result = self.configureDialog.exec_() # Run the dialog
# yo =1
# if self.configureDialog.isOk():
self.configureDialog.show() # show the dialog
result = self.configureDialog.exec_() # Run the dialog
self.csvFileName = self.configureDialog.getCsvFileName()
self.lastPath = self.configureDialog.getLastPath()
self.crs = self.configureDialog.getCrs()
self.useCode = self.configureDialog.getUseCode()
self.useName = self.configureDialog.getUseName()
self.useHeight = self.configureDialog.getUseHeight()
self.useNumber = self.configureDialog.getUseNumber()
self.useGeoidModel = self.configureDialog.getUseGeoidModel()
self.geoidModelFileName = self.configureDialog.getGeoidModelFileName()
if self.crs.isValid():
if self.crs.geographicFlag():
self.firstCoordinateLabel.setText("Longitude")
self.secondCoordinateLabel.setText("Latitude")
else:
self.firstCoordinateLabel.setText("Easting")
self.secondCoordinateLabel.setText("Northing")
crsAuthId = self.crs.authid()
self.settings.setValue("crsAuthId", crsAuthId)
self.settings.sync()
if self.lastPath:
self.settings.setValue("last_path", self.lastPath)
self.settings.sync()
if self.configureDialog.getIsOk():
self.startPushButton.setEnabled(True)
else:
self.startPushButton.setEnabled(False)
def selectName(self):
oldText = self.nameLineEdit.text()
label = "Input Point Name:"
title = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_WINDOW_TITLE
[text, ok] = QInputDialog.getText(self, title, label, QLineEdit.Normal,
oldText)
if ok and text:
text = text.strip()
if not text == oldText:
self.nameLineEdit.setText(text)
def selectNumber(self):
if self.pointNumbers == []:
candidateValue = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_FIRST_POINT_NUMBER
else:
candidateValue = self.pointNumbers(len(self.pointNumbers) - 1)
label = "Input Point Number:"
title = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_WINDOW_TITLE
ok = False
while not ok:
[text, ok] = QInputDialog.getText(self, title, label,
QLineEdit.Normal,
str(candidateValue))
if ok and text:
text = text.strip()
if not text.isdigit():
ok = False
else:
value = int(text)
if (value < constants.
CONST_GNSS_3D_CAPTURE_SAVE_POINT_POINT_NUMBER_MINIMUM_VALUE
or value > constants.
CONST_GNSS_3D_CAPTURE_SAVE_POINT_POINT_NUMBER_MAXIMUM_VALUE
):
ok = False
if ok:
self.numberLineEdit.setText(text)
else:
if not ok:
ok = True
def startProcess(self):
connectionRegistry = QgsGPSConnectionRegistry().instance()
connectionList = connectionRegistry.connectionList()
if connectionList == []:
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText(
"GPS connection not detected.\nConnect a GPS and try again")
msgBox.exec_()
return
GPSInfo = connectionList[0].currentGPSInformation()
self.capturePointGroupBox.setEnabled(False)
if not self.configureDialog.getIsOk():
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("The configuration is not valid")
msgBox.exec_()
return
if self.useCode:
self.codePushButton.setEnabled(True)
self.codeLineEdit.setEnabled(True)
else:
self.codePushButton.setEnabled(False)
self.codeLineEdit.setEnabled(False)
self.codeLineEdit.clear()
if self.useName:
self.namePushButton.setEnabled(True)
self.nameLineEdit.setEnabled(True)
else:
self.namePushButton.setEnabled(False)
self.nameLineEdit.setEnabled(False)
self.nameLineEdit.clear()
if self.useNumber:
self.numberPushButton.setEnabled(True)
self.numberLineEdit.setEnabled(True)
else:
self.numberPushButton.setEnabled(False)
self.numberLineEdit.setEnabled(False)
self.numberLineEdit.clear()
if self.useHeight:
self.heightAntennaPushButton.setEnabled(True)
self.heightAntennaLineEdit.setEnabled(True)
self.antennaHeight = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_ANTENNA_HEIGHT_DEFAULT_VALUE
strAntennaHeigth = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_ANTENNA_HEIGHT_PRECISION.format(
self.antennaHeight)
self.heightAntennaLineEdit.setText(strAntennaHeigth)
self.heightGpsLabel.setEnabled(True)
self.heightGpsLineEdit.setEnabled(True)
self.heightGroundLabel.setEnabled(True)
self.heightGroundLineEdit.setEnabled(True)
if self.useGeoidModel and self.geoidModelFileName:
self.heightGeoidLabel.setEnabled(True)
self.heightGeoidLineEdit.setEnabled(True)
self.heightFromGeoidLabel.setEnabled(True)
self.heightFromGeoidLineEdit.setEnabled(True)
else:
self.heightGeoidLabel.setEnabled(False)
self.heightGeoidLineEdit.setEnabled(False)
self.heightGeoidLineEdit.clear()
self.heightFromGeoidLabel.setEnabled(False)
self.heightFromGeoidLineEdit.setEnabled(False)
self.heightFromGeoidLineEdit.clear()
else:
self.heightAntennaPushButton.setEnabled(False)
self.heightAntennaLineEdit.setEnabled(False)
self.heightAntennaLineEdit.clear()
self.heightGpsLabel.setEnabled(False)
self.heightGpsLineEdit.setEnabled(False)
self.heightGpsLineEdit.clear()
self.heightGroundLabel.setEnabled(False)
self.heightGroundLineEdit.setEnabled(False)
self.heightGroundLineEdit.clear()
self.heightGeoidLabel.setEnabled(False)
self.heightGeoidLineEdit.setEnabled(False)
self.heightGeoidLineEdit.clear()
self.heightFromGeoidLabel.setEnabled(False)
self.heightFromGeoidLineEdit.setEnabled(False)
self.heightFromGeoidLineEdit.clear()
fileName = self.csvFileName
if not fileName:
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("You must select CSV file")
msgBox.exec_()
return
strDateTime = ""
if QFile.exists(fileName):
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
text = "Exists CSV file:\n" + fileName
msgBox.setText(text)
msgBox.setInformativeText(
"Do you want to rename it with current date an time?")
msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Discard
| QMessageBox.Cancel)
msgBox.setDefaultButton(QMessageBox.Ok)
ret = msgBox.exec_()
if ret == QMessageBox.Ok:
dateTime = QDateTime.currentDateTime()
strDateTime = dateTime.toString("yyyy-MM-dd_HH-mm-ss")
fileInfo = QFileInfo(fileName)
filePath = fileInfo.absolutePath()
fileNameWithoutExtension = fileInfo.completeBaseName()
fileExtension = fileInfo.completeSuffix()
newFileName = filePath + "/" + fileNameWithoutExtension + "_" + strDateTime + "." + fileExtension
if not QFile.copy(fileName, newFileName):
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Warning)
msgBox.setWindowTitle(
constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setWindowTitle(
constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("Error copying existing file:\n" +
fileName + "\n" + newFileName)
msgBox.exec_()
return
if not self.crs.isValid():
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("You must select the output CRS")
msgBox.exec_()
return
if self.useGeoidModel and self.geoidModelFileName == constants.CONST_GNSS_3D_CAPTURE_COMBOBOX_NO_SELECT_OPTION:
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText(
"If you select substract geoide height \n you must select a geoid model"
)
msgBox.exec_()
return
csvFile = QFile(fileName)
if not csvFile.open(QIODevice.WriteOnly | QIODevice.Text):
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("Error opening for writting file:\n" + fileName)
msgBox.exec_()
return
csvTextStream = QTextStream(csvFile)
fileInfo = QFileInfo(fileName)
self.memoryLayerName = fileInfo.completeBaseName()
existsMemoryLayer = None
for lyr in QgsMapLayerRegistry.instance().mapLayers().values():
if lyr.name() == self.memoryLayerName:
existsMemoryLayer = lyr
break
if existsMemoryLayer != None:
newMemoryLayerName = self.memoryLayerName + "_" + strDateTime
existsMemoryLayer.setLayerName(newMemoryLayerName)
memoryLayerTypeAndCrs = "Point?crs=" + self.crs.authid() #EPSG:4326"
self.memoryLayer = QgsVectorLayer(memoryLayerTypeAndCrs,
self.memoryLayerName, "memory")
self.memoryLayerDataProvider = self.memoryLayer.dataProvider()
memoryLayerFields = []
# add fields
firstField = True
if self.useName:
csvTextStream << "Name"
firstField = False
memoryLayerFields.append(QgsField("Name", QVariant.String))
if self.useNumber:
if not firstField:
csvTextStream << ","
else:
firstField = False
csvTextStream << "Number"
memoryLayerFields.append(QgsField("Number", QVariant.Int))
if not firstField:
csvTextStream << ","
else:
firstField = False
if not self.crs.geographicFlag():
csvTextStream << "Easting"
csvTextStream << "," << "Northing"
memoryLayerFields.append(QgsField("Easting", QVariant.Double))
memoryLayerFields.append(QgsField("Northing", QVariant.Double))
else:
csvTextStream << "Longitude"
csvTextStream << "," << "Latitude"
memoryLayerFields.append(QgsField("Longitude", QVariant.Double))
memoryLayerFields.append(QgsField("Latitude", QVariant.Double))
if self.useHeight:
csvTextStream << "," << "Height"
memoryLayerFields.append(QgsField("Height", QVariant.Double))
if self.useCode:
csvTextStream << "," << "Code"
memoryLayerFields.append(QgsField("Code", QVariant.String))
csvFile.close()
self.memoryLayerDataProvider.addAttributes(memoryLayerFields)
# self.memoryLayerDataProvider.addAttributes([QgsField("Name", QVariant.String),
# QgsField("Number", QVariant.String),
# QgsField("FirstCoordinate", QVariant.Double),
# QgsField("SecondCoordinate", QVariant.Double),
# QgsField("Height", QVariant.Double),
# QgsField("Code", QVariant.Int)])
self.memoryLayer.startEditing()
self.memoryLayer.commitChanges()
qmlFileName = self.path_plugin + "/" + constants.CONST_GNSS_3D_CAPTURE_QML_TEMPLATES_FOLDER + "/"
if self.useName:
qmlFileName += constants.CONST_GNSS_3D_CAPTURE_QML_TEMPLATES_FOLDER_QML_POINT_NAME_Z
elif self.useNumber:
qmlFileName += constants.CONST_GNSS_3D_CAPTURE_QML_TEMPLATES_FOLDER_QML_POINT_NUMBER_Z
else:
qmlFileName += constants.CONST_GNSS_3D_CAPTURE_QML_TEMPLATES_FOLDER_QML_POINT_Z
self.memoryLayer.loadNamedStyle(qmlFileName)
QgsMapLayerRegistry.instance().addMapLayer(self.memoryLayer)
epsgCodeGps = constants.CONST_GNSS_3D_CAPTURE_EPSG_CODE_GPS
self.crsGps = QgsCoordinateReferenceSystem(epsgCodeGps)
if not self.crsGps.isValid():
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("Error creating CRS by EPSG Code: " +
str(epsgCodeGps))
msgBox.exec_()
self.isValid = False
return
self.crsOperationFromGps = QgsCoordinateTransform(
self.crsGps, self.crs)
if self.useHeight:
if self.useGeoidModel:
if not QFile.exists(self.geoidModelFileName):
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(
constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("Geoid Model file not exists:\n" +
self.geoidModelFileName)
msgBox.exec_()
self.isValid = False
return
geoidModelFileInfo = QFileInfo(self.geoidModelFileName)
geoidModelPath = geoidModelFileInfo.filePath()
geoidModelBaseName = geoidModelFileInfo.baseName()
self.geoidModel = QgsRasterLayer(geoidModelPath,
geoidModelBaseName)
self.crsGeoidModel = self.geoidModel.crs()
if not self.crsGeoidModel.isValid():
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(
constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText("Error getting Geoid Model CRS:\n" +
self.geoidModelFileName)
msgBox.exec_()
self.isValid = False
return
self.geoidStepFirstCoordinate = self.geoidModel.rasterUnitsPerPixelX(
) # debe ser positivo
self.geoidStepSecondCoordinate = 1.0 * self.geoidModel.rasterUnitsPerPixelX(
) # debe ser positivo
self.geoidExtend = self.geoidModel.dataProvider().extent()
self.geoidMinimumFirstCoordinate = self.geoidExtend.xMinimum()
self.geoidMaximumSecondCoordinate = self.geoidExtend.yMaximum()
self.crsOperationFromGpsToGeoid = QgsCoordinateTransform(
self.crsGps, self.crsGeoidModel)
self.capturePointGroupBox.setEnabled(True)
self.configurePushButton.setEnabled(False)
self.startPushButton.setEnabled(False)
self.finishPushButton.setEnabled(True)
if self.useNumber:
strFirstNumber = str(
constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_FIRST_POINT_NUMBER)
self.numberLineEdit.setText(strFirstNumber)
self.updatePosition()
def updatePosition(self):
connectionRegistry = QgsGPSConnectionRegistry().instance()
connectionList = connectionRegistry.connectionList()
if connectionList == []:
msgBox = QMessageBox(self)
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle(constants.CONST_GNSS_3D_CAPTURE_WINDOW_TITLE)
msgBox.setText(
"GPS connection not detected.\nConnect a GPS and try again")
msgBox.exec_()
return
GPSInfo = connectionList[0].currentGPSInformation()
firstCoordinate = GPSInfo.longitude
secondCoordinate = GPSInfo.latitude
pointCrsGps = QgsPoint(firstCoordinate, secondCoordinate)
pointCrs = self.crsOperationFromGps.transform(pointCrsGps)
firstCoordinate = pointCrs.x()
secondCoordinate = pointCrs.y()
if self.crs.geographicFlag():
strFirstCoordinate = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_LONGITUDE_PRECISION.format(
firstCoordinate)
strSecondCoordinate = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_LATITUDE_PRECISION.format(
secondCoordinate)
else:
strFirstCoordinate = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_EASTING_PRECISION.format(
firstCoordinate)
strSecondCoordinate = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_NORTHING_PRECISION.format(
secondCoordinate)
self.firstCoordinateLineEdit.setText(strFirstCoordinate)
self.secondCoordinateLineEdit.setText(strSecondCoordinate)
antennaHeight = float(self.heightAntennaLineEdit.text())
if self.useHeight:
height = GPSInfo.elevation
heightGround = height - antennaHeight
strHeight = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_HEIGHT_PRECISION.format(
height)
self.heightGpsLineEdit.setText(strHeight)
strHeightGround = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_HEIGHT_PRECISION.format(
heightGround)
self.heightGroundLineEdit.setText(strHeightGround)
if self.useGeoidModel:
geoidHeight = self.getGeoidInterpolatedValue(
GPSInfo.longitude, GPSInfo.latitude)
if geoidHeight == constants.CONST_GNSS_3D_CAPTURE_GEOIDS_NO_VALUE:
return
strGeoidHeight = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_GEOID_HEIGHT_PRECISION.format(
geoidHeight)
heightFromGeoid = heightGround - geoidHeight
strHeightFromGeoid = constants.CONST_GNSS_3D_CAPTURE_SAVE_POINT_HEIGHT_FROM_GEOID_PRECISION.format(
heightFromGeoid)
self.heightGeoidLineEdit.setText(strGeoidHeight)
self.heightFromGeoidLineEdit.setText(strHeightFromGeoid)
