def paint_extent(self, rec):
self.roi_x_max = rec.xMaximum()
self.ui.XMaxLineEdit.setText(str(round(rec.xMaximum(), 3)))
self.roi_y_min = rec.yMinimum()
self.ui.YMinLineEdit.setText(str(round(rec.yMinimum(), 3)))
self.roi_x_min = rec.xMinimum()
self.ui.XMinLineEdit.setText(str(round(rec.xMinimum(), 3)))
self.roi_y_max = rec.yMaximum()
self.ui.YMaxLineEdit.setText(str(round(rec.yMaximum(), 3)))
if self.extent:
self.canvas.scene().removeItem(self.extent)
self.extent = None
self.extent = QgsRubberBand(self.canvas, True)
points = [
QgsPoint(self.roi_x_max, self.roi_y_min),
QgsPoint(self.roi_x_max, self.roi_y_max),
QgsPoint(self.roi_x_min, self.roi_y_max),
QgsPoint(self.roi_x_min, self.roi_y_min),
QgsPoint(self.roi_x_max, self.roi_y_min)
]
self.extent.setToGeometry(QgsGeometry.fromPolyline(points), None)
self.extent.setColor(QColor(227, 26, 28, 255))
self.extent.setWidth(5)
self.extent.setLineStyle(Qt.PenStyle(Qt.DashLine))
self.canvas.refresh()
def run(self):
area_type_dict = {} # (key: area_type, value: nsite index list)
d = QgsDistanceArea() # 计算距离
allNSiteFeatures = getFeaturesList(self.nsiteLayer)
# 把所有的nsite按区域类型分类
for nsiteFeature in allNSiteFeatures:
area_type = nsiteFeature[u"区域类型"]
if area_type not in [u"普通市区", u"密集市区", u"农村", u"郊区乡镇"]:
area_type = u"普通市区"
if not area_type_dict.has_key(area_type):
area_type_dict[area_type] = [nsiteFeature]
else:
t = area_type_dict[area_type]
t.append(nsiteFeature)
area_type_dict[area_type] = t
del t
total = len(allNSiteFeatures) # 写进度条
progess = Progess(self.parent, total, u"优化中...")
progess.show()
delete_list = [] # 要删除的 nsiteFeaures.id() list
for (area_type, nsiteFeatures_list) in area_type_dict.items():
if area_type == u"密集市区":
mergeDis = 200
elif area_type == u"郊区乡镇":
mergeDis = 500
elif area_type == u"农村":
mergeDis = 800
else:
# 默认普通市区
mergeDis = 300
for nsiteFeatures1 in nsiteFeatures_list:
progess.count()
lon1 = nsiteFeatures1[u"经度"]
lat1 = nsiteFeatures1[u"纬度"]
point1 = QgsPoint(float(lon1), float(lat1))
rectangle = createARectangleByCenterPoint(point1, 2000)
if nsiteFeatures1.id() in delete_list:
progess.count()
continue
else:
request = QgsFeatureRequest()
request.setFilterRect(rectangle)
for nsiteFeature2 in self.nsiteLayer.getFeatures(request):
if nsiteFeatures1.id() == nsiteFeature2.id():
continue
if nsiteFeature2.id() in delete_list:
continue
lon2 = nsiteFeatures1[u"经度"]
lat2 = nsiteFeatures1[u"纬度"]
point2 = QgsPoint(float(lon2), float(lat2))
distance = d.convertMeasurement(
d.measureLine(point1, point2), 2, 0, False)[0]
if distance <= mergeDis:
delete_list.append(nsiteFeature2.id())
break
progess.kill()
# 删除features
delFeatures(self.nsiteLayer, delete_list)
return True
def gera_tracado_pontos(self,
inicial=False,
final=False,
callback_inst=None,
callback_method=None,
crs=None):
if (not (inicial) and not (final)):
self.callback = eval('callback_inst.%s' % callback_method)
self.crs = crs
self.tracado_dlg_inicial = GeraTracadoUI(self.iface)
self.tracado_dlg_inicial.lblName.setText("Ponto Inicial")
self.tracado_dlg_inicial.btnCapture.clicked.connect(
self.capture_point_inicial)
self.tracado_dlg_final = GeraTracadoUI(self.iface)
self.tracado_dlg_final.lblName.setText("Ponto Final")
self.tracado_dlg_final.btnCapture.clicked.connect(
self.capture_point_final)
if (not (inicial) and not (final)) or not (final):
ok = self.tracado_dlg_inicial.exec_()
if not (ok):
return None
else:
pn = float(
self.tracado_dlg_inicial.txtNorth.text().strip().replace(
",", "."))
pe = float(
self.tracado_dlg_inicial.txtEste.text().strip().replace(
",", "."))
self.gera_tracado_ponto_inicial(QgsPoint(pe, pn))
if (not (inicial) and not (final)) or not (inicial):
ok = self.tracado_dlg_final.exec_()
if not (ok):
return None
else:
pn = float(
self.tracado_dlg_final.txtNorth.text().strip().replace(
",", "."))
pe = float(
self.tracado_dlg_final.txtEste.text().strip().replace(
",", "."))
self.gera_tracado_ponto_final(QgsPoint(pe, pn))
if inicial and final:
p1n = float(
self.tracado_dlg_inicial.txtNorth.text().strip().replace(
",", "."))
p1e = float(
self.tracado_dlg_inicial.txtEste.text().strip().replace(
",", "."))
p2n = float(self.tracado_dlg_final.txtNorth.text().strip().replace(
",", "."))
p2e = float(self.tracado_dlg_final.txtEste.text().strip().replace(
",", "."))
self.iface.mapCanvas().setMapTool(None)
self.callback(pontos=self.create_line(QgsPoint(p1e, p1n),
QgsPoint(p2e, p2n),
"Diretriz"),
parte=1)
def get_click_coordenate(self, point, mouse):
self.actual_point = QgsPoint(point)
if self.tracado_dlg.txtNorthStart.text().strip() == '':
self.tracado_dlg.txtNorthStart.setText("%f" %
self.actual_point.y())
self.tracado_dlg.txtEsteStart.setText("%f" % self.actual_point.x())
elif self.tracado_dlg.txtNorthEnd.text().strip() == '':
self.tracado_dlg.txtNorthEnd.setText("%f" % self.actual_point.y())
self.tracado_dlg.txtEsteEnd.setText("%f" % self.actual_point.x())
def canvasReleaseEvent(self, event: QgsMapMouseEvent):
if event.button() == Qt.RightButton:
self.endcapture()
return
if not self.editmode:
point = QgsPoint(event.snapPoint())
point.addZValue(0)
self.add_point(point)
else:
self.editvertex = None
self.update_valid_state()
def createARectangleByCenterPoint(centerPoint, mradius):
x0 = centerPoint.x()
y0 = centerPoint.y()
delta_x = (1.0 / 111000.0 * mradius)
delta_y = (1.0 / 111000.0 * mradius * math.cos(y0))
x1 = x0 - delta_x
y1 = y0 - delta_y
point1 = QgsPoint(x1, y1)
x2 = x0 + delta_x
y2 = y0 + delta_y
point2 = QgsPoint(x2, y2)
rectangle = QgsRectangle(point1, point2)
return rectangle
def gera_estaca_intermediaria(self,
estaca,
anterior,
prog,
az,
cosa,
cosb,
sobra=0.0):
dist = sobra if sobra > 0 else self.distancia
p = QgsPoint(anterior.x() + (dist * cosa),
anterior.y() + (dist * cosb))
prog += dist
return [estaca, '', prog, p.y(), p.x(), 0.0, az], prog, p
def showRect(self, startPoint, endPoint):
self.rubberBand.reset(True)
if startPoint.x() == endPoint.x() or startPoint.y() == endPoint.y():
return
point1 = QgsPoint(startPoint.x(), startPoint.y())
point2 = QgsPoint(startPoint.x(), endPoint.y())
point3 = QgsPoint(endPoint.x(), endPoint.y())
point4 = QgsPoint(endPoint.x(), startPoint.y())
self.rubberBand.addPoint(point1, False)
self.rubberBand.addPoint(point2, False)
self.rubberBand.addPoint(point3, False)
self.rubberBand.addPoint(point4, False)
self.rubberBand.addPoint(point1, True) # true to update canvas
self.rubberBand.show()
def getPoint(self, mapPoint):
self.set_rad.setEnabled(True)
# change tool so you don't get more than one POI
self.canvas.unsetMapTool(self.emitPoint)
self.canvas.setMapTool(self.userTool)
# Get the click
if mapPoint:
self.atk_pt = QgsPoint(mapPoint)
self.distance()
# Specify the geometry type
layer = QgsVectorLayer('Point?crs=epsg:28992', 'Attack Point',
'memory')
style = "style_attack.qml"
qml_path = self.plugin_dir + "/data/" + style
layer.loadNamedStyle(qml_path)
layer.triggerRepaint()
# Set the provider to accept the data source
prov = layer.dataProvider()
# Add a new feature and assign the geometry
feat = QgsFeature()
feat.setGeometry(QgsGeometry.fromPoint(mapPoint))
prov.addFeatures([feat])
# Update extent of the layer
layer.updateExtents()
# Add the layer to the Layers panel
QgsMapLayerRegistry.instance().addMapLayers([layer])
def add_vertex_avg(self):
# if turned on
if roam.config.settings.get('gps_averaging', True):
# if currently happening
if roam.config.settings.get('gps_averaging_in_action', True):
# start -> stop
# averaging
average_point = GPS.average_func(GPS.gpspoints)
point = QgsPoint(average_point[0], average_point[1],
average_point[2])
self.add_point(point)
self.band.addPoint(QgsPointXY(point))
# default settings
vertex_or_point = ''
in_action = False
start_time = '0:00:00'
roam.config.settings['gps_averaging_measurements'] = 0
self.set_buttons_avg(True)
else:
# stop -> start
# avg settings
vertex_or_point = 'vertex'
in_action = True
start_time = datetime.now()
self.set_buttons_avg(False)
roam.config.settings['gps_vertex_or_point'] = vertex_or_point
roam.config.settings['gps_averaging_in_action'] = in_action
roam.config.settings['gps_averaging_start_time'] = start_time
roam.config.save()
else:
self.add_vertex()
def p2QgsPoint(
pt,
pt2=None
): #Qgis 3.10.0 has a bug where the QgsPoint doesn't accept a QgsPointXY as a constructor
if pt2 is None:
try:
if type(pt) is list:
if len(pt) == 3:
return QgsPoint(pt[0], pt[1], pt[2])
else:
return QgsPoint(pt[0], pt[1])
else:
return QgsPoint(pt.x(), pt.y())
except:
return QgsPoint(pt)
else:
return QgsPoint(pt, pt2)
def getEvac(self, evac):
self.canvas.unsetMapTool(self.emitEvac)
self.select_POI.setEnabled(False)
self.select_shelter.setEnabled(True)
if evac:
self.evac = QgsPoint(evac)
self.evac_layer, self.evac_feat = self.select(self.evac)
self.to_evac_table()
def getShel(self, shel):
self.canvas.unsetMapTool(self.emitShel)
if shel:
self.shel = QgsPoint(shel)
self.shel_layer, self.shel_feat = self.select(self.shel)
self.shelter_table()
if self.evac and self.shel:
self.shortestRouteButton.setEnabled(True)
def criticalLocate(self):
point = None
try:
point = QgsPoint(float(self.ui.txtCriticalX.text()), float(self.ui.txtCriticalY.text()))
except:
return
if define._units == QGis.Meters:
extent = QgsRectangle(point.x() - 350, point.y() - 350, point.x() + 350, point.y() + 350)
else:
extent = QgsRectangle(point.x() - 0.005, point.y() - 0.005, point.x() + 0.005, point.y() + 0.005)
if extent is None:
return
QgisHelper.zoomExtent(point, extent, 2)
def exit_dialog(self, points, crs):
self.dialog.close()
layer = QgsVectorLayer('LineString', self.name_tracado, "memory")
pr = layer.dataProvider()
print points
anterior = QgsPoint(points[0])
fets = []
for p in points[1:]:
fet = QgsFeature(layer.pendingFields())
fet.setGeometry(QgsGeometry.fromPolyline([anterior, QgsPoint(p)]))
fets.append(fet)
anterior = QgsPoint(p)
pr.addFeatures(fets)
self.crs = crs
layer.setCrs(QgsCoordinateReferenceSystem(int(crs), 0))
layer.updateExtents()
QgsMapLayerRegistry.instance().addMapLayer(layer)
def canvasReleaseEvent(self, event):
#Get the click
x = event.pos().x()
y = event.pos().y()
point = self.canvas.getCoordinateTransform().toMapCoordinates(x, y)
self.p = QgsPoint(point[0], point[1])
print point, self.p
print self.p.wellKnownText()
class PointTool(QgsMapTool):
def __init__(self, canvas):
QgsMapTool.__init__(self, canvas)
self.canvas = canvas
def canvasPressEvent(self, event):
pass
def canvasMoveEvent(self, event):
#Uncomment Activate point Hovering
#x = event.pos().x()
#y = event.pos().y()
#point = self.canvas.getCoordinateTransform().toMapCoordinates(x, y)
pass
def canvasReleaseEvent(self, event):
#Get the click
x = event.pos().x()
y = event.pos().y()
point = self.canvas.getCoordinateTransform().toMapCoordinates(x, y)
self.p = QgsPoint(point[0], point[1])
print point, self.p
print self.p.wellKnownText()
def activate(self):
pass
def deactivate(self):
pass
def isZoomTool(self):
return False
def isTransient(self):
return False
def isEditTool(self):
return True
def getPoint(self):
return self.p
def paint(self, p, *args):
super(RubberBand, self).paint(p)
# p.drawRect(self.boundingRect())
if not roam.config.settings.get("draw_distance", True):
return
offset = QPointF(5, 5)
nodescount = self.numberOfVertices()
for index in range(nodescount, -1, -1):
if index == 0:
return
qgspoint = self.getPoint(0, index)
qgspointbefore = self.getPoint(0, index - 1)
# No point before means we are the first index and there is nothing
# before us.
if not qgspointbefore:
return
if qgspoint and qgspointbefore:
distance = self.distancearea.measureLine(
qgspoint, qgspointbefore)
if int(distance) == 0:
continue
text = QgsDistanceArea.formatDistance(distance,
3,
self.unit,
keepBaseUnit=False)
linegeom = QgsGeometry.fromPolyline(
[QgsPoint(qgspoint),
QgsPoint(qgspointbefore)])
midpoint = linegeom.centroid().asPoint()
midpoint = self.toCanvasCoordinates(midpoint) - self.pos()
midpoint += offset
path = QPainterPath()
path.addText(midpoint, self.font, text)
p.setPen(self.blackpen)
p.setRenderHints(QPainter.Antialiasing)
p.setFont(self.font)
p.setBrush(self.whitebrush)
p.drawPath(path)
def reprojectBoundingBox(self, crsSrc, ogrPoly):
crsDest = QgsCoordinateReferenceSystem(4326)
coordinateTransformer = QgsCoordinateTransform(crsSrc, crsDest)
newPolyline = []
ring = ogrPoly.GetGeometryRef(0)
for i in range(ring.GetPointCount()):
pt = ring.GetPoint(i)
point = QgsPoint(pt[0], pt[1])
newPolyline.append(coordinateTransformer.transform(point))
qgsPolygon = QgsGeometry.fromPolygon([newPolyline])
return qgsPolygon
def createCircle(mpoint, mradius, iface, mapunits=True, segment=64):
if not mapunits:
ctx = iface.mapCanvas().mapRenderer().rendererContext()
mradius *= ctx.scaleFactor() * ctx.mapToPixel().mapUnitsPerPixel()
pts = []
for i in range(segment):
theta = i * (2.0 * math.pi / segment)
p = QgsPoint(mpoint.x() + mradius * math.cos(theta),
mpoint.y() + mradius * math.sin(theta))
pts.append(p)
return pts
def gera_tracado_ponto_inicial(self, point):
self.tracado_dlg_inicial.txtNorth.setText("%f" % point.y())
self.tracado_dlg_inicial.txtEste.setText("%f" % point.x())
ok = self.tracado_dlg_inicial.exec_()
if not (ok):
return None
else:
pn = float(
self.tracado_dlg_inicial.txtNorth.text().strip().replace(
",", "."))
pe = float(self.tracado_dlg_inicial.txtEste.text().strip().replace(
",", "."))
self.gera_tracado_ponto_final(QgsPoint(pe, pn))
#self.gera_tracado_pontos(inicial=True)
self.gera_tracado_pontos(final=True)
def canvasMoveEvent(self, event: QgsMapMouseEvent):
if self.is_tracking and not self.capturing or self.editvertex is None:
return
point = point_from_event(event, self.snapping)
if not self.editmode:
self.pointband.movePoint(point)
if self.capturing:
self.band.movePoint(point)
if self.editmode and self.editvertex is not None:
found, vertexid = self.geom.vertexIdFromVertexNr(self.editvertex)
self.geom.get().moveVertex(vertexid, QgsPoint(point))
self.feature.setGeometry(self.geom)
self.currentVectorLayer().updateFeature(self.feature)
self.pointband.setToGeometry(self.toMultiPoint(self.geom), self.currentVectorLayer())
self.band.setToGeometry(self.geom, self.currentVectorLayer())
def setResultLayer(self, result_list):
layerName = u'规划基站结果'
layerType = QGis.WKBPoint
project_dir = getProjectDir(self.iface)
# 先判断是否已存在规划基站结果图层
result_layer = getLayerByName(layerName, self.iface)
if result_layer:
#清空数据
delAllFeatures(result_layer)
else:
# 删除原有图层文件
deleteShapefile(project_dir, layerName)
shapPath = os.path.join(project_dir, layerName + u".shp")
# 生成图层
fileds = self.createFields()
# 创建出Shap文件
# 数据源编码模式为GBK2312（否则中文字段会乱码）
wr = QgsVectorFileWriter(shapPath, "GBK2312", fileds, layerType, None, "ESRI Shapefile")
# 如果保存的时候没有错误
if wr.hasError() == QgsVectorFileWriter.NoError:
pass
else:
print wr.hasError()
raise Exception, wr.errorMessage() # 发生错误，抛出异常交给外面的方法处理异常
del wr # 使添加的字段生效
result_layer = QgsVectorLayer(shapPath, layerName, 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(result_layer)
# 添加数据
features_list = []
for result in result_list:
feature = createABasicPointFeature(QgsPoint(float(result[1]),float(result[2])), result)
features_list.append(feature)
importFeaturesToLayer(result_layer, features_list)
# 合并站点
mergeNSite = OptimizateNewSite(result_layer, self.parent)
if mergeNSite.run():
QMessageBox.information(self.parent, u"自动规划基站", u"自动规划基站成功！")
else:
QMessageBox.critical(self.parent, u"自动规划基站", u"自动规划基站失败！")
def get_del(self, delete):
self.canvas.unsetMapTool(self.emitDel)
if delete:
layer = "Danger Zones"
min_dist = QgsDistanceArea()
vl = uf.getLegendLayerByName(self.iface, layer)
point = QgsPoint(delete)
feats = vl.getFeatures()
for feat in feats:
geom = feat.geometry()
pt = geom.centroid().asPoint()
dist = QgsDistanceArea().measureLine(point, pt)
if dist < min_dist:
min_dist = dist
fid = feat.id()
vl.startEditing()
vl.deleteFeature(fid)
vl.commitChanges()
def plotar(self):
vl = QgsVectorLayer("Point", "temporary_points", "memory")
pr = vl.dataProvider()
# Enter editing mode
vl.startEditing()
# add fields
pr.addAttributes([
QgsField("estaca", QVariant.String),
QgsField("descrição", QVariant.String),
QgsField("north", QVariant.String),
QgsField("este", QVariant.String),
QgsField("cota", QVariant.String),
QgsField("azimite", QVariant.String)
])
fets = []
for r in range(self.tableWidget.rowCount()):
ident = self.tableWidget.item(r, 0).text()
if ident in ["", None]: break
fet = QgsFeature(vl.pendingFields())
n = 0.0
e = 0.0
try:
es = self.tableWidget.item(r, 0).text()
d = self.tableWidget.item(r, 1).text()
n = float(self.tableWidget.item(r, 3).text())
e = float(self.tableWidget.item(r, 4).text())
c = float(self.tableWidget.item(r, 5).text())
a = self.tableWidget.item(r, 6).text()
except:
break
fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(e, n)))
fet.setAttributes([es, d, n, e, c, a])
fets.append(fet)
pr.addFeatures(fets)
vl.commitChanges()
QgsMapLayerRegistry.instance().addMapLayer(vl)
def createSector(mpoint,
mradius,
iface,
mapunits=True,
angle=0.0,
szAngle=0.0,
segment=24):
if not mapunits:
ctx = iface.mapCanvas().mapRenderer().rendererContext()
mradius *= ctx.scaleFactor() * ctx.mapToPixel().mapUnitsPerPixel()
if type(angle) != float:
angle = math.pi / 180 * (90.0 - float(angle))
szAngle = math.pi / 180 * szAngle
pts = []
pts.append(mpoint)
for i in range(segment):
theta = angle - szAngle / 2 + i * (szAngle / segment)
p = QgsPoint(mpoint.x() + mradius * math.cos(theta),
mpoint.y() + mradius * math.sin(theta))
pts.append(p)
pts.append(mpoint)
return pts
def create_estacas_old(self):
estacas = []
k = 0
prog = 0.0
dist = 0.0
p = self.get_features()[self.estaca]
az = 0.0
lab = 0
for elem in self.layer.getFeatures():
for i, (seg_start, seg_end) in enumerate(pairs(elem, self.estaca)):
estaca = []
line_start = QgsPoint(seg_start)
line_end = QgsPoint(seg_end)
if k != 0:
# lab = 1
pass
else:
lab = 0
# mid point = vector coordinates [x2-x1,y2-y1]
pointm = diff(line_end, line_start)
# direction cosines of the segment
cosa, cosb = dircos(pointm)
# length of the segment
lg = length(line_end, line_start)
az = azimuth(
line_start,
QgsPoint(line_start.x() + ((prog + self.distancia) * cosa),
line_start.y() +
((prog + self.distancia) * cosb)))
geo = line_start
prop = self.distancia - (
(prog + self.distancia) - dist) if prog > 0 else prog
txtId = "%d+%f" % (
lab, prop) if prog > 0 or prop > 0 else "%d" % lab
estaca.extend(
[txtId, 'v%d' % i, dist,
geo.y(),
geo.x(), 0.0, az])
estacas.append(estaca)
'''
------------------------------------------------
Definição das estacas intermediarias.
------------------------------------------------
'''
prog = 0.0 if (prog == 0) else prog
dist = dist + lg
p = line_start
nprog = 0.0
while nprog + self.distancia < lg:
estaca = []
lab += 1
k += 1
pa = p
p = QgsPoint(p.x() + ((self.distancia - prop) * cosa),
p.y() + ((self.distancia - prop) * cosb))
az = azimuth(seg_start, p)
prog += self.distancia
nprog += self.distancia
prop = 0
estaca.extend([str(lab), '', prog, p.y(), p.x(), 0.0, az])
estacas.append(estaca)
estaca = []
ultimo = self.get_features()[-1]
lg = prog + length(p, ultimo)
prop = self.distancia - (prog - lg) if prog > 0 else prog
txtId = "%d+%f" % (lab, prop) if prog > 0 or prop > 0 else "%d" % lab
# az = self.azimuth(p,QgsPoint(ultimo.x(), ultimo.y()))
estaca.extend(
[txtId, 'vf', lg,
ultimo.y(),
ultimo.x(),
ultimo.x(), az])
estacas.append(estaca)
return estacas
def gera_vertice(self):
prog = 0.0
sobra = 0.0
resto = 0.0
estaca = 0
cosa = 0.0
cosb = 0.0
crs = int(self.getCRS())
sem_internet = False
for elemento in self.layer.getFeatures():
for i, (seg_start,
seg_end) in enumerate(pairs(elemento, self.estaca)):
ponto_inicial = QgsPoint(seg_start)
ponto_final = QgsPoint(seg_end)
tamanho_da_linha = length(ponto_final, ponto_inicial)
ponto = diff(ponto_final, ponto_inicial)
cosa, cosb = dircos(ponto)
az = azimuth(
ponto_inicial,
QgsPoint(ponto_inicial.x() + ((self.distancia) * cosa),
ponto_inicial.y() + ((self.distancia) * cosb)))
estacas_inteiras = int(
math.floor((tamanho_da_linha - sobra) / self.distancia))
estacas_inteiras_sobra = estacas_inteiras + 1 if sobra > 0 else estacas_inteiras
if not sem_internet:
cota = getElevation(
crs,
QgsPoint(float(ponto_inicial.x()),
float(ponto_inicial.y())))
if cota == 0:
sem_internet = True
else:
cota = 0.0
yield [
'%d+%f' % (estaca, resto) if resto != 0 else '%d' %
(estaca),
'v%d' % i, prog,
ponto_inicial.y(),
ponto_inicial.x(), cota, az
], ponto_inicial, estacas_inteiras, prog, az, sobra, tamanho_da_linha, cosa, cosb
prog += tamanho_da_linha
resto = (tamanho_da_linha - sobra) - (self.distancia *
estacas_inteiras)
sobra = self.distancia - resto
estaca += estacas_inteiras_sobra
cota = getElevation(
crs, QgsPoint(float(ponto_final.x()), float(ponto_final.y())))
yield [
'%d+%f' % (estaca, resto),
'v%d' % i, prog,
ponto_final.y(),
ponto_final.x(), cota, az
], ponto_final, 0, tamanho_da_linha, az, sobra, tamanho_da_linha, cosa, cosb
def geometry(self):
if self.geom.type() == QgsWkbTypes.PointGeometry:
x = float(self.xedit.text())
y = float(self.yedit.text())
return QgsGeometry.fromPointXY(QgsPoint(x, y))
def __init__(self, parent=None):
"""Constructor."""
super(Evacu8DockWidget, 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)
#define globals
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.plugin_dir = os.path.dirname(__file__)
self.emitPoint = QgsMapToolEmitPoint(self.canvas)
self.toolPoly = PolyMapTool(self.canvas)
self.emitEvac = QgsMapToolEmitPoint(self.canvas)
self.emitShel = QgsMapToolEmitPoint(self.canvas)
self.emitDel = QgsMapToolEmitPoint(self.canvas)
self.input_template = self.scen_info.toHtml()
# set up GUI operation signals
# data
self.load_scen.clicked.connect(self.openScenario)
self.tabs.setTabEnabled(1, False)
self.set_pt.clicked.connect(self.enterPoi)
self.emitPoint.canvasClicked.connect(self.getPoint)
self.set_rad.clicked.connect(self.calculateBuffer)
self.set_rad.setEnabled(False)
self.send_notes.clicked.connect(self.sendNotes)
self.set_danger.clicked.connect(self.setDangerZone)
self.get_danger.clicked.connect(self.getDangerZone)
self.del_danger.clicked.connect(self.delDangerZone)
self.emitDel.canvasClicked.connect(self.get_del)
# set images and icons
self.logo.setPixmap(QtGui.QPixmap(':images/Logosmall.jpeg'))
self.load_scen.setIcon(QtGui.QIcon(':images/Open.png'))
self.load_scen.setIconSize(QSize(25, 25))
self.set_danger.setIcon(QtGui.QIcon(':images/Draw1.svg'))
self.set_danger.setIconSize(QSize(25, 25))
self.get_danger.setIcon(QtGui.QIcon(':images/Check.png'))
self.get_danger.setIconSize(QSize(25, 25))
self.del_danger.setIcon(QtGui.QIcon(':images/Delete.png'))
self.del_danger.setIconSize(QSize(30, 30))
self.shortestRouteButton.setIcon(QtGui.QIcon(':images/Route.png'))
self.shortestRouteButton.setIconSize(QSize(25, 25))
self.to_wiki1.setIcon(QtGui.QIcon(':images/Info.png'))
self.to_wiki1.setIconSize(QSize(20, 20))
# analysis
self.evac = QgsPoint()
self.evacId = int()
self.shel = QgsPoint()
self.shelId = int()
self.evac_layer = QgsVectorLayer()
self.evac_feat = QgsFeature()
self.shel_layer = QgsVectorLayer()
self.shel_feat = QgsFeature()
self.select_POI.clicked.connect(self.enterEvac)
self.emitEvac.canvasClicked.connect(self.getEvac)
self.desel_POI.clicked.connect(self.deleteEvac)
self.select_shelter.setEnabled(False)
self.select_shelter.clicked.connect(self.enterShel)
self.emitShel.canvasClicked.connect(self.getShel)
self.shortestRouteButton.setEnabled(False)
self.shortestRouteButton.clicked.connect(self.buildNetwork)
self.shortestRouteButton.clicked.connect(self.calculateRoute)
self.network_layer = QgsVectorLayer()
self.tied_points = []
self.to_evac_info.setVerticalHeaderLabels(
["Type", "Name", "Address", "Population", "Dist from Attack(m)"])
self.shelter_info.setVerticalHeaderLabels(
["Type", "Name", "Address", "Capacity", "Route distance (m)"])
# Open wiki
self.to_wiki1.clicked.connect(self.open_wiki)
self.big_button.clicked.connect(self.evacuateThis)
self.savelog.clicked.connect(self.saveLog)
self.big_button.setEnabled(False)
self.warning_msg.setVisible(False)
self.show_selected.clicked.connect(self.showSelected)
self.hide_selected.clicked.connect(self.hideSelected)
self.save_map.pressed.connect(self.showSelected)
self.save_map.released.connect(self.saveMap)
self.savelog.clicked.connect(self.timerMessage)
self.save_map.released.connect(self.timerMessage)
self.saved_msg.setVisible(False)
self.sent_msg.setVisible(False)
def matrix_dem_build(self, dem_dataset, height, width, scale, spacing_mm,
roi_x_max, roi_x_min, roi_y_min, h_base, z_scale, projected):
# Calculate DEM parameters
dem_col = dem_dataset.RasterXSize
dem_row = dem_dataset.RasterYSize
geotransform = dem_dataset.GetGeoTransform()
dem_x_min = geotransform[0]
dem_y_max = geotransform[3]
dem_y_min = dem_y_max + dem_row * geotransform[5]
dem_x_max = dem_x_min + dem_col * geotransform[1]
if not projected:
spacing_deg = spacing_mm * (roi_x_max - roi_x_min) / width
row_stl = int(math.ceil(height / spacing_mm) + 1)
col_stl = int(math.ceil(width / spacing_mm) + 1)
matrix_dem = [range(col_stl) for i in range(row_stl)]
var_y = height
for i in range(row_stl):
self.updateProgress.emit()
QApplication.processEvents()
var_x = 0
for j in range(col_stl):
# Model coordinate x(mm), y(mm)
x_model = round(var_x, 2)
y_model = round(var_y, 2)
# Model maps geo_coordinates
if projected:
x = x_model * scale / 1000 + roi_x_min
y = y_model * scale / 1000 + roi_y_min
else:
x = x_model * spacing_deg / spacing_mm + roi_x_min
y = y_model * spacing_deg / spacing_mm + roi_y_min
# Model layer geo_coordinates to query z value
point = QgsPoint(x, y)
source = self.parameters["crs_map"]
target = self.parameters["crs_layer"]
if source != target:
transform = QgsCoordinateTransform(source, target)
point = transform.transform(point)
x = point.x()
y = point.y()
# From x(m) get Column in DEM file
col_dem = (x - dem_x_min) * dem_col / (dem_x_max - dem_x_min)
col_dem = int(math.floor(col_dem))
if col_dem == dem_col:
col_dem -= 1
# From y(m) get Row in DEM file
row_dem = (dem_y_max - y) * dem_row / (dem_y_max - dem_y_min)
row_dem = int(math.floor(row_dem))
if row_dem == dem_row:
row_dem -= 1
# Model coordinate z(mm)
if col_dem < 0 or row_dem < 0:
z_model = 2
elif self.get_dem_z(dem_dataset, col_dem, row_dem, 1, 1)[0] <= h_base:
z_model = 2
elif math.isnan(self.get_dem_z(dem_dataset, col_dem, row_dem, 1, 1)[0]):
z_model = 2
else:
z_model = round((self.get_dem_z(dem_dataset, col_dem, row_dem, 1, 1)[0] - h_base) /
scale * 1000 * z_scale, 2) + 2
matrix_dem[i][j] = self.pto(x=x_model, y=y_model, z=z_model)
var_x += spacing_mm
if var_x > width:
var_x = width
var_y = spacing_mm * (row_stl - (i + 2))
if self.quit:
return 0
return matrix_dem
def run(self):
d = QgsDistanceArea()
self.jlist = self.getNewSites()
maxDistance = self.tlist[1] # 最大搜索范围
feature_list = []
existed_name_list = self.getResultNodesNames()
for (jindex, jsite) in enumerate(self.jlist): # 遍历结点
perList = [] # 临时列表，用于转化子字典
jnaminDis1, jnaminDis2, jnaminDis3, jnaminDis4, jnaminDis5, jnaminDis6 = [
self.tlist[1] for i in range(6)
]
asite1, asite2, asite3, asite4, asite5, asite6 = [
None for i in range(6)
]
if jsite[7] == u'农村':
minDis = float(self.tlist[2])
elif jsite[7] == u'郊区乡镇':
minDis = float(self.tlist[3])
elif jsite[7] == u'密集市区':
minDis = float(self.tlist[5])
else: # 区域类型的结点的最小辐射范围
# 默认jsite[7]==u'普通市区'
minDis = float(self.tlist[4])
jpoint = jsite.geometry().asPoint()
# 先找到结点附近设置搜索范围内的所有基站
area = createARectangleByCenterPoint(jpoint, maxDistance)
siteFeatures_list = getFeaturesListByArea(self.siteLayer, area)
for asite in siteFeatures_list: # #遍历找到的基站
jnaDis = d.convertMeasurement(d.measureLine(jpoint, \
QgsPoint(asite[4], asite[5])), 2, 0, False)[0]
jnaAngle = math.atan2(asite[5] - jpoint.y(),
asite[4] - jpoint.x())
jnaAngle = 90.0 - 180 / math.pi * jnaAngle # 弧度转角度(90-方位角，可转为以正北为0度角)
if jnaDis <= jnaminDis1 and 0 < jnaAngle <= 60:
jnaminDis1 = float('%0.4f' % jnaDis) # 保留四位小数
asite1 = asite
elif jnaDis <= jnaminDis2 and 60 < jnaAngle <= 120:
jnaminDis2 = float('%0.4f' % jnaDis) # 保留四位小数
asite2 = asite
elif jnaDis <= jnaminDis3 and 120 < jnaAngle <= 180:
jnaminDis3 = float('%0.4f' % jnaDis) # 保留四位小数
asite3 = asite
elif jnaDis <= jnaminDis4 and -180 < jnaAngle <= -120:
jnaminDis4 = float('%0.4f' % jnaDis) # 保留四位小数
asite4 = asite
elif jnaDis <= jnaminDis5 and -120 < jnaAngle <= -60:
jnaminDis5 = float('%0.4f' % jnaDis) # 保留四位小数
asite5 = asite
elif jnaDis <= jnaminDis6 and -60 < jnaAngle <= 0:
jnaminDis6 = float('%0.4f' % jnaDis) # 保留四位小数
asite6 = asite
if jnaminDis1 and asite1: perList.append([jnaminDis1, asite1])
if jnaminDis2 and asite2: perList.append([jnaminDis2, asite2])
if jnaminDis3 and asite3: perList.append([jnaminDis3, asite3])
if jnaminDis4 and asite4: perList.append([jnaminDis4, asite4])
if jnaminDis5 and asite5: perList.append([jnaminDis5, asite5])
if jnaminDis6 and asite6: perList.append([jnaminDis6, asite6])
# 判断是否至少找到一个符合的基站
if len(perList) < 6:
for i in range(6 - len(perList)):
perList.append(None) # 若数量不足，给列表补None值
NewSiteName = "0"
while True:
if NewSiteName in existed_name_list:
NewSiteName = str(int(NewSiteName) + 1)
else:
existed_name_list.append(NewSiteName)
break
tempList1 = [
NewSiteName,
str(jpoint.x()),
str(jpoint.y()), jsite[7]
]
tempList2 = []
tolDistance = 0
suit_site_dict = {
} # 用于记录符合基站的基站名和距离 (key: SiteName, value: distance)
for L in perList:
if isinstance(L, list): # 判断是否为列表类型
tolDistance = tolDistance + L[0]
psite = L[1]
tempList2.append(psite[2]) # 基站名
tempList2.append(str(L[0])) # 距离
tempList2.append(str(psite[4])) # 经度
tempList2.append(str(psite[5])) # 纬度
suit_site_dict[psite[2]] = L[0]
else:
tempList2.append('NULL')
tempList2.append('NULL') # 没有基站，设为None值
tempList2.append('NULL')
tempList2.append('NULL')
if ((tolDistance != 0) and (len(suit_site_dict) != 0)):
avgDistance = ("%.4f" % (tolDistance / len(suit_site_dict)))
# 将符合要求的站点按距离从小到大排序
sorted_list = sorted(suit_site_dict.iteritems(),
key=lambda d: d[1],
reverse=False)
# tempList1后追加最近基站名称，最近基站距离，平均距离
tempList1.extend([
sorted_list[0][0],
str(sorted_list[0][1]),
str(avgDistance)
])
else:
# tempList1后追加最近基站名称，最近基站距离，平均距离
tempList1.extend(["NULL", "NULL", "0"])
NewSite_datas = (tempList1 + tempList2)
feature_list.append(createABasicPointFeature(
jpoint, NewSite_datas))
if importFeaturesToLayer(self.nsiteLayer, feature_list):
self.iface.actionDraw().trigger()
return True
else:
return False
def importSiteAndCellData(self):
cell_features = []
site_features = []
site_dict = {}
try:
# 先生成小区feature再生成基站feature
for itm in self.data_list:
# 创建小区feature
# 当有小区ID和小区名时才导入信息
cell_id = itm[2]
cell_name = itm[3]
if cell_id and cell_name:
cell = []
for (index, i) in enumerate(itm):
# 小区表中没有站点地址（48）和基站ID2（51）
if index not in [48, 51]:
cell.append(i)
# 获取小区图形设置\
setting = self.getCellGraphicParam()
if not setting:
return
# 处理小区图形参数
if setting["type"] == 0:
# 按运营商
operator = itm[18]
if operator == u'移动':
angle = setting[u"移动"][0]
length = setting[u"移动"][1]
elif operator == u'联通':
angle = setting[u"联通"][0]
length = setting[u"联通"][1]
elif operator == u'电信':
angle = setting[u"电信"][0]
length = setting[u"电信"][1]
else:
angle = setting[u"铁塔"][0]
length = setting[u"铁塔"][1]
else:
# 自定义
system = itm[10]
frequency = itm[12]
# 获取默认设置
angle = self.setting[u"默认"][0]
length = self.setting[u"默认"][1]
# 获取分类
case_list = self.setting["case_list"]
for (c_system, c_frequency, c_angle, c_length) in case_list:
if c_system and (not c_frequency):
if system == c_system:
angle = c_angle
length = c_length
elif (not c_system) and c_frequency:
if frequency == c_frequency:
angle = c_angle
length = c_length
elif c_system and c_frequency:
if (system == c_system) and (frequency == c_frequency):
angle = c_angle
length = c_length
# 根据小区类型生成相应的geometry
if itm[5] == u"室分":
circle = createCircle(QgsPoint(float(itm[8]), float(itm[9])), length / 2,
self.iface, True, 64)
cell_feat = createACellFeature(circle, cell)
cell_features.append(cell_feat)
else:
sector = createSector(QgsPoint(float(itm[8]), float(itm[9])), length, self.iface, True,
itm[7], angle)
cell_feat = createACellFeature(sector, cell)
cell_features.append(cell_feat)
# 创建基站feature
site = [
itm[0], # 基站ID
itm[1], # 基站名
itm[6], # RNC-BSC
itm[8], # 经度
itm[9], # 纬度
itm[10], # 网络制式
itm[11], # 典型环境
itm[17], # 区域
itm[18], # 运营商
itm[19], # 簇
itm[20], # 基站英文名
itm[22], # 基站类型
itm[48], # 站点地址
itm[49], # MCC
itm[50], # MNC
itm[51], # 基站ID2
itm[52], # 话务量
itm[53], # 投诉量
itm[54], # Polygon
itm[55] # 其他
]
site_id = itm[0]
site_name = itm[1]
rnc_bsc = itm[6]
lon = itm[8]
lat = itm[9]
site_key = (site_id, site_name, rnc_bsc, lon, lat)
if site_dict.has_key(site_key):
continue
else:
site_dict[site_key] = True
site_feat = createASiteFeature(QgsPoint(float(itm[8]), float(itm[9])), site)
site_features.append(site_feat)
# 导入数据
siteLayer = getLayerByName(u"基站",self.iface)
site_result = importFeaturesToLayer(siteLayer, site_features)
cellLayer = getLayerByName(u"小区", self.iface)
cell_result = importFeaturesToLayer(cellLayer, cell_features)
if (site_result is False) or (cell_result is False):
siteLayer.destroyEditCommand()
cellLayer.destroyEditCommand()
return False
else:
siteLayer.endEditCommand()
cellLayer.endEditCommand()
return True
except Exception:
raise Exception, traceback.format_exc()
