def azimuth(self):
punto1 = self.dlg.lineEdit1.text()
punto2 = self.dlg.lineEdit2.text()
if (punto1 == "" or punto2 == ""):
QMessageBox.information(self.iface.mainWindow(), "Error",
"Without coordinates")
else:
x1 = float(punto1.split(",")[0])
y1 = float(punto1.split(",")[1])
x2 = float(punto2.split(",")[0])
y2 = float(punto2.split(",")[1])
# create points objects
p1 = QgsPoint(x1, y1)
p2 = QgsPoint(x2, y2)
az = round(p1.azimuth(p2), 2)
if (az < 0):
self.dlg.lineEditAzimuth.setText(
str(az) + " (" + str(360 + az) + ")")
else:
self.dlg.lineEditAzimuth.setText(str(az))
# calculate distance
points = [p1, p2]
line = QgsGeometry.fromPolyline(points)
d = QgsDistanceArea()
crs = QgsProject.instance().crs() # asigna el crs del proyecto
# comprobar si es dd (6)
if (crs.mapUnits() == 6):
# es dd
d.setEllipsoid('WGS84')
m = round(d.measureLength(line), 4)
else: # projectada
m = round(d.measureLength(line), 4)
self.dlg.lineEditDistance.setText(str(m))
self.iface.actionPan().trigger() # vuelve el cursor al pan
#Drawing Polyline
polyline = QgsRubberBand(self.canvas,
False) # False = not a polygon
points = [QgsPoint(x1, y1), QgsPoint(x2, y2)]
polyline.setToGeometry(QgsGeometry.fromPolyline(points), None)
polyline.setColor(QColor(255, 0, 0))
polyline.setWidth(3)
"""
def arc(p1, p2, offset=1):
# point in middle
mp = QgsPoint((p1.x() + p2.x()) / 2, (p1.y() + p2.y()) / 2)
# distance between the two points
d = sqrt(p1.sqrDist(p2))
# orthogonal direction to segment p1-p2
az = (p1.azimuth(p2) + 90) * pi / 180
# create point distant to segment of offset of segment length, will be center of circular arc
cp = QgsPoint(mp.x() + d * offset * sin(az), mp.y() + d * offset * cos(az))
# radius
r = d * sqrt(4 * offset * offset + 1) / 2
# calculate start and end azimuth of circular arc
az1 = cp.azimuth(p1)
az2 = cp.azimuth(p2)
if az2 < az1:
az2 += 360
# draw arc
vx = [cp.x() + r * sin(az * pi / 180) for az in floatrange(az1, az2, 5)]
vy = [cp.y() + r * cos(az * pi / 180) for az in floatrange(az1, az2, 5)]
arcLine = [QgsPoint(vx[i], vy[i]) for i in range(len(vx))]
return QgsGeometry().fromPolyline(arcLine)
def arc(p1, p2, offset=1):
# point in middle
mp = QgsPoint((p1.x()+p2.x())/2, (p1.y()+p2.y())/2)
# distance between the two points
d = sqrt(p1.sqrDist(p2))
# orthogonal direction to segment p1-p2
az = (p1.azimuth(p2)+90)*pi/180
# create point distant to segment of offset of segment length, will be center of circular arc
cp = QgsPoint(mp.x()+d*offset*sin(az),
mp.y()+d*offset*cos(az))
# radius
r = d*sqrt(4*offset*offset+1)/2
# calculate start and end azimuth of circular arc
az1 = cp.azimuth(p1)
az2 = cp.azimuth(p2)
if az2 < az1:
az2 += 360
# draw arc
vx = [cp.x()+r*sin(az*pi/180) for az in floatrange(az1, az2, 5)]
vy = [cp.y()+r*cos(az*pi/180) for az in floatrange(az1, az2, 5)]
arcLine = [QgsPoint(vx[i], vy[i]) for i in range(len(vx))]
return QgsGeometry().fromPolyline(arcLine)
def testMeasureLineProjected(self):
# +-+
# | |
# +-+ +
# test setting/getting the source CRS
da_3068 = QgsDistanceArea()
da_wsg84 = QgsDistanceArea()
da_3068.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:3068'))
if (da_3068.sourceCrs().isGeographic()):
da_3068.setEllipsoid(da_3068.sourceCrs().ellipsoidAcronym())
print(("setting [{}] srid [{}] description [{}]".format(u'Soldner Berlin', da_3068.sourceCrs().authid(), da_3068.sourceCrs().description())))
self.assertEqual(da_3068.sourceCrs().authid(), 'EPSG:3068')
da_wsg84.setSourceCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:4326'))
if (da_wsg84.sourceCrs().isGeographic()):
da_wsg84.setEllipsoid(da_wsg84.sourceCrs().ellipsoidAcronym())
self.assertEqual(da_wsg84.sourceCrs().authid(), 'EPSG:4326')
print(("setting [{}] srid [{}] description [{}] isGeographic[{}]".format(u'Wsg84', da_wsg84.sourceCrs().authid(), da_wsg84.sourceCrs().description(), da_wsg84.sourceCrs().isGeographic())))
# print(("-- projectionAcronym[{}] ellipsoidAcronym[{}] toWkt[{}] mapUnits[{}] toProj4[{}]".format(da_wsg84.sourceCrs().projectionAcronym(),da_wsg84.sourceCrs().ellipsoidAcronym(), da_wsg84.sourceCrs().toWkt(),da_wsg84.sourceCrs().mapUnits(),da_wsg84.sourceCrs().toProj4())))
print(("Testing Position change for[{}] years[{}]".format(u'Ampelanlage - Potsdamer Platz, Verkehrsinsel', u'1924 and 1998')))
# 1924-10-24 SRID=3068;POINT(23099.49 20296.69)
# 1924-10-24 SRID=4326;POINT(13.37650707988041 52.50952361017194)
# 1998-10-02 SRID=3068;POINT(23082.30 20267.80)
# 1998-10-02 SRID=4326;POINT(13.37625537334001 52.50926345498337)
# values returned by spatialite
point_soldner_1924 = QgsPoint(23099.49, 20296.69)
point_soldner_1998 = QgsPoint(23082.30, 20267.80)
distance_soldner_meters = 33.617379
azimuth_soldner_1924 = 3.678339
# ST_Transform(point_soldner_1924,point_soldner_1998,4326)
point_wsg84_1924 = QgsPoint(13.37650707988041, 52.50952361017194)
point_wsg84_1998 = QgsPoint(13.37625537334001, 52.50926345498337)
# ST_Distance(point_wsg84_1924,point_wsg84_1998,1)
distance_wsg84_meters = 33.617302
# ST_Distance(point_wsg84_1924,point_wsg84_1998)
# distance_wsg84_mapunits=0.000362
distance_wsg84_mapunits_format = QgsDistanceArea.formatDistance(0.000362, 7, QgsUnitTypes.DistanceDegrees, True)
# ST_Azimuth(point_wsg84_1924,point_wsg84_1998)
azimuth_wsg84_1924 = 3.674878
# ST_Azimuth(point_wsg84_1998,point_wsg84_1998)
azimuth_wsg84_1998 = 0.533282
# ST_Project(point_wsg84_1924,33.617302,3.674878)
# SRID=4326;POINT(13.37625537318728 52.50926345503591)
point_soldner_1998_project = QgsPoint(13.37625537318728, 52.50926345503591)
# ST_Project(point_wsg84_1998,33.617302,0.533282)
# SRID=4326;POINT(13.37650708009255 52.50952361009799)
point_soldner_1924_project = QgsPoint(13.37650708009255, 52.50952361009799)
distance_qpoint = point_soldner_1924.distance(point_soldner_1998)
azimuth_qpoint = point_soldner_1924.azimuth(point_soldner_1998)
point_soldner_1998_result = point_soldner_1924.project(distance_qpoint, azimuth_qpoint)
point_soldner_1924_result = QgsPoint(0, 0)
point_soldner_1998_result = QgsPoint(0, 0)
# Test meter based projected point from point_1924 to point_1998
length_1998_mapunits, point_soldner_1998_result = da_3068.measureLineProjected(point_soldner_1924, distance_soldner_meters, azimuth_qpoint)
self.assertEqual(point_soldner_1998_result.toString(6), point_soldner_1998.toString(6))
# Test degree based projected point from point_1924 1 meter due East
point_wsg84_meter_result = QgsPoint(0, 0)
point_wsg84_1927_meter = QgsPoint(13.37652180838435, 52.50952361017102)
length_meter_mapunits, point_wsg84_meter_result = da_wsg84.measureLineProjected(point_wsg84_1924, 1.0, (math.pi / 2))
self.assertEqual(QgsDistanceArea.formatDistance(length_meter_mapunits, 7, QgsUnitTypes.DistanceDegrees, True), '0.0000147 deg')
self.assertEqual(point_wsg84_meter_result.toString(7), point_wsg84_1927_meter.toString(7))
point_wsg84_1998_result = QgsPoint(0, 0)
length_1928_mapunits, point_wsg84_1998_result = da_wsg84.measureLineProjected(point_wsg84_1924, distance_wsg84_meters, azimuth_wsg84_1924)
self.assertEqual(QgsDistanceArea.formatDistance(length_1928_mapunits, 7, QgsUnitTypes.DistanceDegrees, True), distance_wsg84_mapunits_format)
self.assertEqual(point_wsg84_1998_result.toString(7), point_wsg84_1998.toString(7))
def passPointSeek(crete_layer, ID_crete, dem_layer, PassagePoint):
"""Seeks passage points (peak, col) along ridge
Extract all points of interest (start of line, end of line, peak, pass) from polyline layer
"""
# Load ridge line layer
inCRS = crete_layer.crs().authid()
crs = QgsCoordinateReferenceSystem(inCRS)
# Load dem_layer layer
x_res = dem_layer.rasterUnitsPerPixelX()
y_res = dem_layer.rasterUnitsPerPixelY()
# Create memory layer to store result
pointPassage = QgsVectorLayer("Point", "point", 'memory')
pointPassage.setCrs(crs)
name_T_id = "T_id"
name_L_id = "L_id"
name_P_id = "P_id"
name_nat = "nature"
provider = pointPassage.dataProvider()
caps = provider.capabilities()
if caps & QgsVectorDataProvider.AddAttributes:
res = provider.addAttributes([
QgsField(name_T_id, QVariant.String),
QgsField(name_L_id, QVariant.String),
QgsField(name_P_id, QVariant.String),
QgsField(name_nat, QVariant.String)
])
pointPassage.updateFields()
pointPassage.startEditing()
# Loop over features
for feature in crete_layer.getFeatures():
feat_L_id = feature.attribute(ID_crete)
geomType = feature.geometry().wkbType()
if geomType == 2:
geom = feature.geometry().asPolyline()
nb = len(geom)
geom_clean = feature.geometry().asPolyline()
ind = 0
for i in range(0, nb - 1):
pt1 = geom[i]
x1 = pt1.x()
if x1 % 10 == 2:
x1 += 0.5
elif x1 % 10 == 8:
x1 += -0.5
y1 = pt1.y()
if y1 % 10 == 2:
y1 += 0.5
elif y1 % 10 == 8:
y1 += -0.5
pt2 = geom[i + 1]
x2 = pt2.x()
if x2 % 10 == 2:
x2 += 0.5
elif x2 % 10 == 8:
x2 += -0.5
y2 = pt2.y()
if y2 % 10 == 2:
y2 += 0.5
elif y2 % 10 == 8:
y2 += -0.5
pt1 = QgsPoint(x1, y1)
pt2 = QgsPoint(x2, y2)
dist = math.sqrt(pt1.sqrDist(pt2))
if dist > math.sqrt(x_res * x_res + y_res * y_res) + 1:
azimuth = pt1.azimuth(pt2)
if azimuth % 10 != 0:
decoup_dist = math.sqrt(x_res * x_res + y_res * y_res)
else:
decoup_dist = x_res
tot_distance = 0
pts = []
while tot_distance / x_res < dist / x_res:
tot_distance += decoup_dist
xv = round(tot_distance *
math.sin(math.radians(azimuth)))
yv = round(tot_distance *
math.cos(math.radians(azimuth)))
# print xv, yv, tot_distance, azimuth, x1, y1, x2, y2
pt = QgsPoint(pt1.x() + xv, pt1.y() + yv)
pts.append(pt)
pt1_elev = dem_layer.dataProvider().identify(
pt1, QgsRaster.IdentifyFormatValue)
pt2_elev = dem_layer.dataProvider().identify(
pt2, QgsRaster.IdentifyFormatValue)
min_elev = min(pt1_elev, pt2_elev)
max_elev = max(pt1_elev, pt2_elev)
points_elev = []
min_list = None
max_list = None
max_id = None
min_id = None
for j, point in enumerate(pts):
elev = dem_layer.dataProvider().identify(
point, QgsRaster.IdentifyFormatValue)
if elev < min_elev:
if min_list == None or elev < min_list:
min_list = elev
min_id = j
if elev > max_elev:
if max_list == None or elev < max_list:
max_list = elev
max_id = j
if max_id != None and min_id != None:
if max_id < min_id:
geom_clean.insert(i + 1 + ind, pts[max_id])
geom_clean.insert(i + 2 + ind, pts[min_id])
ind += 2
else:
geom_clean.insert(i + 2 + ind, pts[min_id])
geom_clean.insert(i + 1 + ind, pts[max_id])
ind += 2
elif max_id != None and min_id == None:
geom_clean.insert(i + 1 + ind, pts[max_id])
ind += 1
elif min_id != None and max_id == None:
geom_clean.insert(i + 1 + ind, pts[min_id])
ind += 1
nb = len(geom_clean)
elev_list = []
for point in geom_clean:
elev = dem_layer.dataProvider().identify(
point, QgsRaster.IdentifyFormatValue)
elev_list.append(elev.results()[1])
count = 0
for i in range(0, nb):
feat_point = QgsFeature()
try:
if i == 0:
feat_point.setGeometry(QgsGeometry.fromPoint(geom[0]))
nat = 's'
t_id = 'l' + str(feat_L_id) + 'p' + str(count) + nat
feat_point.setAttributes(
[t_id, feat_L_id, count, 'start'])
count += 1
pointPassage.dataProvider().addFeatures([feat_point])
elif i == nb - 1:
feat_point.setGeometry(QgsGeometry.fromPoint(geom[-1]))
nat = 'e'
t_id = 'l' + str(feat_L_id) + 'p' + str(count) + nat
feat_point.setAttributes(
[t_id, feat_L_id, count, 'end'])
count += 1
pointPassage.dataProvider().addFeatures([feat_point])
elif i < 3:
pass
elif i > nb - 3:
pass
else:
feat_point.setGeometry(
QgsGeometry.fromPoint(geom_clean[i]))
min_elev1 = min(elev_list[i - 3], elev_list[i - 2],
elev_list[i - 1])
min_elev2 = min(elev_list[i + 3], elev_list[i + 2],
elev_list[i + 1])
max_elev1 = max(elev_list[i - 3], elev_list[i - 2],
elev_list[i - 1])
max_elev2 = max(elev_list[i + 3], elev_list[i + 2],
elev_list[i + 1])
if elev_list[i] < min_elev1 and elev_list[
i] <= min_elev2:
nat = 'd'
t_id = 'l' + str(feat_L_id) + 'p' + str(
count) + nat
feat_point.setAttributes(
[t_id, feat_L_id, count, 'col'])
count += 1
pointPassage.dataProvider().addFeatures(
[feat_point])
if elev_list[i] >= max_elev1 and elev_list[
i] > max_elev2:
nat = 't'
t_id = 'l' + str(feat_L_id) + 'p' + str(
count) + nat
feat_point.setAttributes(
[t_id, feat_L_id, count, 'pic'])
count += 1
pointPassage.dataProvider().addFeatures(
[feat_point])
pointPassage.commitChanges()
pointPassage.updateExtents()
except:
pass
else:
print 'PPS: no multiline'
return pointPassage, crs, dem_layer
