def on_search_wpt(self, event):
dlg = WptSearchDlg()
dlg.CentreOnParent()
if dlg.ShowModal() == wx.ID_OK:
name = dlg.name.GetValue()
if name:
way_points = search.find_pos_from_name(name, g.search_api)
if len(way_points) > 0:
folder_name = '地点搜索结果：%s' % name
new_folder = g.track_tree.create_child_folder(
g.data_root, folder_name)
first_wpt = None
for point in way_points:
wpt = WayPoint(point[0],
point[1],
point[2],
parent=new_folder.uuid,
bmp_index=g.default_wpt_bmp_index)
g.add_data(new_folder, wpt)
if not first_wpt:
first_wpt = wpt
g.track_tree.SelectItem(first_wpt.tree_node)
g.map_canvas.zoom_to_lon_lat(15, first_wpt.lon,
first_wpt.lat)
self.repaint(canvas=const.REDRAW_MAP)
else:
do_log('地名搜索失败...')
else:
do_log('地名不能为空...')
dlg.Destroy()
def on_delete_file_folder(self, event):
folder = self._popup_context[event.Id]
if folder:
dlg = wx.MessageDialog(self, '确认删除该文件夹？',
'确认删除？',
wx.YES_NO
)
ret = dlg.ShowModal()
dlg.Destroy()
if ret != wx.ID_YES:
return
deleted = g.del_folder(folder, commit=False)
g.db_mgr.commit()
if self.selected_track_line in deleted:
self.selected_track_line = None
undo_action = {}
undo_action['action'] = 'tree_del_folder'
undo_action['deleted'] = deleted
g.undo_list = []
g.undo_list.append(undo_action)
g.frame.enable_undo()
g.frame.repaint(canvas=const.REDRAW_TRACK)
do_log('文件夹“%s”被删除...' % folder.name)
def on_begin_drag(self, event):
node = event.GetItem()
if node == self._tree_root:
do_log('根目录不能移动...')
return
self._src_node = node
event.Allow()
def on_reverse_track(self, event):
index = self._popup_context[event.Id]
track_line = self._track_list[index]
if track_line.has_timestamp:
dlg = wx.MessageDialog(self, '该轨迹含时间戳信息，翻转后时间信息将丢失。确认翻转？', '确认翻转？',
wx.YES_NO)
ret = dlg.ShowModal()
dlg.Destroy()
if ret != wx.ID_YES:
return
undo_action = {}
undo_action['action'] = 'reverse'
undo_action['track'] = track_line
undo_action['has_timestamp'] = track_line.has_timestamp
self.g.undo_list = []
self.g.undo_list.append(undo_action)
track_line.track_points.reverse()
track_line.has_timestamp = False
track_line.compute_track_line_args()
self.set_selected_track_line(track_line)
self.g.frame.enable_undo(False)
do_log('轨迹“%s”方向已翻转...' % track_line.name)
self.g.frame.repaint(canvas=const.REDRAW_TRACK)
def on_add_wpt_from_tile(self, event):
dlg = AddWptFromTileDlg()
dlg.CentreOnParent()
if dlg.ShowModal() == wx.ID_OK:
if dlg.tile_x.GetValue() and dlg.tile_y.GetValue(
) and dlg.tile_z.GetValue():
tile_x = int(dlg.tile_x.GetValue())
tile_y = int(dlg.tile_y.GetValue())
zoom = int(dlg.tile_z.GetValue())
need_jiupian = dlg.need_jiupian.GetValue()
lon = transform.get_longitude_from_fpx(
transform.get_fpx_from_px(tile_x * 256 + 128, zoom))
lat = transform.get_latitude_from_fpy(
transform.get_fpy_from_py(tile_y * 256 + 128, zoom))
if need_jiupian:
lon, lat = jiupian.gcj02_to_wgs84(lon, lat)
wpt = WayPoint('瓦片-x%d-y%d-z%d' % (tile_x, tile_y, zoom),
lon,
lat,
parent=g.data_root.uuid,
bmp_index=g.default_wpt_bmp_index)
g.add_data(g.data_root, wpt)
g.track_tree.SelectItem(wpt.tree_node)
self.repaint(const.REDRAW_COPY)
else:
do_log('瓦片x，y，z坐标都必须有值...')
dlg.Destroy()
def download_wpt_alt_main_thread(self):
do_log('正在为路点“%s”下载高程数据，请稍候...' % self.wpt.name)
i = 0
if self.wpt.alt <= 0: # 本应用中假定海拔高度都应大于0
g.srtm_mgr.progress_now = 3.0
self._ctl_gauge_point.SetValue(g.srtm_mgr.progress_now)
thread = threading.Thread(target=g.srtm_mgr.get_alt_network, args=(self.wpt.lon, self.wpt.lat))
thread.setDaemon(True)
thread.start()
time.sleep(0.1)
while g.srtm_mgr.downloading:
self._ctl_gauge_point.SetValue(g.srtm_mgr.progress_now)
time.sleep(0.1)
alt = g.srtm_mgr.alt
self._ctl_gauge_point.SetValue(g.srtm_mgr.PROGRESS_RANGE)
if alt < 0:
if alt == g.srtm_mgr.ERROR_NETWORK:
do_log('下载失败，可能网路故障或网速太慢，请稍后再试...')
elif alt == g.srtm_mgr.ERROR_CANCELED:
do_log('下载过程被人为中止！')
else:
do_log('获取高程数据有误...')
else:
self.wpt.alt = alt
do_log('路点高程数据获取成功...')
g.frame.repaint(const.REDRAW_COPY)
self.Destroy()
def on_begin_edit_label(self, event):
node = event.GetItem()
if not node:
event.Veto()
return
if node == self._tree_root:
do_log('根目录名不能更改...')
event.Veto()
return
def on_set_end_pt(self, event):
track_line = g.track_edit.selected_track_line
if track_line and track_line.selected_point:
track_point = track_line.selected_point
track_line.sel_end_idx = track_line.track_points.index(track_point)
if track_line.sel_end_idx < track_line.sel_start_idx:
track_line.sel_start_idx = 0
g.map_canvas.redraw_edit_selected_track_line()
self.repaint(canvas=const.REDRAW_NONE)
else:
do_log('请先选择轨迹点...')
def save_kml(self, data):
dlg = wx.FileDialog(
self, message='保存为...', defaultDir=os.getcwd(),
defaultFile=data.name, wildcard=const.WILDCARD_KML, style=wx.FD_SAVE | wx.FD_CHANGE_DIR | wx.FD_OVERWRITE_PROMPT
)
dlg.SetFilterIndex(0)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
try:
with open(path, 'wb') as fn:
fn.write(write_kml(data).encode('utf-8'))
except:
do_log('kml文件写入出错...')
dlg.Destroy()
def on_del_all_wpts(self, event):
dlg = wx.MessageDialog(self, '真的要删除所有路点数据？', '提示', wx.YES_NO)
ret = dlg.ShowModal()
dlg.Destroy()
if ret != wx.ID_YES:
return
g.empty_wpt_list()
g.map_canvas.repaint(const.REDRAW_COPY)
undo_action = {}
undo_action['action'] = 'del_all_wpts'
g.undo_list = [undo_action]
self.enable_undo()
do_log('已删除所有路点数据...')
def on_end_drag(self, event):
dst_node = event.GetItem()
if not dst_node.IsOk():
do_log('不能移动到这里...')
return
if self.is_ancestor(self._src_node, dst_node):
do_log('不能移动到自己或自己的下级...')
return
src_data = self.GetItemData(self._src_node)
src_parent_data = self.GetItemData(self.GetItemParent(self._src_node))
dst_data = self.GetItemData(dst_node)
if isinstance(dst_data, TrackLine) or isinstance(dst_data, WayPoint):
dst_parent_node = self.GetItemParent(dst_node)
dst_prev_node = self.GetPrevSibling(dst_node)
prev_order = self.GetItemData(
dst_prev_node).order_in_parent if dst_prev_node.ID else 0
src_data.order_in_parent = (dst_data.order_in_parent +
prev_order) / 2.0
else:
dst_parent_node = dst_node
if self.GetChildrenCount(dst_parent_node) == 0:
src_data.order_in_parent = 1000
else:
src_data.order_in_parent = self.GetItemData(
self.GetLastChild(dst_parent_node)).order_in_parent + 1000
self.g.db_mgr.update_order_in_parent(src_data)
dst_parent_data = self.GetItemData(dst_parent_node)
if dst_parent_data is not src_parent_data:
src_data.parent = dst_parent_data.uuid
self.g.db_mgr.update_parent_uuid(src_data, dst_parent_data.uuid)
if isinstance(src_data, DataFolder):
if self.g.folder_list.index(src_data) < self.g.folder_list.index(
dst_parent_data):
self.g.del_and_append_folder(src_data)
self.Delete(self._src_node)
if isinstance(src_data, DataFolder):
node = self.add_tree_folder(dst_parent_data, src_data)
else:
node = self.add_tree_node(dst_parent_data, src_data)
self.SelectItem(node)
def on_photo_add(self, event):
dlg = wx.FileDialog(self,
message='请选择照片文件',
defaultDir=os.getcwd(),
defaultFile='',
wildcard='照片文件 (*.jpg)|*.jpg',
style=wx.FD_OPEN | wx.FD_CHANGE_DIR)
if dlg.ShowModal() == wx.ID_OK:
paths = dlg.GetPaths()
photo = Photo(paths[0])
if photo.bmp:
g.photo_list.append(photo)
g.db_mgr.add_photo(photo)
g.map_canvas.zoom_to_lon_lat(15, photo.lon, photo.lat)
else:
do_log('照片文件无GPS信息，无法放置到地图...')
dlg.Destroy()
def on_del_alt(self, event):
index = self._popup_context[event.Id]
track_line = self._track_list[index]
dlg = wx.MessageDialog(self, '将删除本轨迹中所有轨迹点的高程数据。该操作不可撤销，确认删除？',
'确认删除？', wx.YES_NO)
ret = dlg.ShowModal()
dlg.Destroy()
if ret != wx.ID_YES:
return
for point in track_line.track_points:
point.alt = 0.0
do_log('已删除本轨迹中所有轨迹点的高程数据...')
track_line.compute_track_line_args()
self.set_selected_track_line(track_line)
self.g.frame.repaint(canvas=const.REDRAW_TRACK)
def open_track_files(self, paths, parent_folder):
do_log('正在加载轨迹文件，请稍候...')
self.CollapseAll()
first_track = None
first_wpt = None
fpx_min_list = []
fpx_max_list = []
fpy_min_list = []
fpy_max_list = []
for path in paths:
if path[-4:] == '.kml':
data_list = parse_kml(path, parent_folder.uuid)
elif path[-4:] == '.kmz':
data_list = parse_kmz(path, parent_folder.uuid)
elif path[-4:] == '.gpx':
data_list = parse_gpx(path, parent_folder.uuid)
else:
do_log('轨迹文件后缀不符...')
continue
for data in data_list:
data_parent = self.g.get_parent_folder(data)
self.g.add_data(data_parent, data, commit=False)
if isinstance(data, TrackLine):
fpx_min_list.append(data.fpx_min)
fpx_max_list.append(data.fpx_max)
fpy_min_list.append(data.fpy_min)
fpy_max_list.append(data.fpy_max)
if not first_track:
first_track = data
elif isinstance(data, WayPoint):
fpx_min_list.append(data.fpx)
fpx_max_list.append(data.fpx)
fpy_min_list.append(data.fpy)
fpy_max_list.append(data.fpy)
if not first_wpt:
first_wpt = data
self.g.db_mgr.commit()
if fpx_min_list:
if first_track:
self.selected_track_line = first_track
self.SelectItem(first_track.tree_node)
elif first_wpt:
self.SelectItem(first_wpt.tree_node)
self.g.map_canvas.zoom_to_range(min(fpx_min_list),
max(fpx_max_list),
min(fpy_min_list),
max(fpy_max_list))
self.g.frame.repaint(const.REDRAW_NONE)
do_log('轨迹文件加载完成...')
else:
do_log('轨迹文件无内容...')
def on_add_wpt_from_coord(self, event):
dlg = AddWptFromCoordDlg()
dlg.CentreOnParent()
if dlg.ShowModal() == wx.ID_OK:
if dlg.lon.GetValue() and dlg.lat.GetValue():
lat = float(dlg.lat.GetValue())
lon = float(dlg.lon.GetValue())
name = search.find_name_from_pos(lon, lat, g.search_api)
wpt = WayPoint(name,
lon,
lat,
parent=g.data_root.uuid,
bmp_index=g.default_wpt_bmp_index)
g.add_data(g.data_root, wpt)
g.track_tree.SelectItem(wpt.tree_node)
self.repaint(const.REDRAW_COPY)
else:
do_log('经纬度坐标都必须有值...')
dlg.Destroy()
def on_map_clear_cache(self, event):
dlg = wx.MessageDialog(self, '确认要清空本地硬盘中缓存的地图瓦片图片？', '提示', wx.YES_NO)
ret = dlg.ShowModal()
dlg.Destroy()
if ret != wx.ID_YES:
return
do_log('开始清空地图缓存...')
g.map_canvas.SetCursor(wx.Cursor(wx.CURSOR_WAIT))
root_dir = g.tile_mgr.get_cache_path()
file_list = os.listdir(root_dir)
for f in file_list:
file_path = os.path.join(root_dir, f)
if os.path.isfile(file_path):
try:
os.remove(file_path)
except:
pass
g.map_canvas.SetCursor(wx.STANDARD_CURSOR)
do_log('地图缓存清空完毕！')
def on_delete_track(self, event):
dlg = wx.MessageDialog(self, '确认删除该轨迹？', '确认删除？', wx.YES_NO)
ret = dlg.ShowModal()
dlg.Destroy()
if ret != wx.ID_YES:
return
track_line = self._popup_context[event.Id]
undo_action = {}
undo_action['action'] = 'tree_del_track'
undo_action['track'] = track_line
self.g.undo_list = []
self.g.undo_list.append(undo_action)
if track_line is self.selected_track_line:
self.selected_track_line = None
self.g.del_track_line(track_line)
self.g.frame.enable_undo()
self.g.frame.repaint(canvas=const.REDRAW_TRACK)
do_log('轨迹“%s”被删除...' % track_line.name)
def on_left_up(self, event):
if not self._dragging_item:
return
self._dragging_item = False
self.SetCursor(wx.STANDARD_CURSOR)
pt = event.GetPosition()
index, flags = self.HitTest(event.GetPosition())
if flags == wx.LIST_HITTEST_ONITEMLABEL:
drag_to = index
if drag_to == self._drag_from:
do_log('自己不能移动到自己...')
return
self.DeleteItem(self._drag_from)
self.InsertStringItem(drag_to,
self._track_list[self._drag_from].name)
self._track_list.insert(drag_to,
self._track_list.pop(self._drag_from))
if self._track_list[drag_to].is_checked:
self.CheckItem(drag_to, True)
else:
event.Skip()
def on_delete_point(self, event):
track_line = g.track_edit.selected_track_line
if track_line is None or track_line.selected_point is None:
do_log('请先选择轨迹点...')
return
if track_line.point_num < 10:
do_log('轨迹点过少，操作无效...')
return
track_point = track_line.selected_point
index = track_line.track_points.index(track_point)
undo_action = {}
undo_action['action'] = 'del_point'
undo_action['track'] = track_line
undo_action['index'] = index
undo_action['point'] = track_point
g.undo_list = [undo_action]
track_line.track_points.pop(index)
track_line.compute_track_line_args()
if index > track_line.point_num - 1:
index -= 1
track_line.selected_point = track_line.track_points[index]
g.track_edit.set_selected_track_line(track_line)
self.enable_undo()
do_log('选中轨迹点(%d)被删除...' % undo_action['index'])
self.repaint(canvas=const.REDRAW_TRACK)
def get_tile_network(self, tile_url, tile_id, file_format):
tile_path = os.path.join(self._cache_path,
'%s.%s' % (tile_id, file_format))
try:
headers = {'User-Agent': 'Mozilla/5.0'}
response = requests.get(tile_url,
headers=headers,
timeout=const.DOWNLOAD_TIMEOUT)
if 200 == response.status_code:
img = response.content
self._tile_cache[tile_id] = wx.Bitmap(wx.Image(
io.BytesIO(img)))
try:
with open(tile_path, 'wb') as fn:
fn.write(img)
except:
do_log('写缓存文件失败：' + '%s.%s' % (tile_id, file_format))
else:
self._tile_cache[tile_id] = self.g.tile_transparent_bmp
do_log('文件不存在，用透明图片替代：' + tile_url)
except:
self._tile_cache[tile_id] = self.g.tile_transparent_bmp
do_log('下载失败，用透明图片替代：' + tile_url)
return self._tile_cache[tile_id]
def on_merge(self, event):
track1 = None
item1 = 0
i = 0
org_track_list = []
for track_line in self.g.edit_track_list:
if track_line.is_checked:
track1 = track_line
org_track_list.append(copy.deepcopy(track1))
item1 = i
break
i += 1
if track1 is None:
do_log('请先在多选框选择两条以上轨迹...')
return
item2_list = []
for j in range(i + 1, len(self.g.edit_track_list)):
if self.g.edit_track_list[j].is_checked:
item2_list.append(j)
if not item2_list:
do_log('请先在多选框选择两条以上轨迹...')
return
for item2 in item2_list:
track2 = self.g.edit_track_list[item2]
track1.track_points[len(track1.track_points
):] = track2.track_points
if not track2.has_timestamp:
track1.has_timestamp = False
for track_point in track1.track_points:
track_point.track_line = track1
track1.compute_track_line_args()
track1.selected_point = None
track1.name = '合并%05d' % auto_id.get_id()
for item2 in item2_list[-1::-1]:
self.g.track_edit.DeleteItem(item2)
org_track_list.append(self.g.edit_track_list.pop(item2))
self.g.track_edit.DeleteItem(item1)
self.g.edit_track_list.pop(item1)
self.g.track_edit.InsertStringItem(len(self.g.edit_track_list),
track1.name)
self.g.edit_track_list.append(track1)
track1.is_checked = False
self.g.track_edit.set_selected_track_line(track1)
undo_action = {}
undo_action['action'] = 'merge'
undo_action['org_track_list'] = org_track_list
undo_action['new_track'] = track1
self.g.undo_list = [undo_action]
self.enable_undo()
do_log('已将%d个轨迹合并为一个...' % len(org_track_list))
self.repaint(canvas=const.REDRAW_TRACK)
def on_delete_segment(self, event):
track_line = g.track_edit.selected_track_line
if track_line is None:
do_log('请选择轨迹段...')
return
if track_line.sel_start_idx == 0 and track_line.sel_end_idx == track_line.point_num - 1:
# 删除整个轨迹
dlg = wx.MessageDialog(self, '已选择整段轨迹，确认删除该轨迹？', '确认删除？',
wx.YES_NO)
ret = dlg.ShowModal()
dlg.Destroy()
if ret != wx.ID_YES:
return
undo_action = {}
undo_action['action'] = 'edit_del_track'
undo_action['track'] = track_line
g.undo_list = [undo_action]
g.track_edit.set_selected_track_line(None)
sel_index = g.edit_track_list.index(track_line)
g.track_edit.DeleteItem(sel_index)
g.edit_track_list.pop(sel_index)
self.enable_undo()
do_log('轨迹“%s”被删除...' % track_line.name)
else:
undo_action = {}
undo_action['action'] = 'del_seg'
undo_action['track'] = track_line
undo_action['start'] = track_line.sel_start_idx
undo_action['end'] = track_line.sel_end_idx
undo_action['del_seg'] = track_line.track_points[
track_line.sel_start_idx:track_line.sel_end_idx + 1]
g.undo_list = [undo_action]
track_line.track_points[track_line.
sel_start_idx:track_line.sel_end_idx +
1] = []
track_line.selected_point = None
track_line.compute_track_line_args()
g.track_edit.set_selected_track_line(None)
self.enable_undo()
do_log('选中轨迹段(%d点)被删除...' % len(undo_action['del_seg']))
self.repaint(canvas=const.REDRAW_TRACK)
def on_split(self, event):
track_line = g.track_edit.selected_track_line
if track_line is None or track_line.selected_point is None:
do_log('请先选择轨迹点...')
return
track_point = track_line.selected_point
item = g.edit_track_list.index(track_line)
index = track_line.track_points.index(track_point)
if index < 10 or index > track_line.point_num - 10:
do_log('分割点距起始点太近，操作无效...')
return
track1 = track_line
track_org = copy.deepcopy(track1)
track2 = copy.deepcopy(track1)
track1.track_points[index + 1:] = []
track1.compute_track_line_args()
g.track_edit.set_selected_track_line(track1)
track1.name = '分割1_' + track1.name
track2.track_points[0:index + 1] = []
for track_point in track2.track_points:
track_point.track_line = track2
track2.compute_track_line_args()
track2.selected_point = None
track2.name = '分割2_' + track2.name
g.track_edit.SetItemText(item, track1.name)
g.track_edit.InsertStringItem(item + 1, track2.name)
g.edit_track_list.insert(item + 1, track2)
undo_action = {}
undo_action['action'] = 'split'
undo_action['track_org'] = track_org
undo_action['track1'] = track1
undo_action['track2'] = track2
g.undo_list = [undo_action]
self.enable_undo()
do_log('轨迹“%s”被分割为两段...' % track_org.name)
self.repaint(canvas=const.REDRAW_TRACK)
def on_undo(self, event):
if not g.undo_list:
self.enable_undo(False)
return
undo_action = g.undo_list.pop()
if undo_action['action'] == 'tree_del_track':
track_line = undo_action['track']
parent = g.get_parent_folder(track_line)
g.add_data(parent, track_line)
self.enable_undo(False)
self.repaint(const.REDRAW_TRACK)
do_log('刚才删除的轨迹“%s”被恢复至文件夹“%s”' % (track_line.name, parent.name))
elif undo_action['action'] == 'tree_del_folder':
deleted = undo_action['deleted']
for data in deleted:
parent = g.get_parent_folder(data)
g.add_data(parent, data, commit=False)
g.db_mgr.commit()
self.enable_undo(False)
self.repaint(const.REDRAW_TRACK)
do_log('刚才删除的文件夹“%s”被恢复')
elif undo_action['action'] == 'edit_del_track':
track_line = undo_action['track']
g.track_edit.InsertStringItem(len(g.edit_track_list),
track_line.name)
g.edit_track_list.append(track_line)
self.enable_undo(False)
self.repaint(const.REDRAW_TRACK)
do_log('刚才删除的轨迹“%s”已恢复' % track_line.name)
elif undo_action['action'] == 'del_seg':
track_line = undo_action['track']
start_idx = undo_action['start']
track_line.track_points[start_idx:start_idx] = undo_action[
'del_seg']
g.track_edit.selected_track_line = track_line
track_line.sel_start_idx = start_idx
track_line.sel_end_idx = undo_action['end']
track_line.compute_track_line_args()
self.enable_undo(False)
self.repaint(const.REDRAW_TRACK)
do_log('刚才删除的轨迹段(%d点)已恢复' % len(undo_action['del_seg']))
elif undo_action['action'] == 'del_point':
track_line = undo_action['track']
point = undo_action['point']
index = undo_action['index']
track_line.track_points[index:index] = [point]
g.track_edit.selected_track_line = track_line
track_line.sel_start_idx = index
track_line.sel_end_idx = index
track_line.selected_point = point
track_line.compute_track_line_args()
self.enable_undo(False)
self.repaint(const.REDRAW_TRACK)
do_log('刚才删除的轨迹点已恢复...')
elif undo_action['action'] == 'split':
track_org = undo_action['track_org']
track1 = undo_action['track1']
track2 = undo_action['track2']
track_list = g.edit_track_list
g.track_edit.DeleteItem(track_list.index(track2))
g.track_edit.DeleteItem(track_list.index(track1))
track_list.pop(track_list.index(track2))
track_list.pop(track_list.index(track1))
g.track_edit.InsertStringItem(len(track_list), track_org.name)
track_list.append(track_org)
g.track_edit.set_selected_track_line(track_org)
self.enable_undo(False)
self.repaint(const.REDRAW_TRACK)
do_log('刚才被分割的轨迹已重新合并...')
elif undo_action['action'] == 'merge':
org_track_list = undo_action['org_track_list']
new_track = undo_action['new_track']
track_list = g.edit_track_list
g.track_edit.DeleteItem(track_list.index(new_track))
track_list.pop(track_list.index(new_track))
for track_line in org_track_list:
g.track_edit.InsertStringItem(len(track_list), track_line.name)
track_list.append(track_line)
track_line.is_checked = False
for point in track_line.track_points:
point.track_line = track_line
g.track_edit.set_selected_track_line(None)
self.enable_undo(False)
self.repaint(const.REDRAW_TRACK)
do_log('刚才被合并的轨迹已重新分割为多个...')
elif undo_action['action'] == 'reverse':
track_line = undo_action['track']
track_line.track_points.reverse()
track_line.has_timestamp = undo_action['has_timestamp']
track_line.compute_track_line_args()
g.track_edit.set_selected_track_line(track_line)
self.enable_undo(False)
self.repaint(canvas=const.REDRAW_TRACK)
do_log('刚才翻转的轨迹已恢复至原来方向...')
elif undo_action['action'] == 'del_all_wpts':
redo_dir = '被删路点恢复%05d' % auto_id.get_id()
wpt_folder = g.track_tree.create_child_folder(
g.data_root, redo_dir)
for wpt in g.wpt_list_deleted:
wpt.parent = wpt_folder.uuid
g.add_data(wpt_folder, wpt, commit=False)
g.db_mgr.commit()
g.wpt_list_deleted = []
self.repaint(canvas=const.REDRAW_COPY)
do_log('刚才被删除的路点统一被恢复至<%s>文件夹...' % redo_dir)
def parse_gpx(path, parent_uuid):
try:
tree = ET.parse(path)
except:
do_log('解析gpx文件出错！')
return []
root = tree.getroot()
tag = trim_tag(root.tag)
if tag != 'gpx':
do_log('解析gpx文件出错！')
return []
file_dir, file_name = os.path.split(path)
file_name = file_name[:-4]
folder = DataFolder(parent=parent_uuid, name=file_name)
folder_data = []
wpt_folder = DataFolder(parent=folder.uuid, name='路点')
wpt_data = []
for child in root:
tag = trim_tag(child.tag)
if tag == 'name':
folder.name = child.text
elif tag == 'metadata':
for sub_child in child:
sub_tag = trim_tag(sub_child.tag)
if sub_tag == 'name':
folder.name = sub_child.text
elif tag == 'wpt':
name = '未命名'
lon = float(child.attrib['lon'])
lat = float(child.attrib['lat'])
alt = 0.0
timestamp_str = None
for sub_child in child:
tag1 = trim_tag(sub_child.tag)
if tag1 == 'name':
name = sub_child.text
elif tag1 == 'ele':
alt = float(sub_child.text)
elif tag1 == 'time':
timestamp_str = sub_child.text
wpt = WayPoint(name, lon, lat, alt, timestamp=timestamp_str, parent=wpt_folder.uuid)
wpt_data.append(wpt)
elif tag == 'trk':
name = file_name
for sub_child in child:
sub_tag = trim_tag(sub_child.tag)
if sub_tag == 'name':
name = sub_child.text
elif sub_tag == 'trkseg':
track_line = TrackLine(parent=folder.uuid)
parse_trkseg(track_line, trkseg=sub_child, name=name)
if track_line.track_points:
folder_data.append(track_line)
if not folder_data and not wpt_data:
return [] # 文件夹内容为空，不新建文件夹
if wpt_data and not folder_data:
wpt_folder.parent = parent_uuid
wpt_folder.name = file_name
return [wpt_folder] + wpt_data
if folder_data and not wpt_data:
if len(folder_data) == 1:
folder_data[0].parent = parent_uuid
return folder_data
else:
return [folder] + folder_data
if len(wpt_data) == 1:
wpt_data[0].parent = folder.uuid
return [folder] + wpt_data + folder_data
return [folder] + [wpt_folder] + wpt_data + folder_data
def download_track_alt_main_thread(self):
do_log('正在为轨迹“%s”下载高程数据，请稍候...' % self._track_line.name)
num_filled = 0
num_error = 0
self._total_progress_now = 0
self._ctl_gauge_total.SetValue(0)
i = 0
for point in self._track_line.track_points:
i += 1
self._ctl_progress_tip.SetLabelText('正在为第%d个轨迹点填充高程数据...' % i)
if point.alt <= 0: # 本应用中假定海拔高度都应大于0
self.g.srtm_mgr.progress_now = 3.0
self._ctl_gauge_point.SetValue(self.g.srtm_mgr.progress_now)
alt = self.g.srtm_mgr.get_alt_local(point.lon, point.lat)
if alt is None:
thread = threading.Thread(
target=self.g.srtm_mgr.get_alt_network,
args=(point.lon, point.lat))
thread.setDaemon(True)
thread.start()
time.sleep(0.01)
while self.g.srtm_mgr.downloading:
self._ctl_gauge_point.SetValue(
self.g.srtm_mgr.progress_now)
time.sleep(0.01)
alt = self.g.srtm_mgr.alt
self._ctl_gauge_point.SetValue(self.g.srtm_mgr.PROGRESS_RANGE)
if alt < 0:
num_error += 1
if alt == self.g.srtm_mgr.ERROR_NETWORK:
do_log('因网络原因下载失败，请稍后再试...')
break
elif alt == self.g.srtm_mgr.ERROR_CANCELED:
do_log('下载过程被人为中止！')
break
else:
do_log('为第%d个轨迹点获取的高程数据有误...' % i)
else:
point.alt = alt
num_filled += 1
self._total_progress_now = i * self._total_progress_unit
self._ctl_gauge_total.SetValue(int(self._total_progress_now))
if num_filled > 0:
do_log('已为%d轨迹点添加高程数据...' % num_filled)
self._track_line.compute_track_line_args()
if self.g.in_editing:
self.g.track_edit.set_selected_track_line(self._track_line)
self.g.frame.repaint(canvas=const.REDRAW_TRACK)
elif num_error == 0:
do_log('本轨迹所有轨迹点已有高程数据，不需下载...')
self._ctl_gauge_total.SetValue(self.g.srtm_mgr.PROGRESS_RANGE)
if not self.g.srtm_mgr.manual_canceled:
self._ctl_progress_tip.SetLabelText('高程数据填充完成！')
time.sleep(1)
self.Destroy()
def on_map_download(self, event):
g.downloading_map = True
do_log('请按住鼠标左键拖动来框选欲下载区域...')
g.map_canvas.SetCursor(wx.Cursor(wx.CURSOR_SIZING))
def on_delete_wpt(self, event):
wpt = self._popup_context[event.Id]
self.g.del_wpt(wpt)
self.g.frame.repaint(canvas=const.REDRAW_COPY)
do_log('路点“%s”被删除...' % wpt.name)
def on_search_route(self, event):
dlg = RouteSearchDlg()
dlg.CentreOnParent()
if dlg.ShowModal() == wx.ID_OK:
wpt_start = None
wpt_end = None
start_idx = dlg.start.GetCurrentSelection()
if start_idx < 0:
start_name = dlg.start.GetValue()
if start_name:
way_points = search.find_pos_from_name(
start_name, g.search_api)
if way_points:
wpt_start = WayPoint(way_points[0][0],
way_points[0][1],
way_points[0][2],
bmp_index=g.default_wpt_bmp_index)
else:
wpt_start = None
else:
wpt_start = g.wpt_list[start_idx]
end_idx = dlg.end.GetCurrentSelection()
if end_idx < 0:
end_name = dlg.end.GetValue()
if end_name:
way_points = search.find_pos_from_name(
end_name, g.search_api)
if way_points:
wpt_end = WayPoint(way_points[0][0],
way_points[0][1],
way_points[0][2],
bmp_index=g.default_wpt_bmp_index)
else:
wpt_end = None
else:
wpt_end = g.wpt_list[end_idx]
if wpt_start and wpt_end:
routes = search.find_drive_route(
(wpt_start.lon, wpt_start.lat), (wpt_end.lon, wpt_end.lat),
g.search_api)
if len(routes) > 0:
folder_name = '路径搜索结果：%s --> %s' % (wpt_start.name,
wpt_end.name)
new_folder = g.track_tree.create_child_folder(
g.data_root, folder_name)
first_track = None
for route in routes:
track_line = TrackLine(new_folder.uuid,
name='行车路径%05d' %
auto_id.get_id())
track_line.load_from_points(route)
g.add_data(new_folder, track_line, commit=False)
if not first_track:
first_track = track_line
if not wpt_start.parent:
wpt_start.parent = new_folder.uuid
g.add_data(new_folder, wpt_start, commit=False)
if not wpt_end.parent:
wpt_end.parent = new_folder.uuid
g.add_data(new_folder, wpt_end, commit=False)
g.db_mgr.commit()
g.track_tree.selected_track_line = first_track
g.track_tree.SelectItem(first_track.tree_node)
g.map_canvas.zoom_to_track_line(first_track)
do_log('找到%d条行车路线' % len(routes))
else:
do_log('未找到合适的行车路线...')
else:
do_log('地名为空或无效...')
dlg.Destroy()
