def processAlgorithm(self, progress):
source = self.getParameterValue(self.INPUT)
vlayer = dataobjects.getObjectFromUri(source)
output = self.getOutputFromName(self.OUTPUT)
vprovider = vlayer.dataProvider()
fields = vprovider.fields()
writer = output.getVectorWriter(fields, QGis.WKBPoint, self.crs)
xfieldindex = vlayer.fieldNameIndex(self.getParameterValue(self.XFIELD))
yfieldindex = vlayer.fieldNameIndex(self.getParameterValue(self.YFIELD))
crsId = self.getParameterValue(self.TARGET_CRS)
targetCrs = QgsCoordinateReferenceSystem()
targetCrs.createFromUserInput(crsId)
self.crs = targetCrs
outFeat = QgsFeature()
nElement = 0
features = vector.features(vlayer)
nFeat = len(features)
for feature in features:
nElement += 1
progress.setPercentage(nElement * 100 / nFeat)
attrs = feature.attributes()
try:
x = float(attrs[xfieldindex])
y = float(attrs[yfieldindex])
except:
continue
pt = QgsPoint(x, y)
outFeat.setGeometry(QgsGeometry.fromPoint(pt))
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
del writer
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
crsId = self.getParameterValue(self.TARGET_CRS)
targetCrs = QgsCoordinateReferenceSystem()
targetCrs.createFromUserInput(crsId)
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields().toList(), layer.wkbType(), targetCrs)
layerCrs = layer.crs()
crsTransform = QgsCoordinateTransform(layerCrs, targetCrs)
outFeat = QgsFeature()
features = vector.features(layer)
total = 100.0 / len(features)
for current, f in enumerate(features):
geom = f.geometry()
geom.transform(crsTransform)
outFeat.setGeometry(geom)
outFeat.setAttributes(f.attributes())
writer.addFeature(outFeat)
progress.setPercentage(int(current * total))
del writer
self.crs = targetCrs
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
crsId = self.getParameterValue(self.TARGET_CRS)
targetCrs = QgsCoordinateReferenceSystem()
targetCrs.createFromUserInput(crsId)
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(),
targetCrs, context)
layerCrs = layer.crs()
crsTransform = QgsCoordinateTransform(layerCrs, targetCrs)
outFeat = QgsFeature()
features = QgsProcessingUtils.getFeatures(layer, context)
total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
for current, f in enumerate(features):
geom = f.geometry()
geom.transform(crsTransform)
outFeat.setGeometry(geom)
outFeat.setAttributes(f.attributes())
writer.addFeature(outFeat)
feedback.setProgress(int(current * total))
del writer
self.crs = targetCrs
def processAlgorithm(self, progress):
source = self.getParameterValue(self.INPUT)
vlayer = dataobjects.getObjectFromUri(source)
output = self.getOutputFromName(self.OUTPUT)
fields = vlayer.fields()
writer = output.getVectorWriter(fields, QgsWkbTypes.Point, self.crs)
xfieldindex = vlayer.fieldNameIndex(self.getParameterValue(self.XFIELD))
yfieldindex = vlayer.fieldNameIndex(self.getParameterValue(self.YFIELD))
crsId = self.getParameterValue(self.TARGET_CRS)
targetCrs = QgsCoordinateReferenceSystem()
targetCrs.createFromUserInput(crsId)
self.crs = targetCrs
outFeat = QgsFeature()
features = vector.features(vlayer)
total = 100.0 / len(features)
for current, feature in enumerate(features):
progress.setPercentage(int(current * total))
attrs = feature.attributes()
try:
x = float(attrs[xfieldindex])
y = float(attrs[yfieldindex])
except:
continue
pt = QgsPoint(x, y)
outFeat.setGeometry(QgsGeometry.fromPoint(pt))
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
del writer
def processAlgorithm(self, feedback):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
crsId = self.getParameterValue(self.TARGET_CRS)
targetCrs = QgsCoordinateReferenceSystem()
targetCrs.createFromUserInput(crsId)
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields().toList(), layer.wkbType(), targetCrs)
layerCrs = layer.crs()
crsTransform = QgsCoordinateTransform(layerCrs, targetCrs)
outFeat = QgsFeature()
features = vector.features(layer)
total = 100.0 / len(features)
for current, f in enumerate(features):
geom = f.geometry()
geom.transform(crsTransform)
outFeat.setGeometry(geom)
outFeat.setAttributes(f.attributes())
writer.addFeature(outFeat)
feedback.setProgress(int(current * total))
del writer
self.crs = targetCrs
def processAlgorithm(self, feedback):
extent = str(self.getParameterValue(self.EXTENT)).split(',')
spacing = float(self.getParameterValue(self.SPACING))
inset = float(self.getParameterValue(self.INSET))
randomize = self.getParameterValue(self.RANDOMIZE)
isSpacing = self.getParameterValue(self.IS_SPACING)
crsId = self.getParameterValue(self.CRS)
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(crsId)
extent = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, crs)
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.0 / (area / pSpacing)
y = extent.yMaximum() - inset
extent_geom = QgsGeometry.fromRect(extent)
extent_engine = QgsGeometry.createGeometryEngine(extent_geom.geometry())
extent_engine.prepareGeometry()
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if randomize:
geom = QgsGeometry().fromPoint(QgsPoint(
uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0))))
else:
geom = QgsGeometry().fromPoint(QgsPoint(x, y))
if extent_engine.intersects(geom.geometry()):
f.setAttribute('id', count)
f.setGeometry(geom)
writer.addFeature(f)
x += pSpacing
count += 1
feedback.setProgress(int(count * total))
y = y - pSpacing
del writer
def processAlgorithm(self, progress):
source = self.getParameterValue(self.INPUT)
vlayer = dataobjects.getObjectFromUri(source)
output = self.getOutputFromName(self.OUTPUT)
fields = vlayer.fields()
writer = output.getVectorWriter(fields, QgsWkbTypes.Point, self.crs)
xfieldindex = vlayer.fields().lookupField(
self.getParameterValue(self.XFIELD))
yfieldindex = vlayer.fields().lookupField(
self.getParameterValue(self.YFIELD))
crsId = self.getParameterValue(self.TARGET_CRS)
targetCrs = QgsCoordinateReferenceSystem()
targetCrs.createFromUserInput(crsId)
self.crs = targetCrs
outFeat = QgsFeature()
features = vector.features(vlayer)
total = 100.0 / len(features)
for current, feature in enumerate(features):
progress.setPercentage(int(current * total))
attrs = feature.attributes()
try:
x = float(attrs[xfieldindex])
y = float(attrs[yfieldindex])
except:
continue
pt = QgsPoint(x, y)
outFeat.setGeometry(QgsGeometry.fromPoint(pt))
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
del writer
def processAlgorithm(self, progress):
source = self.getParameterValue(self.INPUT)
vlayer = dataobjects.getObjectFromUri(source)
output = self.getOutputFromName(self.OUTPUT)
fields = vlayer.fields()
x_field_index = fields.lookupField(self.getParameterValue(self.XFIELD))
y_field_index = fields.lookupField(self.getParameterValue(self.YFIELD))
z_field_index = None
if self.getParameterValue(self.ZFIELD):
z_field_index = fields.lookupField(self.getParameterValue(self.ZFIELD))
m_field_index = None
if self.getParameterValue(self.MFIELD):
m_field_index = fields.lookupField(self.getParameterValue(self.MFIELD))
wkb_type = QgsWkbTypes.Point
if z_field_index is not None:
wkb_type = QgsWkbTypes.addZ(wkb_type)
if m_field_index is not None:
wkb_type = QgsWkbTypes.addM(wkb_type)
crsId = self.getParameterValue(self.TARGET_CRS)
target_crs = QgsCoordinateReferenceSystem()
target_crs.createFromUserInput(crsId)
writer = output.getVectorWriter(fields, wkb_type, target_crs)
features = vector.features(vlayer)
total = 100.0 / len(features)
for current, feature in enumerate(features):
progress.setPercentage(int(current * total))
attrs = feature.attributes()
try:
x = float(attrs[x_field_index])
y = float(attrs[y_field_index])
point = QgsPointV2(x, y)
if z_field_index is not None:
try:
point.addZValue(float(attrs[z_field_index]))
except:
point.addZValue(0.0)
if m_field_index is not None:
try:
point.addMValue(float(attrs[m_field_index]))
except:
point.addMValue(0.0)
feature.setGeometry(QgsGeometry(point))
except:
pass # no geometry
writer.addFeature(feature)
del writer
def processAlgorithm(self, parameters, context, feedback):
extent = str(self.getParameterValue(self.EXTENT)).split(',')
spacing = float(self.getParameterValue(self.SPACING))
inset = float(self.getParameterValue(self.INSET))
randomize = self.getParameterValue(self.RANDOMIZE)
isSpacing = self.getParameterValue(self.IS_SPACING)
crsId = self.getParameterValue(self.CRS)
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(crsId)
extent = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, crs, context)
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.0 / (area / pSpacing)
y = extent.yMaximum() - inset
extent_geom = QgsGeometry.fromRect(extent)
extent_engine = QgsGeometry.createGeometryEngine(extent_geom.geometry())
extent_engine.prepareGeometry()
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if randomize:
geom = QgsGeometry().fromPoint(QgsPointXY(
uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0))))
else:
geom = QgsGeometry().fromPoint(QgsPointXY(x, y))
if extent_engine.intersects(geom.geometry()):
f.setAttribute('id', count)
f.setGeometry(geom)
writer.addFeature(f)
x += pSpacing
count += 1
feedback.setProgress(int(count * total))
y = y - pSpacing
del writer
def processAlgorithm(self, progress):
source = self.getParameterValue(self.INPUT)
vlayer = dataobjects.getObjectFromUri(source)
output = self.getOutputFromName(self.OUTPUT)
fields = vlayer.fields()
x_field_index = fields.lookupField(self.getParameterValue(self.XFIELD))
y_field_index = fields.lookupField(self.getParameterValue(self.YFIELD))
z_field_index = None
if self.getParameterValue(self.ZFIELD):
z_field_index = fields.lookupField(self.getParameterValue(self.ZFIELD))
m_field_index = None
if self.getParameterValue(self.MFIELD):
m_field_index = fields.lookupField(self.getParameterValue(self.MFIELD))
wkb_type = QgsWkbTypes.Point
if z_field_index is not None:
wkb_type = QgsWkbTypes.addZ(wkb_type)
if m_field_index is not None:
wkb_type = QgsWkbTypes.addM(wkb_type)
crsId = self.getParameterValue(self.TARGET_CRS)
target_crs = QgsCoordinateReferenceSystem()
target_crs.createFromUserInput(crsId)
writer = output.getVectorWriter(fields, wkb_type, target_crs)
features = vector.features(vlayer)
total = 100.0 / len(features)
for current, feature in enumerate(features):
progress.setPercentage(int(current * total))
attrs = feature.attributes()
try:
x = float(attrs[x_field_index])
y = float(attrs[y_field_index])
point = QgsPointV2(x, y)
if z_field_index is not None:
try:
point.addZValue(float(attrs[z_field_index]))
except:
point.addZValue(0.0)
if m_field_index is not None:
try:
point.addMValue(float(attrs[m_field_index]))
except:
point.addMValue(0.0)
feature.setGeometry(QgsGeometry(point))
except:
pass # no geometry
writer.addFeature(feature)
del writer
def processAlgorithm(self, feedback):
pointCount = int(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
extent = str(self.getParameterValue(self.EXTENT)).split(',')
crsId = self.getParameterValue(self.CRS)
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(crsId)
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
extent = QgsGeometry().fromRect(
QgsRectangle(xMin, yMin, xMax, yMax))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, crs)
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = xMin + (xMax - xMin) * random.random()
ry = yMin + (yMax - yMin) * random.random()
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if geom.within(extent) and \
vector.checkMinDistance(pnt, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Can not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
del writer
def processAlgorithm(self, parameters, context, feedback):
pointCount = int(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
extent = str(self.getParameterValue(self.EXTENT)).split(',')
crsId = self.getParameterValue(self.CRS)
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(crsId)
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
extent = QgsGeometry().fromRect(QgsRectangle(xMin, yMin, xMax, yMax))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, crs, context)
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = xMin + (xMax - xMin) * random.random()
ry = yMin + (yMax - yMin) * random.random()
pnt = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if geom.within(extent) and \
vector.checkMinDistance(pnt, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
QgsMessageLog.logMessage(
self.tr('Can not generate requested number of random points. '
'Maximum number of attempts exceeded.'),
self.tr('Processing'), QgsMessageLog.INFO)
del writer
def L(data):
"""Get the pipe length from QGIS"""
if data.L is None:
distance = qgis.core.QgsDistanceArea()
layer = qgis.utils.plugins["XPSS"].params.pipes_vlay
lyr_crs = layer.crs()
elps = QgsProject.instance().ellipsoid()
elps_crs = QgsCoordinateReferenceSystem()
elps_crs.createFromUserInput(elps)
logger.debugger("Map Ellipsoid: " + str(elps))
#transform = iface.mapCanvas().mapSettings().transformContext()
trans_context = QgsCoordinateTransformContext()
trans_context.calculateDatumTransforms(lyr_crs, elps_crs)
distance.setEllipsoid(elps)
distance.setSourceCrs(lyr_crs, trans_context)
units = qgis.core.QgsUnitTypes
logger.debugger("units: " + str(units))
#get_lst is the qepanet parameter field name for the attribute
#sort_lst = map(str, sort_lst) #convert the array of ints to an array of strings
#df = self.pipe_fts.filter(get_lst, axis=1) #extract columns from qepanet data
len_ = []
features = layer.getFeatures()
#logger.debugger("Converting from "+units.toString(units.DistanceMeters)+" to "+units.toString(calc_units)+".")
#factor = QgsUnitTypes.fromUnitToUnitFactor(units.DistanceMeters, calc_units) ## TODO: Soft code
#logger.debugger("Conversion factor: "+str(factor))
for feature in features:
#l_calc = distance.measureLength(feature.geometry())*factor
#TODO: Soft code units
l_calc = distance.measureLength(feature.geometry())
len_.append(l_calc) #extract length from the QgsFeature
logger.debugger(feature['id'] + ": " + str(l_calc))
data.L = np.array(len_) * LengthUnits['m']
logger.debugger("L: " + str(data.L))
return data.L.reshape((-1, 1))
def sdbinfo(self, filename):
"""Populate dialog with current values"""
self.sdbname.setText(filename)
try:
sdb = SDB(filename)
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(sdb.meta("crs"))
self.sdb_info_basic.setPlainText(
sdb.info(report='basic') +
'\nCRS parsed by QGIS:\n{}'.format(crs.description()))
self.sdb_info_data.setPlainText(sdb.info(report='data'))
self.sdb_info_tags.setPlainText(sdb.info(report='tags'))
self.dbok = True
except:
self.sdb_info_basic.clear()
self.sdb_info_data.clear()
self.sdb_info_tags.clear()
self.sdbname.clear()
self.dbok = False
def _toVectorLayer_geojson (self):
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(self.provider.srsName)
fileName = self.xmlFile.replace(".xml", ".geojson")
fields = QgsFields ()
map (fields.append, self.provider.fields)
writer = QgsVectorFileWriter (fileName, "utf-8", fields, QGis.WKBPoint, crs, "GeoJSON")
if writer.hasError() != QgsVectorFileWriter.NoError:
raise Exception (writer.errorMessage())
for feature in self.provider.getFeatures():
self.features.append(feature)
writer.addFeature(feature)
del writer #Forzar escritura a disco
return QgsVectorLayer( fileName, self.name, "ogr")
def _toVectorLayer_geojson(self):
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(self.provider.srsName)
fileName = self.xmlFile.replace(".xml", ".geojson")
fields = QgsFields()
map(fields.append, self.provider.fields)
writer = QgsVectorFileWriter(fileName, "utf-8", fields, QGis.WKBPoint,
crs, "GeoJSON")
if writer.hasError() != QgsVectorFileWriter.NoError:
raise Exception(writer.errorMessage())
for feature in self.provider.getFeatures():
self.features.append(feature)
writer.addFeature(feature)
del writer #Forzar escritura a disco
return QgsVectorLayer(fileName, self.name, "ogr")
def coordgps (self):
connectionRegistry = QgsApplication.gpsConnectionRegistry()
connectionList = connectionRegistry.connectionList()
coordenadas = []
gps = QgsCoordinateReferenceSystem(4326)
crsAuthId = QgsProject.instance().crs().authid()
crs= QgsCoordinateReferenceSystem()
crs.createFromUserInput(crsAuthId)
tform = QgsCoordinateTransform(gps, crs, QgsProject.instance())
#Advertencia si no hay GPS conectado
if connectionList == []:
QtWidgets.QMessageBox.information(None, "GPS no conectado",
"Conecta un GPS para obtener las coordenadas.\nMientras tanto, puede introducirlas manualmente.")
#Transformación de coordenadas al sistema actual
else:
GPSInfo = connectionList[0].currentGPSInformation()
x,y = tform.transform(GPSInfo.longitude, GPSInfo.latitude)
coordenadas.append(x)
coordenadas.append(y)
return coordenadas
def parse(self, xml):
xml = XMLParser.parse(self, xml)
node, _ = self.searchFirst(xml, "")
if not node or not node.localName() == "ObservationCollection":
if node.localName() == "ExceptionReport":
node, exceptionCode = self.searchFirst(
node, "Exception@exceptionCode")
_, exceptionText = self.searchFirst(node, "ExceptionText")
raise sos.ExceptionReport(exceptionCode, exceptionText)
raise ValueError(node.localName())
boundedByNode, boundedByType = self.searchFirst(xml, "boundedBy/*")
_, self.provider.srsName = self.searchFirst(boundedByNode, "@srsName")
crs = QgsCoordinateReferenceSystem()
if crs.createFromUserInput(self.provider.srsName):
yx = crs.axisInverted()
else:
yx = (self.provider.srsName == 'urn:ogc:def:crs:EPSG:0'
) #Hack para meteogalicia
if boundedByType == "Envelope":
self.provider.extent = GMLParser.rectangleFromGMLEnvelope(
boundedByNode)
elif boundedByType == "Box":
self.provider.extent = GMLParser.rectangleFromGMLBox(boundedByNode)
else:
geo = GMLParser.geometryFromGML(boundedByNode)
if geo:
self.provider.extent = geo.boundingBox()
_, tag = self.searchFirst(xml, 'member/*')
omParser = XMLParserFactory.getInstance(tag)(self.provider, yx)
components = omParser.parse(xml)
components = filter(lambda f: f != None, components.values())
hasTime = False
for i, f in enumerate(components):
if f.name() == "Time" or f.name() == "SamplingTime":
components.pop(i)
f.setName("Time")
self.provider.fields.append(f)
hasTime = True
break
if not hasTime:
self.provider.fields.append(QgsField("Time", QVariant.String, ''))
self.provider.fields.extend(components)
return self.provider
def processAlgorithm(self, progress):
source = self.getParameterValue(self.INPUT)
vlayer = dataobjects.getObjectFromUri(source)
output = self.getOutputFromName(self.OUTPUT)
vprovider = vlayer.dataProvider()
fields = vprovider.fields()
writer = output.getVectorWriter(fields, QGis.WKBPoint, self.crs)
xfieldindex = vlayer.fieldNameIndex(self.getParameterValue(
self.XFIELD))
yfieldindex = vlayer.fieldNameIndex(self.getParameterValue(
self.YFIELD))
crsId = self.getParameterValue(self.TARGET_CRS)
targetCrs = QgsCoordinateReferenceSystem()
targetCrs.createFromUserInput(crsId)
self.crs = targetCrs
outFeat = QgsFeature()
nElement = 0
features = vector.features(vlayer)
nFeat = len(features)
for feature in features:
nElement += 1
progress.setPercentage(nElement * 100 / nFeat)
attrs = feature.attributes()
try:
x = float(attrs[xfieldindex])
y = float(attrs[yfieldindex])
except:
continue
pt = QgsPoint(x, y)
outFeat.setGeometry(QgsGeometry.fromPoint(pt))
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
del writer
def parse (self, xml):
xml = XMLParser.parse(self, xml)
node,_ = self.searchFirst (xml, "")
if not node or not node.localName() == "ObservationCollection":
if node.localName() == "ExceptionReport":
node, exceptionCode = self.searchFirst(node, "Exception@exceptionCode")
_, exceptionText = self.searchFirst(node, "ExceptionText")
raise sos.ExceptionReport (exceptionCode, exceptionText)
raise ValueError (node.localName())
boundedByNode, boundedByType = self.searchFirst (xml, "boundedBy/*")
_, self.provider.srsName = self.searchFirst (boundedByNode, "@srsName")
crs = QgsCoordinateReferenceSystem()
if crs.createFromUserInput(self.provider.srsName):
yx = crs.axisInverted()
else:
yx = (self.provider.srsName == 'urn:ogc:def:crs:EPSG:0') #Hack para meteogalicia
if boundedByType == "Envelope":
self.provider.extent = GMLParser.rectangleFromGMLEnvelope(boundedByNode)
elif boundedByType == "Box":
self.provider.extent = GMLParser.rectangleFromGMLBox(boundedByNode)
else:
geo = GMLParser.geometryFromGML(boundedByNode)
if geo:
self.provider.extent = geo.boundingBox()
_, tag = self.searchFirst(xml, 'member/*')
omParser = XMLParserFactory.getInstance(tag)(self.provider, yx)
components = omParser.parse(xml)
components = filter(lambda f: f != None, components.values())
hasTime = False
for i, f in enumerate(components):
if f.name() == "Time" or f.name() == "SamplingTime":
components.pop (i)
f.setName("Time")
self.provider.fields.append(f)
hasTime = True
break
if not hasTime:
self.provider.fields.append(QgsField ("Time", QVariant.String, ''))
self.provider.fields.extend(components)
return self.provider
def run(self):
def filePath(title):
qfd = QFileDialog()
path = ""
filter = "uper(*.uper)"
f = QFileDialog.getOpenFileName(qfd, title, path, filter)
return f
fpath = filePath("Select *.uper")
if fpath[0] != "":
with tempfile.TemporaryDirectory() as tmpdirname:
#print('created temporary directory', tmpdirname)
get_geojson_from_complete_uper(
tmpdirname, fpath[0],
os.path.join(os.path.dirname(__file__),
'mapem_spatem.asn'))
layer = QgsProject.instance().layerTreeRoot()
def addGroupIfNotExist(name, group):
mapem_group = None
for i in group.children():
if i.name() == name:
mapem_group = i
break
if mapem_group == None:
# create layer
group.addGroup(name)
for i in group.children():
if i.name() == name:
mapem_group = i
break
return mapem_group
#mapem_group = addGroupIfNotExist("MAPEM",layer)
mapem_group = addGroupIfNotExist(
os.path.basename(fpath[0]).split('.')[0] + ".uper", layer)
intersections = addGroupIfNotExist("intersections",
mapem_group)
roadSegments = addGroupIfNotExist("roadSegments", mapem_group)
def addFileJsonInLayer(filename, group, name):
#listLayers=QgsProject.instance().mapLayersByName(name)
listLayers = group.children()
to_delete = []
for i in listLayers:
#print(i.name(), i.layer().id())
if i.name() == name:
to_delete.append(i.layer().id())
QgsProject.instance().removeMapLayers(to_delete)
vl = QgsVectorLayer(filename, name)
crs = QgsCoordinateReferenceSystem(
3857, QgsCoordinateReferenceSystem.PostgisCrsId)
nameShape_folder = os.path.dirname(
QgsProject.instance().fileName())
nameShape_filename = os.path.basename(filename).split(
".")[0] + ".shp"
nameShape = os.path.join(nameShape_folder,
nameShape_filename)
QgsVectorFileWriter.writeAsVectorFormat(vl,
nameShape,
"utf-8",
crs,
"ESRI Shapefile",
onlySelected=False)
vl = QgsVectorLayer(nameShape, name)
QgsProject.instance().addMapLayer(vl, False)
group.addLayer(vl)
return vl
for path, subdirs, files in os.walk(tmpdirname +
"intersections"):
for name in files:
f = os.path.join(path, name)
g = addGroupIfNotExist(
name.split("-")[0], intersections)
layer = addFileJsonInLayer(f, g, name.split(".")[0])
if "connectsTo" in layer.name():
layer.loadNamedStyle(
':/plugins/view_mapem/styles/intersections/connectsTo.qml'
)
layer.triggerRepaint()
if "GenericLane" in layer.name():
layer.loadNamedStyle(
':/plugins/view_mapem/styles/intersections/GenericLane.qml'
)
layer.triggerRepaint()
if "nodeList" in layer.name():
layer.loadNamedStyle(
':/plugins/view_mapem/styles/intersections/nodeList.qml'
)
layer.triggerRepaint()
if "refPoint" in layer.name():
layer.loadNamedStyle(
':/plugins/view_mapem/styles/intersections/refPoint.qml'
)
layer.triggerRepaint()
for path, subdirs, files in os.walk(tmpdirname +
"roadSegments"):
for name in files:
f = os.path.join(path, name)
g = addGroupIfNotExist(
name.split("-")[0], roadSegments)
layer = addFileJsonInLayer(f, g, name.split(".")[0])
if "connectsTo" in layer.name():
layer.loadNamedStyle(
':/plugins/view_mapem/styles/roadSegments/connectsTo.qml'
)
layer.triggerRepaint()
if "GenericLane" in layer.name():
layer.loadNamedStyle(
':/plugins/view_mapem/styles/roadSegments/GenericLane.qml'
)
layer.triggerRepaint()
if "nodeList" in layer.name():
layer.loadNamedStyle(
':/plugins/view_mapem/styles/roadSegments/nodeList.qml'
)
layer.triggerRepaint()
if "refPoint" in layer.name():
layer.loadNamedStyle(
':/plugins/view_mapem/styles/roadSegments/refPoint.qml'
)
layer.triggerRepaint()
# Settign the CRS of the data set option 1
canvas = self.iface.mapCanvas()
selectedcrs = "EPSG:3857"
target_crs = QgsCoordinateReferenceSystem()
target_crs.createFromUserInput(selectedcrs)
canvas.setDestinationCrs(target_crs)
outputinfo = "Импортирование завершено."
Q = QMessageBox(self.iface.mainWindow())
Q = QMessageBox.information(Q, 'Import from MAPEM', outputinfo,
QMessageBox.Ok)
def run(self):
"""Run method that loads and starts the plugin"""
if not iface.building_toolbar:
# Set up toolbar
iface.building_toolbar = QToolBar(u"Building Tools")
iface.addToolBar(iface.building_toolbar, Qt.RightToolBarArea)
# Create the dockwidget and dialog and keep reference
if not self.dockwidget:
self.dockwidget = BuildingsDockwidget()
# Connect with close
self.dockwidget.closed.connect(self.on_dockwidget_closed)
# Show the dockwidget as a tab
layerdock = iface.mainWindow().findChild(QDockWidget, "Layers")
iface.addDockWidget(Qt.LeftDockWidgetArea, self.dockwidget)
iface.mainWindow().tabifyDockWidget(layerdock, self.dockwidget)
self.setup_main_toolbar()
dw = self.dockwidget
# no base layers
self.menu_frame = MenuFrame(self.dockwidget)
dw.insert_into_frames("menu_frame", self.menu_frame)
home_dir = os.path.dirname(__file__)
if dw.lst_options.item(0) is None:
icon_path = os.path.join(home_dir, "icons",
"buildings_plugin.png")
item = QListWidgetItem("Buildings")
item.setIcon(QIcon(icon_path))
dw.lst_options.addItem(item)
dw.lst_options.setCurrentItem(item)
icon_path = os.path.join(home_dir, "icons", "capture_source.png")
item = QListWidgetItem("Capture Sources")
item.setIcon(QIcon(icon_path))
dw.lst_sub_menu.addItem(item)
icon_path = os.path.join(home_dir, "icons", "bulk_load.png")
item = QListWidgetItem("Bulk Load")
item.setIcon(QIcon(icon_path))
dw.lst_sub_menu.addItem(item)
icon_path = os.path.join(home_dir, "icons", "edit.png")
item = QListWidgetItem("Edit Outlines")
item.setIcon(QIcon(icon_path))
dw.lst_sub_menu.addItem(item)
icon_path = os.path.join(home_dir, "icons", "settings.png")
item = QListWidgetItem("Settings")
item.setIcon(QIcon(icon_path))
dw.lst_sub_menu.addItem(item)
icon_path = os.path.join(home_dir, "icons", "reference.png")
item = QListWidgetItem("Reference Data")
item.setIcon(QIcon(icon_path))
dw.lst_sub_menu.addItem(item)
canvas = iface.mapCanvas()
selectedcrs = "EPSG:2193"
target_crs = QgsCoordinateReferenceSystem()
target_crs.createFromUserInput(selectedcrs)
canvas.setDestinationCrs(target_crs)
self.on_click()
self.dockwidget.show()
self.dockwidget.raise_()
options['overwrite'] = True
options['lowercaseFieldNames'] = True
options['dropStringConstraints'] = True
createIndex = True
#clear geometry column for non-geometry tables
if not layer.hasGeometryType():
geomColumn = None
# Import de la couche
#self.importTable(db, table, schema, primaryKeyField, geomColumn, options)
uri = QgsDataSourceURI()
uri.setConnection(host, str(port), database, username, password)
newCrs = QgsCoordinateReferenceSystem()
newCrs.createFromUserInput(u"EPSG:2154")
#Gid = cle primaire par defaut
uri.setDataSource(schema, table, geomColumn, '', "gid")
progress.setInfo(u"Importation de la table vers PostgreSQL (cela peut prendre un moment)")
#Import
(ret, errMsg) = QgsVectorLayerImport.importLayer(
layer,
uri.uri(),
providerName,
newCrs,
False,
False,
options,
class QgsMapToolCaptureSpatialOperand (QgsMapTool):
"""
QGIS map tool. Draw a point, line, polygon or bounding box
and convert it to WKT format.
"""
selectionFinished = QtCore.pyqtSignal(str)
def __init__(self, canvas, gmlOperand = "gml:Envelope", srsName="", parent = None):
QgsMapTool.__init__ (self, canvas)
self.canvas = canvas
self.parent = parent
if gmlOperand == "gml:Point":
self.minPoints = 1
self.maxPoints = 1
self.isPolygon = False
elif gmlOperand == "gml:Envelope":
self.minPoints = 2
self.maxPoints = 2
self.isPolygon = True
elif gmlOperand == "gml:Polygon":
self.minPoints = 3
self.maxPoints = 0
self.isPolygon = True
elif gmlOperand == "gml:LineString":
self.minPoints = 2
self.maxPoints = 0
self.isPolygon = False
else:
pass
self.srsName = srsName
self.rect = QtCore.QRect() if self.isPolygon and self.maxPoints == 2 else None
if self.isPolygon:
self.rubberBand = QgsRubberBand(self.canvas, QGis.Polygon)
else:
self.rubberBand = QgsRubberBand(self.canvas, QGis.Line)
self.rubberBand.setColor(QtGui.QColor (255, 0,0, 150))
self.rubberBand.setWidth(1)
self.cursor = QtGui.QCursor (QtCore.Qt.CrossCursor)
self.vertexMarkers = []
self.captureList = []
self.crs = QgsCoordinateReferenceSystem()
self.crs.createFromUserInput(self.srsName)
self.yx = self.crs.axisInverted()
def canvasPressEvent(self, event):
pass
def canvasMoveEvent(self, event):
if isinstance (self.rect, QtCore.QRect):
self.rect.setBottomRight(event.pos())
self.moveVertex(self.toMapCoordinates(event.pos()))
def canvasReleaseEvent(self, event):
numPoints = self.addVertex(self.toMapCoordinates(event.pos()))
if numPoints == 1 and isinstance (self.rect, QtCore.QRect):
self.rect.setTopLeft(event.pos())
if (event.button() == QtCore.Qt.RightButton and numPoints >= self.minPoints) or \
(numPoints == self.maxPoints):
self.finishGeom (numPoints)
def keyReleaseEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.selectionFinished.emit(None)
def activate(self):
QgsMapTool.activate(self)
self.canvas.setCursor(self.cursor)
def deactivate(self):
QgsMapTool.deactivate(self)
self.canvas.unsetCursor()
self.clearMapCanvas()
def isZoomTool(self):
return False
def isTransient(self):
return False
def isEditTool(self):
return False
def addVertex(self, pt):
self.rubberBand.addPoint(pt)
m = QgsVertexMarker(self.canvas)
m.setCenter(pt)
self.vertexMarkers.append(m)
#if self.yx: pt = QgsPoint(pt.y(),pt.x())
self.captureList.append (pt)
return len(self.captureList)
def moveVertex(self, pt):
if self.rubberBand.numberOfVertices() > 1:
if isinstance (self.rect, QtCore.QRect):
transform = self.canvas.getCoordinateTransform()
ll = transform.toMapCoordinates( self.rect.left(), self.rect.bottom() );
ur = transform.toMapCoordinates( self.rect.right(), self.rect.top() );
self.rubberBand.reset(QGis.Polygon)
self.rubberBand.addPoint( ll, False )
self.rubberBand.addPoint( QgsPoint( ur.x(), ll.y() ), False )
self.rubberBand.addPoint( ur, False )
self.rubberBand.addPoint( QgsPoint( ll.x(), ur.y() ), True )
else:
self.rubberBand.movePoint(pt)
def finishGeom (self, numPoints):
if self.maxPoints == 1:
geom = QgsGeometry.fromPoint(self.captureList[0])
elif self.isPolygon and numPoints == 2:
geom = QgsGeometry.fromPolyline(self.captureList)
#geom = QgsGeometry.fromRect(geom.boundingBox())
elif self.isPolygon:
geom = QgsGeometry.fromPolygon([self.captureList])
else:
geom = QgsGeometry.fromPolyline(self.captureList)
geom.simplify(0.00001)
geom.transform(QgsCoordinateTransform(
self.canvas.mapSettings().destinationCrs(),
self.crs))
if self.yx:
i = 0
vertex = geom.vertexAt(i)
while (vertex != QgsPoint(0,0)):
x = vertex.x()
y = vertex.y()
geom.moveVertex(y, x, i)
i+=1
vertex = geom.vertexAt(i)
self.selectionFinished.emit(geom.exportToWkt())
self.clearMapCanvas()
def clearMapCanvas(self):
"""
Clears the map canvas and in particular the rubberband.
A warning is thrown when the markers are removed.
"""
# Reset the capture list
self.captureList = []
# Create an empty rubber band
if self.isPolygon:
self.rubberBand.reset(QGis.Polygon)
else:
self.rubberBand.reset(QGis.Line)
# Delete also all vertex markers
for marker in self.vertexMarkers:
self.canvas.scene().removeItem(marker)
del marker
self.canvas.refresh()
class QgsMapToolCaptureSpatialOperand(QgsMapTool):
"""
QGIS map tool. Draw a point, line, polygon or bounding box
and convert it to WKT format.
"""
selectionFinished = QtCore.pyqtSignal(str)
def __init__(self,
canvas,
gmlOperand="gml:Envelope",
srsName="",
parent=None):
QgsMapTool.__init__(self, canvas)
self.canvas = canvas
self.parent = parent
if gmlOperand == "gml:Point":
self.minPoints = 1
self.maxPoints = 1
self.isPolygon = False
elif gmlOperand == "gml:Envelope":
self.minPoints = 2
self.maxPoints = 2
self.isPolygon = True
elif gmlOperand == "gml:Polygon":
self.minPoints = 3
self.maxPoints = 0
self.isPolygon = True
elif gmlOperand == "gml:LineString":
self.minPoints = 2
self.maxPoints = 0
self.isPolygon = False
else:
pass
self.srsName = srsName
self.rect = QtCore.QRect(
) if self.isPolygon and self.maxPoints == 2 else None
if self.isPolygon:
self.rubberBand = QgsRubberBand(self.canvas, QGis.Polygon)
else:
self.rubberBand = QgsRubberBand(self.canvas, QGis.Line)
self.rubberBand.setColor(QtGui.QColor(255, 0, 0, 150))
self.rubberBand.setWidth(1)
self.cursor = QtGui.QCursor(QtCore.Qt.CrossCursor)
self.vertexMarkers = []
self.captureList = []
self.crs = QgsCoordinateReferenceSystem()
self.crs.createFromUserInput(self.srsName)
self.yx = self.crs.axisInverted()
def canvasPressEvent(self, event):
pass
def canvasMoveEvent(self, event):
if isinstance(self.rect, QtCore.QRect):
self.rect.setBottomRight(event.pos())
self.moveVertex(self.toMapCoordinates(event.pos()))
def canvasReleaseEvent(self, event):
numPoints = self.addVertex(self.toMapCoordinates(event.pos()))
if numPoints == 1 and isinstance(self.rect, QtCore.QRect):
self.rect.setTopLeft(event.pos())
if (event.button() == QtCore.Qt.RightButton and numPoints >= self.minPoints) or \
(numPoints == self.maxPoints):
self.finishGeom(numPoints)
def keyReleaseEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.selectionFinished.emit(None)
def activate(self):
QgsMapTool.activate(self)
self.canvas.setCursor(self.cursor)
def deactivate(self):
QgsMapTool.deactivate(self)
self.canvas.unsetCursor()
self.clearMapCanvas()
def isZoomTool(self):
return False
def isTransient(self):
return False
def isEditTool(self):
return False
def addVertex(self, pt):
self.rubberBand.addPoint(pt)
m = QgsVertexMarker(self.canvas)
m.setCenter(pt)
self.vertexMarkers.append(m)
#if self.yx: pt = QgsPoint(pt.y(),pt.x())
self.captureList.append(pt)
return len(self.captureList)
def moveVertex(self, pt):
if self.rubberBand.numberOfVertices() > 1:
if isinstance(self.rect, QtCore.QRect):
transform = self.canvas.getCoordinateTransform()
ll = transform.toMapCoordinates(self.rect.left(),
self.rect.bottom())
ur = transform.toMapCoordinates(self.rect.right(),
self.rect.top())
self.rubberBand.reset(QGis.Polygon)
self.rubberBand.addPoint(ll, False)
self.rubberBand.addPoint(QgsPoint(ur.x(), ll.y()), False)
self.rubberBand.addPoint(ur, False)
self.rubberBand.addPoint(QgsPoint(ll.x(), ur.y()), True)
else:
self.rubberBand.movePoint(pt)
def finishGeom(self, numPoints):
if self.maxPoints == 1:
geom = QgsGeometry.fromPoint(self.captureList[0])
elif self.isPolygon and numPoints == 2:
geom = QgsGeometry.fromPolyline(self.captureList)
#geom = QgsGeometry.fromRect(geom.boundingBox())
elif self.isPolygon:
geom = QgsGeometry.fromPolygon([self.captureList])
else:
geom = QgsGeometry.fromPolyline(self.captureList)
geom.simplify(0.00001)
geom.transform(
QgsCoordinateTransform(self.canvas.mapSettings().destinationCrs(),
self.crs))
if self.yx:
i = 0
vertex = geom.vertexAt(i)
while (vertex != QgsPoint(0, 0)):
x = vertex.x()
y = vertex.y()
geom.moveVertex(y, x, i)
i += 1
vertex = geom.vertexAt(i)
self.selectionFinished.emit(geom.exportToWkt())
self.clearMapCanvas()
def clearMapCanvas(self):
"""
Clears the map canvas and in particular the rubberband.
A warning is thrown when the markers are removed.
"""
# Reset the capture list
self.captureList = []
# Create an empty rubber band
if self.isPolygon:
self.rubberBand.reset(QGis.Polygon)
else:
self.rubberBand.reset(QGis.Line)
# Delete also all vertex markers
for marker in self.vertexMarkers:
self.canvas.scene().removeItem(marker)
del marker
self.canvas.refresh()
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)
