def _focused_dev_changed(self):
neds_focused = np.empty((0, 3))
if self.focused_dev == '':
pass
elif self.focused_dev == 'All':
self._zoomall()
else:
neds_focused = np.array([self.neds[np.equal(self.devs, int(self. focused_dev))][0]])
if len(neds_focused) > 0:
self.plot_data.set_data('n_focused', neds_focused.T[0])
self.plot_data.set_data('e_focused', neds_focused.T[1])
if self.focused_dev == 'All':
self._zoomall()
else:
plot_square_axes(self.plot, 'e_focused', 'n_focused')
def _focused_dev_changed(self):
neds_focused = np.empty((0, 3))
if self.focused_dev == '':
pass
elif self.focused_dev == 'All':
self._zoomall()
else:
neds_focused = np.array(
[self.neds[np.equal(self.devs, int(self.focused_dev))][0]])
if len(neds_focused) > 0:
self.plot_data.set_data('n_focused', neds_focused.T[0])
self.plot_data.set_data('e_focused', neds_focused.T[1])
if self.focused_dev == 'All':
self._zoomall()
else:
plot_square_axes(self.plot, 'e_focused', 'n_focused')
def baseline_callback(self, sbp_msg):
soln = MsgBaselineNEDDepA(sbp_msg)
self.last_soln = soln
table = []
soln.n = soln.n * 1e-3
soln.e = soln.e * 1e-3
soln.d = soln.d * 1e-3
soln.h_accuracy = soln.h_accuracy * 1e-3
soln.v_accuracy = soln.v_accuracy * 1e-3
dist = np.sqrt(soln.n**2 + soln.e**2 + soln.d**2)
tow = soln.tow * 1e-3
if self.nsec is not None:
tow += self.nsec * 1e-9
((tloc, secloc), (tgps, secgps)) = log_time_strings(self.week, tow)
if self.directory_name_b == '':
filepath = time.strftime("baseline_log_%Y%m%d-%H%M%S.csv")
else:
filepath = os.path.join(
self.directory_name_b,
time.strftime("baseline_log_%Y%m%d-%H%M%S.csv"))
if self.logging_b == False:
self.log_file = None
if self.logging_b:
if self.log_file is None:
self.log_file = sopen(filepath, 'w')
self.log_file.write(
'pc_time,gps_time,tow(msec),north(meters),east(meters),down(meters),h_accuracy(meters),v_accuracy(meters),'
'distance(meters),num_sats,flags,num_hypothesis\n')
log_str_gps = ''
if tgps != '' and secgps != 0:
log_str_gps = "{0}:{1:06.6f}".format(tgps, float(secgps))
self.log_file.write(
'%s,%s,%.3f,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%d,%d,%d\n' %
("{0}:{1:06.6f}".format(tloc, float(secloc)), log_str_gps, tow,
soln.n, soln.e, soln.d, soln.h_accuracy, soln.v_accuracy,
dist, soln.n_sats, soln.flags, self.num_hyps))
self.log_file.flush()
self.last_mode = get_mode(soln)
if self.last_mode < 1:
table.append(('GPS Time', EMPTY_STR))
table.append(('GPS Week', EMPTY_STR))
table.append(('GPS TOW', EMPTY_STR))
table.append(('N', EMPTY_STR))
table.append(('E', EMPTY_STR))
table.append(('D', EMPTY_STR))
table.append(('h_accuracy', EMPTY_STR))
table.append(('v_accuracy', EMPTY_STR))
table.append(('Dist.', EMPTY_STR))
table.append(('Num. Sats', EMPTY_STR))
table.append(('Flags', EMPTY_STR))
table.append(('Mode', EMPTY_STR))
else:
self.last_btime_update = time.time()
if self.week is not None:
table.append(
('GPS Time', "{0}:{1:06.3f}".format(tgps, float(secgps))))
table.append(('GPS Week', str(self.week)))
table.append(('GPS TOW', "{:.3f}".format(tow)))
table.append(('N', soln.n))
table.append(('E', soln.e))
table.append(('D', soln.d))
table.append(('h_accuracy', soln.h_accuracy))
table.append(('v_accuracy', soln.v_accuracy))
table.append(('Dist.', dist))
table.append(('Num. Sats', soln.n_sats))
table.append(('Flags', '0x%02x' % soln.flags))
table.append(('Mode', mode_dict[self.last_mode]))
self.table = table
# Rotate array, deleting oldest entries to maintain
# no more than N in plot
self.n[1:] = self.n[:-1]
self.e[1:] = self.e[:-1]
self.d[1:] = self.d[:-1]
self.mode[1:] = self.mode[:-1]
# Insert latest position
if self.last_mode > 1:
self.n[0], self.e[0], self.d[0] = soln.n, soln.e, soln.d
else:
self.n[0], self.e[0], self.d[0] = [np.NAN, np.NAN, np.NAN]
self.mode[0] = self.last_mode
if np.any(self.mode):
float_indexer = (self.mode == FLOAT_MODE)
fixed_indexer = (self.mode == FIXED_MODE)
dgnss_indexer = (self.mode == DGNSS_MODE)
if np.any(fixed_indexer):
self.plot_data.set_data('n_fixed', self.n[fixed_indexer])
self.plot_data.set_data('e_fixed', self.e[fixed_indexer])
self.plot_data.set_data('d_fixed', self.d[fixed_indexer])
if np.any(float_indexer):
self.plot_data.set_data('n_float', self.n[float_indexer])
self.plot_data.set_data('e_float', self.e[float_indexer])
self.plot_data.set_data('d_float', self.d[float_indexer])
if np.any(dgnss_indexer):
self.plot_data.set_data('n_dgnss', self.n[dgnss_indexer])
self.plot_data.set_data('e_dgnss', self.e[dgnss_indexer])
self.plot_data.set_data('d_dgnss', self.d[dgnss_indexer])
# Update our last solution icon
if self.last_mode == FIXED_MODE:
self._reset_remove_current()
self.plot_data.set_data('cur_fixed_n', [soln.n])
self.plot_data.set_data('cur_fixed_e', [soln.e])
self.plot_data.set_data('cur_fixed_d', [soln.d])
elif self.last_mode == FLOAT_MODE:
self._reset_remove_current()
self.plot_data.set_data('cur_float_n', [soln.n])
self.plot_data.set_data('cur_float_e', [soln.e])
self.plot_data.set_data('cur_float_d', [soln.d])
elif self.last_mode == DGNSS_MODE:
self._reset_remove_current()
self.plot_data.set_data('cur_dgnss_n', [soln.n])
self.plot_data.set_data('cur_dgnss_e', [soln.e])
self.plot_data.set_data('cur_dgnss_d', [soln.d])
else:
pass
# make the zoomall win over the position centered button
# position centered button has no effect when zoom all enabled
if not self.zoomall and self.position_centered:
d = (self.plot.index_range.high - self.plot.index_range.low) / 2.
self.plot.index_range.set_bounds(soln.e - d, soln.e + d)
d = (self.plot.value_range.high - self.plot.value_range.low) / 2.
self.plot.value_range.set_bounds(soln.n - d, soln.n + d)
if self.zoomall:
plot_square_axes(self.plot, ('e_fixed', 'e_float', 'e_dgnss'),
('n_fixed', 'n_float', 'n_dgnss'))
def pos_llh_callback(self, sbp_msg, **metadata):
soln = MsgPosLLH(sbp_msg)
masked_flag = soln.flags & 0x7
if masked_flag == 0:
psuedo_absolutes = False
else:
psuedo_absolutes = True
pos_table = []
if self.log_file is None:
self.log_file = open(
time.strftime("position_log_%Y%m%d-%H%M%S.csv"), 'w')
self.log_file.write(
"time,latitude(degrees),longitude(degrees),altitude(meters),n_sats,flags\n"
)
tow = soln.tow * 1e-3
if self.nsec is not None:
tow += self.nsec * 1e-9
if self.week is not None:
t = datetime.datetime(1980, 1, 6) + \
datetime.timedelta(weeks=self.week) + \
datetime.timedelta(seconds=tow)
pos_table.append(('GPS Time', t))
pos_table.append(('GPS Week', str(self.week)))
self.log_file.write('%s,%.10f,%.10f,%.4f,%d,%d\n' %
(str(t), soln.lat, soln.lon, soln.height,
soln.n_sats, soln.flags))
self.log_file.flush()
pos_table.append(('GPS ToW', tow))
pos_table.append(('Num. sats', soln.n_sats))
pos_table.append(('Lat', soln.lat))
pos_table.append(('Lng', soln.lon))
pos_table.append(('Alt', soln.height))
pos_table.append(('Flags', '0x%02x' % soln.flags))
if (soln.flags & 0xff) == 0:
pos_table.append(('Mode', 'SPP (single point position)'))
elif (soln.flags & 0xff) == 1:
pos_table.append(('Mode', 'Fixed RTK'))
elif (soln.flags & 0xff) == 2:
pos_table.append(('Mode', 'Float RTK'))
else:
pos_table.append(('Mode', 'Unknown'))
if psuedo_absolutes:
# setup_plot variables
self.lats_psuedo_abs.append(soln.lat)
self.lngs_psuedo_abs.append(soln.lon)
self.alts_psuedo_abs.append(soln.height)
self.lats_psuedo_abs = self.lats_psuedo_abs[-1000:]
self.lngs_psuedo_abs = self.lngs_psuedo_abs[-1000:]
self.alts_psuedo_abs = self.alts_psuedo_abs[-1000:]
self.plot_data.set_data('lat_ps', self.lats_psuedo_abs)
self.plot_data.set_data('lng_ps', self.lngs_psuedo_abs)
self.plot_data.set_data('alt_ps', self.alts_psuedo_abs)
self.plot_data.set_data('cur_lat_ps', [soln.lat])
self.plot_data.set_data('cur_lng_ps', [soln.lon])
t_psuedo_abs = range(len(self.lats))
self.plot_data.set_data('t', t)
self.plot_data.set_data('t_ps', t_psuedo_abs)
# set-up table variables
self.table_psuedo_abs = pos_table
else:
# setup_plot variables
self.lats.append(soln.lat)
self.lngs.append(soln.lon)
self.alts.append(soln.height)
self.lats = self.lats[-1000:]
self.lngs = self.lngs[-1000:]
self.alts = self.alts[-1000:]
self.plot_data.set_data('lat', self.lats)
self.plot_data.set_data('lng', self.lngs)
self.plot_data.set_data('alt', self.alts)
self.plot_data.set_data('cur_lat', [soln.lat])
self.plot_data.set_data('cur_lng', [soln.lon])
t = range(len(self.lats))
self.plot_data.set_data('t', t)
# set-up table variables
self.pos_table_spp = pos_table
self.table_spp = self.pos_table_spp + self.vel_table + self.dops_table
# TODO: figure out how to center the graph now that we have two separate messages
# when we selectivtely send only SPP, the centering function won't work anymore
if self.position_centered:
d = (self.plot.index_range.high -
self.plot.index_range.low) / 2.
self.plot.index_range.set_bounds(soln.lon - d, soln.lon + d)
d = (self.plot.value_range.high -
self.plot.value_range.low) / 2.
self.plot.value_range.set_bounds(soln.lat - d, soln.lat + d)
if self.zoomall:
plot_square_axes(self.plot, 'lng', 'lat')
def baseline_callback(self, sbp_msg):
soln = MsgBaselineNED(sbp_msg)
table = []
soln.n = soln.n * 1e-3
soln.e = soln.e * 1e-3
soln.d = soln.d * 1e-3
dist = np.sqrt(soln.n**2 + soln.e**2 + soln.d**2)
tow = soln.tow * 1e-3
if self.nsec is not None:
tow += self.nsec * 1e-9
if self.week is not None:
t = datetime.datetime(1980, 1, 6) + \
datetime.timedelta(weeks=self.week) + \
datetime.timedelta(seconds=tow)
table.append(('GPS Time', t))
table.append(('GPS Week', str(self.week)))
if self.log_file is None:
self.log_file = open(time.strftime("baseline_log_%Y%m%d-%H%M%S.csv"), 'w')
self.log_file.write('time,north(meters),east(meters),down(meters),distance(meters),num_sats,flags,num_hypothesis\n')
self.log_file.write('%s,%.4f,%.4f,%.4f,%.4f,%d,0x%02x,%d\n' % (
str(t),
soln.n, soln.e, soln.d, dist,
soln.n_sats,
soln.flags,
self.num_hyps)
)
self.log_file.flush()
table.append(('GPS ToW', tow))
table.append(('N', soln.n))
table.append(('E', soln.e))
table.append(('D', soln.d))
table.append(('Dist.', dist))
table.append(('Num. Sats.', soln.n_sats))
table.append(('Flags', '0x%02x' % soln.flags))
fixed = (soln.flags & 1) == 1
if fixed:
table.append(('Mode', 'Fixed RTK'))
else:
table.append(('Mode', 'Float'))
if time.time() - self.last_hyp_update < 10 and self.num_hyps != 1:
table.append(('IAR Num. Hyps.', self.num_hyps))
else:
table.append(('IAR Num. Hyps.', "None"))
# Rotate array, deleting oldest entries to maintain
# no more than N in plot
self.neds[1:] = self.neds[:-1]
self.fixeds[1:] = self.fixeds[:-1]
# Insert latest position
self.neds[0][:] = [soln.n, soln.e, soln.d]
self.fixeds[0] = fixed
neds_fixed = self.neds[self.fixeds]
neds_float = self.neds[np.logical_not(self.fixeds)]
if not all(map(any, np.isnan(neds_fixed))):
self.plot_data.set_data('n_fixed', neds_fixed.T[0])
self.plot_data.set_data('e_fixed', neds_fixed.T[1])
self.plot_data.set_data('d_fixed', neds_fixed.T[2])
if not all(map(any, np.isnan(neds_float))):
self.plot_data.set_data('n_float', neds_float.T[0])
self.plot_data.set_data('e_float', neds_float.T[1])
self.plot_data.set_data('d_float', neds_float.T[2])
if fixed:
self.plot_data.set_data('cur_fixed_n', [soln.n])
self.plot_data.set_data('cur_fixed_e', [soln.e])
self.plot_data.set_data('cur_fixed_d', [soln.d])
self.plot_data.set_data('cur_float_n', [])
self.plot_data.set_data('cur_float_e', [])
self.plot_data.set_data('cur_float_d', [])
else:
self.plot_data.set_data('cur_float_n', [soln.n])
self.plot_data.set_data('cur_float_e', [soln.e])
self.plot_data.set_data('cur_float_d', [soln.d])
self.plot_data.set_data('cur_fixed_n', [])
self.plot_data.set_data('cur_fixed_e', [])
self.plot_data.set_data('cur_fixed_d', [])
self.plot_data.set_data('ref_n', [0.0])
self.plot_data.set_data('ref_e', [0.0])
self.plot_data.set_data('ref_d', [0.0])
if self.position_centered:
d = (self.plot.index_range.high - self.plot.index_range.low) / 2.
self.plot.index_range.set_bounds(soln.e - d, soln.e + d)
d = (self.plot.value_range.high - self.plot.value_range.low) / 2.
self.plot.value_range.set_bounds(soln.n - d, soln.n + d)
if self.zoomall:
plot_square_axes(self.plot, ('e_fixed', 'e_float'), ('n_fixed', 'n_float'))
self.table = table
def pos_llh_callback(self, sbp_msg, **metadata):
if sbp_msg.msg_type == SBP_MSG_POS_LLH_DEP_A:
soln = MsgPosLLHDepA(sbp_msg)
else:
soln = MsgPosLLH(sbp_msg)
self.last_soln = soln
self.last_pos_mode = get_mode(soln)
pos_table = []
soln.h_accuracy *= 1e-3
soln.v_accuracy *= 1e-3
tow = soln.tow * 1e-3
if self.nsec is not None:
tow += self.nsec * 1e-9
if self.week is not None:
t = datetime.datetime(1980, 1, 6) + \
datetime.timedelta(weeks=self.week) + \
datetime.timedelta(seconds=tow)
tstr = t.strftime('%Y-%m-%d %H:%M')
secs = t.strftime('%S.%f')
if(self.directory_name_p == ''):
filepath_p = time.strftime("position_log_%Y%m%d-%H%M%S.csv")
else:
filepath_p = os.path.join(self.directory_name_p, time.strftime("position_log_%Y%m%d-%H%M%S.csv"))
if self.logging_p == False:
self.log_file = None
if self.logging_p:
if self.log_file is None:
self.log_file = open(filepath_p, 'w')
self.log_file.write("time,latitude(degrees),longitude(degrees),altitude(meters),"
"h_accuracy(meters),v_accuracy(meters),n_sats,flags\n")
self.log_file.write('%s,%.10f,%.10f,%.4f,%.4f,%.4f,%d,%d\n' % (
str(t),
soln.lat, soln.lon, soln.height,
soln.h_accuracy, soln.v_accuracy,
soln.n_sats, soln.flags)
)
self.log_file.flush()
if self.last_pos_mode == 0:
pos_table.append(('GPS Time', EMPTY_STR))
pos_table.append(('GPS Week', EMPTY_STR))
pos_table.append(('GPS TOW', EMPTY_STR))
pos_table.append(('Num. Signals', EMPTY_STR))
pos_table.append(('Lat', EMPTY_STR))
pos_table.append(('Lng', EMPTY_STR))
pos_table.append(('Height', EMPTY_STR))
pos_table.append(('h_accuracy', EMPTY_STR))
pos_table.append(('v_accuracy', EMPTY_STR))
else:
self.last_stime_update = time.time()
if self.week is not None:
pos_table.append(('GPS Time', "{0}:{1:06.3f}".format(tstr, float(secs))))
pos_table.append(('GPS Week', str(self.week)))
pos_table.append(('GPS TOW', "{:.3f}".format(tow)))
pos_table.append(('Num. Sats', soln.n_sats))
pos_table.append(('Lat', soln.lat))
pos_table.append(('Lng', soln.lon))
pos_table.append(('Height', soln.height))
pos_table.append(('h_accuracy', soln.h_accuracy))
pos_table.append(('v_accuracy', soln.v_accuracy))
pos_table.append(('Pos Flags', '0x%03x' % soln.flags))
pos_table.append(('Pos Fix Mode', mode_dict[self.last_pos_mode]))
self.auto_survey()
# setup_plot variables
self.lats[1:] = self.lats[:-1]
self.lngs[1:] = self.lngs[:-1]
self.alts[1:] = self.alts[:-1]
self.tows[1:] = self.tows[:-1]
self.modes[1:] = self.modes[:-1]
self.lats[0] = soln.lat
self.lngs[0] = soln.lon
self.alts[0] = soln.height
self.tows[0] = soln.tow
self.modes[0] = self.last_pos_mode
self.lats = self.lats[-self.plot_history_max:]
self.lngs = self.lngs[-self.plot_history_max:]
self.alts = self.alts[-self.plot_history_max:]
self.tows = self.tows[-self.plot_history_max:]
self.modes = self.modes[-self.plot_history_max:]
# SPP
spp_indexer, dgnss_indexer, float_indexer, fixed_indexer = None, None, None, None
if np.any(self.modes):
spp_indexer = (self.modes == SPP_MODE)
dgnss_indexer = (self.modes == DGNSS_MODE)
float_indexer = (self.modes == FLOAT_MODE)
fixed_indexer = (self.modes == FIXED_MODE)
# make sure that there is at least one true in indexer before setting
if any(spp_indexer):
self.plot_data.set_data('lat_spp', self.lats[spp_indexer])
self.plot_data.set_data('lng_spp', self.lngs[spp_indexer])
self.plot_data.set_data('alt_spp', self.alts[spp_indexer])
if any(dgnss_indexer):
self.plot_data.set_data('lat_dgnss', self.lats[dgnss_indexer])
self.plot_data.set_data('lng_dgnss', self.lngs[dgnss_indexer])
self.plot_data.set_data('alt_dgnss', self.alts[dgnss_indexer])
if any(float_indexer):
self.plot_data.set_data('lat_float', self.lats[float_indexer])
self.plot_data.set_data('lng_float', self.lngs[float_indexer])
self.plot_data.set_data('alt_float', self.alts[float_indexer])
if any(fixed_indexer):
self.plot_data.set_data('lat_fixed', self.lats[fixed_indexer])
self.plot_data.set_data('lng_fixed', self.lngs[fixed_indexer])
self.plot_data.set_data('alt_fixed', self.alts[fixed_indexer])
self._reset_remove_current()
if self.last_pos_mode == SPP_MODE:
self.plot_data.set_data('cur_lat_spp', [soln.lat])
self.plot_data.set_data('cur_lng_spp', [soln.lon])
if self.last_pos_mode == DGNSS_MODE:
self.plot_data.set_data('cur_lat_dgnss', [soln.lat])
self.plot_data.set_data('cur_lng_dgnss', [soln.lon])
if self.last_pos_mode == FLOAT_MODE:
self.plot_data.set_data('cur_lat_float', [soln.lat])
self.plot_data.set_data('cur_lng_float', [soln.lon])
if self.last_pos_mode == FIXED_MODE:
self.plot_data.set_data('cur_lat_fixed', [soln.lat])
self.plot_data.set_data('cur_lng_fixed', [soln.lon])
# set-up table variables
self.pos_table = pos_table
self.table = self.pos_table + self.vel_table + self.dops_table
# TODO: figure out how to center the graph now that we have two separate messages
# when we selectively send only SPP, the centering function won't work anymore
if not self.zoomall and self.position_centered:
d = (self.plot.index_range.high - self.plot.index_range.low) / 2.
self.plot.index_range.set_bounds(soln.lon - d, soln.lon + d)
d = (self.plot.value_range.high - self.plot.value_range.low) / 2.
self.plot.value_range.set_bounds(soln.lat - d, soln.lat + d)
if self.zoomall:
plot_square_axes(self.plot, ('lng_spp', 'lng_dgnss', 'lng_float','lng_fixed'),
('lat_spp', 'lat_dgnss', 'lat_float','lat_fixed'))
def _zoomall(self):
plot_square_axes(self.plot, ('e_satisfied', 'e_unsatisfied'), ('n_satisfied', 'e_unsatisfied'))
def baseline_callback(self, sbp_msg):
self.last_btime_update = time.time()
soln = MsgBaselineNED(sbp_msg)
self.last_soln = soln
table = []
soln.n = soln.n * 1e-3
soln.e = soln.e * 1e-3
soln.d = soln.d * 1e-3
dist = np.sqrt(soln.n**2 + soln.e**2 + soln.d**2)
tow = soln.tow * 1e-3
if self.nsec is not None:
tow += self.nsec * 1e-9
if self.week is not None:
t = datetime.datetime(1980, 1, 6) + \
datetime.timedelta(weeks=self.week) + \
datetime.timedelta(seconds=tow)
table.append(('GPS Time', t))
table.append(('GPS Week', str(self.week)))
if self.directory_name_b == '':
filepath = time.strftime("baseline_log_%Y%m%d-%H%M%S.csv")
else:
filepath = os.path.join(
self.directory_name_b,
time.strftime("baseline_log_%Y%m%d-%H%M%S.csv"))
if self.logging_b == False:
self.log_file = None
if self.logging_b:
if self.log_file is None:
self.log_file = open(filepath, 'w')
self.log_file.write(
'time,north(meters),east(meters),down(meters),distance(meters),num_signals,flags,num_hypothesis\n'
)
self.log_file.write('%s,%.4f,%.4f,%.4f,%.4f,%d,0x%02x,%d\n' %
(str(t), soln.n, soln.e, soln.d, dist,
soln.n_sats, soln.flags, self.num_hyps))
self.log_file.flush()
table.append(('GPS ToW', tow))
table.append(('N', soln.n))
table.append(('E', soln.e))
table.append(('D', soln.d))
table.append(('Dist.', dist))
table.append(('Num. Signals.', soln.n_sats))
table.append(('Flags', '0x%02x' % soln.flags))
table.append(('Mode', self.mode_string(soln)))
if time.time() - self.last_hyp_update < 10 and self.num_hyps != 1:
table.append(('IAR Num. Hyps.', self.num_hyps))
else:
table.append(('IAR Num. Hyps.', "None"))
# Rotate array, deleting oldest entries to maintain
# no more than N in plot
self.neds[1:] = self.neds[:-1]
self.fixeds[1:] = self.fixeds[:-1]
# Insert latest position
self.neds[0][:] = [soln.n, soln.e, soln.d]
self.fixeds[0] = self.fixed
neds_fixed = self.neds[self.fixeds]
neds_float = self.neds[np.logical_not(self.fixeds)]
if not all(map(any, np.isnan(neds_fixed))):
self.plot_data.set_data('n_fixed', neds_fixed.T[0])
self.plot_data.set_data('e_fixed', neds_fixed.T[1])
self.plot_data.set_data('d_fixed', neds_fixed.T[2])
if not all(map(any, np.isnan(neds_float))):
self.plot_data.set_data('n_float', neds_float.T[0])
self.plot_data.set_data('e_float', neds_float.T[1])
self.plot_data.set_data('d_float', neds_float.T[2])
if self.fixed:
self.plot_data.set_data('cur_fixed_n', [soln.n])
self.plot_data.set_data('cur_fixed_e', [soln.e])
self.plot_data.set_data('cur_fixed_d', [soln.d])
self.plot_data.set_data('cur_float_n', [])
self.plot_data.set_data('cur_float_e', [])
self.plot_data.set_data('cur_float_d', [])
else:
self.plot_data.set_data('cur_float_n', [soln.n])
self.plot_data.set_data('cur_float_e', [soln.e])
self.plot_data.set_data('cur_float_d', [soln.d])
self.plot_data.set_data('cur_fixed_n', [])
self.plot_data.set_data('cur_fixed_e', [])
self.plot_data.set_data('cur_fixed_d', [])
self.plot_data.set_data('ref_n', [0.0])
self.plot_data.set_data('ref_e', [0.0])
self.plot_data.set_data('ref_d', [0.0])
if self.position_centered:
d = (self.plot.index_range.high - self.plot.index_range.low) / 2.
self.plot.index_range.set_bounds(soln.e - d, soln.e + d)
d = (self.plot.value_range.high - self.plot.value_range.low) / 2.
self.plot.value_range.set_bounds(soln.n - d, soln.n + d)
if self.zoomall:
plot_square_axes(self.plot, ('e_fixed', 'e_float'),
('n_fixed', 'n_float'))
self.table = table
def _zoomall(self):
plot_square_axes(self.plot, ('e_satisfied', 'e_unsatisfied'),
('n_satisfied', 'e_unsatisfied'))
def baseline_callback(self, sbp_msg):
#soln = MsgBaselineNED(sbp_msg)
soln = sbp_msg
soln.n = soln.n * 1e-3
soln.e = soln.e * 1e-3
soln.d = soln.d * 1e-3
dist = np.sqrt(soln.n**2 + soln.e**2 + soln.d**2)
tow = soln.tow * 1e-3
if self.nsec is not None:
tow += self.nsec * 1e-9
#row_data = [soln.sender, soln.n, soln.e, soln.d, soln.n_sats, soln.flags, soln.depth]
row_data = [
soln.sender, soln.n, soln.e, soln.d, soln.n_sats, soln.flags
]
try:
key = int(row_data[0])
self.data_dict[key] = row_data
except:
pass
self.utils.setDataViewTable(self.data_dict)
if soln.sender not in self.dev_list:
self.dev_list.append(soln.sender)
self.dev_all_list.append(str(soln.sender))
# Rotate array, deleting oldest entries to maintain
# no more than N in plot
self.neds[1:] = self.neds[:-1]
self.fixeds[1:] = self.fixeds[:-1]
self.devs[1:] = self.devs[:-1]
self.times[1:] = self.times[:-1]
# Insert latest position
self.neds[0][:] = [soln.n, soln.e, soln.d]
self.fixeds[0] = (soln.flags & 1) == 1
self.devs[0] = int(soln.sender)
self.times[0] = int(time.time())
neds_all = []
neds_fixed = []
neds_float = []
neds_satisfied = []
neds_unsatisfied = []
devs = np.unique(self.devs)
if devs[0] == 0:
devs = devs[1:]
for dev in devs:
is_dev = np.equal(dev, self.devs)
neds_all.append(self.neds[is_dev][0])
try:
neds_fixed.append(self.neds[np.logical_and(
is_dev, self.fixeds)][0])
except:
pass
try:
neds_float.append(self.neds[np.logical_and(
is_dev, np.logical_not(self.fixeds))][0])
except:
pass
position_satisfied, depth_satisfied, time_satisfied = self._threshold_satisfied(
)
is_satisfied = np.logical_and(position_satisfied, depth_satisfied,
time_satisfied)
try:
neds_satisfied.append(self.neds[np.logical_and(
is_dev, is_satisfied)][0])
except:
pass
try:
neds_unsatisfied.append(self.neds[np.logical_and(
is_dev, np.logical_not(is_satisfied))][0])
except:
pass
neds_all = np.array(neds_all)
neds_fixed = np.array(neds_fixed)
neds_float = np.array(neds_float)
neds_satisfied = np.array(neds_satisfied)
neds_unsatisfied = np.array(neds_unsatisfied)
self.neds_all = neds_all
self.neds_satisfied = neds_satisfied
self.neds_unsatisfied = neds_unsatisfied
neds_focused = np.empty((0, 3))
if self.focused_dev == '':
pass
elif self.focused_dev == 'All':
neds_focused = neds_all
elif self.focused_dev != 'Preset':
neds_focused = np.array(
[self.neds[np.equal(self.devs, int(self.focused_dev))][0]])
#if not all(map(any, np.isnan(neds_fixed))):
if len(neds_fixed) > 0:
self.plot_data.set_data('n_fixed', neds_fixed.T[0])
self.plot_data.set_data('e_fixed', neds_fixed.T[1])
self.plot_data.set_data('d_fixed', neds_fixed.T[2])
#if not all(map(any, np.isnan(neds_float))):
if len(neds_float) > 0:
self.plot_data.set_data('n_float', neds_float.T[0])
self.plot_data.set_data('e_float', neds_float.T[1])
self.plot_data.set_data('d_float', neds_float.T[2])
if len(neds_satisfied) > 0:
self.plot_data.set_data('n_satisfied', neds_satisfied.T[0])
self.plot_data.set_data('e_satisfied', neds_satisfied.T[1])
if len(neds_unsatisfied) > 0:
self.plot_data.set_data('n_unsatisfied', neds_unsatisfied.T[0])
self.plot_data.set_data('e_unsatisfied', neds_unsatisfied.T[1])
if len(self.presets) > 0:
self.plot_data.set_data('n_preset', self.presets['n'])
self.plot_data.set_data('e_preset', self.presets['e'])
if len(neds_focused) > 0:
self.plot_data.set_data('n_focused', neds_focused.T[0])
self.plot_data.set_data('e_focused', neds_focused.T[1])
if self.zoomall:
self._zoomall()
if self.zoom_once:
if self.focused_dev == 'All':
self._zoomall()
elif self.focused_dev == 'Preset':
plot_square_axes(self.plot, 'e_preset', 'n_preset')
else:
plot_square_axes(self.plot, 'e_focused', 'n_focused')
self.zoom_once = False
def _zoomall(self):
plot_square_axes(self.plot, ('e_fixed', 'e_float', 'e_preset'),
('n_fixed', 'n_float', 'n_preset'))
def pos_llh_callback(self, sbp_msg, **metadata):
soln = MsgPosLLH(sbp_msg)
masked_flag = soln.flags & 0x7
if masked_flag == 0:
psuedo_absolutes = False
else:
psuedo_absolutes = True
pos_table = []
if self.log_file is None:
self.log_file = open(time.strftime("position_log_%Y%m%d-%H%M%S.csv"), 'w')
self.log_file.write("time,latitude(degrees),longitude(degrees),altitude(meters),n_sats,flags\n")
tow = soln.tow * 1e-3
if self.nsec is not None:
tow += self.nsec * 1e-9
if self.week is not None:
t = datetime.datetime(1980, 1, 6) + \
datetime.timedelta(weeks=self.week) + \
datetime.timedelta(seconds=tow)
pos_table.append(('GPS Time', t))
pos_table.append(('GPS Week', str(self.week)))
self.log_file.write('%s,%.10f,%.10f,%.4f,%d,%d\n' % (
str(t),
soln.lat, soln.lon, soln.height,
soln.n_sats, soln.flags)
)
self.log_file.flush()
pos_table.append(('GPS ToW', tow))
pos_table.append(('Num. sats', soln.n_sats))
pos_table.append(('Lat', soln.lat))
pos_table.append(('Lng', soln.lon))
pos_table.append(('Alt', soln.height))
pos_table.append(('Flags', '0x%02x' % soln.flags))
if (soln.flags & 0xff) == 0:
pos_table.append(('Mode', 'SPP (single point position)'))
elif (soln.flags & 0xff) == 1:
pos_table.append(('Mode', 'Fixed RTK'))
elif (soln.flags & 0xff) == 2:
pos_table.append(('Mode', 'Float RTK'))
else:
pos_table.append(('Mode', 'Unknown'))
if psuedo_absolutes:
# setup_plot variables
self.lats_psuedo_abs.append(soln.lat)
self.lngs_psuedo_abs.append(soln.lon)
self.alts_psuedo_abs.append(soln.height)
self.lats_psuedo_abs = self.lats_psuedo_abs[-1000:]
self.lngs_psuedo_abs = self.lngs_psuedo_abs[-1000:]
self.alts_psuedo_abs = self.alts_psuedo_abs[-1000:]
self.plot_data.set_data('lat_ps', self.lats_psuedo_abs)
self.plot_data.set_data('lng_ps', self.lngs_psuedo_abs)
self.plot_data.set_data('alt_ps', self.alts_psuedo_abs)
self.plot_data.set_data('cur_lat_ps', [soln.lat])
self.plot_data.set_data('cur_lng_ps', [soln.lon])
t_psuedo_abs = range(len(self.lats))
self.plot_data.set_data('t', t)
self.plot_data.set_data('t_ps', t_psuedo_abs)
# set-up table variables
self.table_psuedo_abs = pos_table
else:
# setup_plot variables
self.lats.append(soln.lat)
self.lngs.append(soln.lon)
self.alts.append(soln.height)
self.lats = self.lats[-1000:]
self.lngs = self.lngs[-1000:]
self.alts = self.alts[-1000:]
self.plot_data.set_data('lat', self.lats)
self.plot_data.set_data('lng', self.lngs)
self.plot_data.set_data('alt', self.alts)
self.plot_data.set_data('cur_lat', [soln.lat])
self.plot_data.set_data('cur_lng', [soln.lon])
t = range(len(self.lats))
self.plot_data.set_data('t', t)
# set-up table variables
self.pos_table_spp = pos_table
self.table_spp = self.pos_table_spp + self.vel_table + self.dops_table
# TODO: figure out how to center the graph now that we have two separate messages
# when we selectivtely send only SPP, the centering function won't work anymore
if self.position_centered:
d = (self.plot.index_range.high - self.plot.index_range.low) / 2.
self.plot.index_range.set_bounds(soln.lon - d, soln.lon + d)
d = (self.plot.value_range.high - self.plot.value_range.low) / 2.
self.plot.value_range.set_bounds(soln.lat - d, soln.lat + d)
if self.zoomall:
plot_square_axes(self.plot, 'lng', 'lat')
def pos_llh_callback(self, sbp_msg, **metadata):
if sbp_msg.msg_type == SBP_MSG_POS_LLH_DEP_A:
soln = MsgPosLLHDepA(sbp_msg)
else:
soln = MsgPosLLH(sbp_msg)
self.last_soln = soln
self.last_pos_mode = get_mode(soln)
pos_table = []
soln.h_accuracy *= 1e-3
soln.v_accuracy *= 1e-3
tow = soln.tow * 1e-3
if self.nsec is not None:
tow += self.nsec * 1e-9
if self.week is not None:
t = datetime.datetime(1980, 1, 6) + \
datetime.timedelta(weeks=self.week) + \
datetime.timedelta(seconds=tow)
tstr = t.strftime('%Y-%m-%d %H:%M')
secs = t.strftime('%S.%f')
if(self.directory_name_p == ''):
filepath_p = time.strftime("position_log_%Y%m%d-%H%M%S.csv")
else:
filepath_p = os.path.join(self.directory_name_p, time.strftime("position_log_%Y%m%d-%H%M%S.csv"))
if self.logging_p == False:
self.log_file = None
if self.logging_p:
if self.log_file is None:
self.log_file = sopen(filepath_p, 'w')
self.log_file.write("time,latitude(degrees),longitude(degrees),altitude(meters),"
"h_accuracy(meters),v_accuracy(meters),n_sats,flags\n")
self.log_file.write('%s,%.10f,%.10f,%.4f,%.4f,%.4f,%d,%d\n' % (
"{0}:{1:06.6f}".format(tstr, float(secs)),
soln.lat, soln.lon, soln.height,
soln.h_accuracy, soln.v_accuracy,
soln.n_sats, soln.flags)
)
self.log_file.flush()
if self.last_pos_mode == 0:
pos_table.append(('GPS Time', EMPTY_STR))
pos_table.append(('GPS Week', EMPTY_STR))
pos_table.append(('GPS TOW', EMPTY_STR))
pos_table.append(('Num. Signals', EMPTY_STR))
pos_table.append(('Lat', EMPTY_STR))
pos_table.append(('Lng', EMPTY_STR))
pos_table.append(('Height', EMPTY_STR))
pos_table.append(('h_accuracy', EMPTY_STR))
pos_table.append(('v_accuracy', EMPTY_STR))
else:
self.last_stime_update = time.time()
if self.week is not None:
pos_table.append(('GPS Time', "{0}:{1:06.3f}".format(tstr, float(secs))))
pos_table.append(('GPS Week', str(self.week)))
pos_table.append(('GPS TOW', "{:.3f}".format(tow)))
pos_table.append(('Num. Sats', soln.n_sats))
pos_table.append(('Lat', soln.lat))
pos_table.append(('Lng', soln.lon))
pos_table.append(('Height', soln.height))
pos_table.append(('h_accuracy', soln.h_accuracy))
pos_table.append(('v_accuracy', soln.v_accuracy))
pos_table.append(('Pos Flags', '0x%03x' % soln.flags))
pos_table.append(('Pos Fix Mode', mode_dict[self.last_pos_mode]))
self.auto_survey()
# setup_plot variables
self.lats[1:] = self.lats[:-1]
self.lngs[1:] = self.lngs[:-1]
self.alts[1:] = self.alts[:-1]
self.tows[1:] = self.tows[:-1]
self.modes[1:] = self.modes[:-1]
self.lats[0] = soln.lat
self.lngs[0] = soln.lon
self.alts[0] = soln.height
self.tows[0] = soln.tow
self.modes[0] = self.last_pos_mode
self.lats = self.lats[-self.plot_history_max:]
self.lngs = self.lngs[-self.plot_history_max:]
self.alts = self.alts[-self.plot_history_max:]
self.tows = self.tows[-self.plot_history_max:]
self.modes = self.modes[-self.plot_history_max:]
# SPP
spp_indexer, dgnss_indexer, float_indexer, fixed_indexer = None, None, None, None
if np.any(self.modes):
spp_indexer = (self.modes == SPP_MODE)
dgnss_indexer = (self.modes == DGNSS_MODE)
float_indexer = (self.modes == FLOAT_MODE)
fixed_indexer = (self.modes == FIXED_MODE)
# make sure that there is at least one true in indexer before setting
if any(spp_indexer):
self.plot_data.set_data('lat_spp', self.lats[spp_indexer])
self.plot_data.set_data('lng_spp', self.lngs[spp_indexer])
self.plot_data.set_data('alt_spp', self.alts[spp_indexer])
if any(dgnss_indexer):
self.plot_data.set_data('lat_dgnss', self.lats[dgnss_indexer])
self.plot_data.set_data('lng_dgnss', self.lngs[dgnss_indexer])
self.plot_data.set_data('alt_dgnss', self.alts[dgnss_indexer])
if any(float_indexer):
self.plot_data.set_data('lat_float', self.lats[float_indexer])
self.plot_data.set_data('lng_float', self.lngs[float_indexer])
self.plot_data.set_data('alt_float', self.alts[float_indexer])
if any(fixed_indexer):
self.plot_data.set_data('lat_fixed', self.lats[fixed_indexer])
self.plot_data.set_data('lng_fixed', self.lngs[fixed_indexer])
self.plot_data.set_data('alt_fixed', self.alts[fixed_indexer])
# update our "current solution" icon
if self.last_pos_mode == SPP_MODE:
self._reset_remove_current()
self.plot_data.set_data('cur_lat_spp', [soln.lat])
self.plot_data.set_data('cur_lng_spp', [soln.lon])
elif self.last_pos_mode == DGNSS_MODE:
self._reset_remove_current()
self.plot_data.set_data('cur_lat_dgnss', [soln.lat])
self.plot_data.set_data('cur_lng_dgnss', [soln.lon])
elif self.last_pos_mode == FLOAT_MODE:
self._reset_remove_current()
self.plot_data.set_data('cur_lat_float', [soln.lat])
self.plot_data.set_data('cur_lng_float', [soln.lon])
elif self.last_pos_mode == FIXED_MODE:
self._reset_remove_current()
self.plot_data.set_data('cur_lat_fixed', [soln.lat])
self.plot_data.set_data('cur_lng_fixed', [soln.lon])
else:
pass
# set-up table variables
self.pos_table = pos_table
self.table = self.pos_table + self.vel_table + self.dops_table
# TODO: figure out how to center the graph now that we have two separate messages
# when we selectively send only SPP, the centering function won't work anymore
if not self.zoomall and self.position_centered:
d = (self.plot.index_range.high - self.plot.index_range.low) / 2.
self.plot.index_range.set_bounds(soln.lon - d, soln.lon + d)
d = (self.plot.value_range.high - self.plot.value_range.low) / 2.
self.plot.value_range.set_bounds(soln.lat - d, soln.lat + d)
if self.zoomall:
plot_square_axes(self.plot, ('lng_spp', 'lng_dgnss', 'lng_float','lng_fixed'),
('lat_spp', 'lat_dgnss', 'lat_float','lat_fixed'))
def baseline_callback(self, sbp_msg):
soln = MsgBaselineNEDDepA(sbp_msg)
self.last_soln = soln
table = []
soln.n = soln.n * 1e-3
soln.e = soln.e * 1e-3
soln.d = soln.d * 1e-3
soln.h_accuracy = soln.h_accuracy * 1e-3
soln.v_accuracy = soln.v_accuracy * 1e-3
dist = np.sqrt(soln.n**2 + soln.e**2 + soln.d**2)
tow = soln.tow * 1e-3
if self.nsec is not None:
tow += self.nsec * 1e-9
if self.week is not None:
t = datetime.datetime(1980, 1, 6) + \
datetime.timedelta(weeks=self.week) + \
datetime.timedelta(seconds=tow)
tstr = t.strftime('%Y-%m-%d %H:%M')
secs = t.strftime('%S.%f')
if self.directory_name_b == '':
filepath = time.strftime("baseline_log_%Y%m%d-%H%M%S.csv")
else:
filepath = os.path.join(self.directory_name_b, time.strftime("baseline_log_%Y%m%d-%H%M%S.csv"))
if self.logging_b == False:
self.log_file = None
if self.logging_b:
if self.log_file is None:
self.log_file = sopen(filepath, 'w')
self.log_file.write('time,north(meters),east(meters),down(meters),h_accuracy(meters),v_accuracy(meters),'
'distance(meters),num_sats,flags,num_hypothesis\n')
self.log_file.write('%s,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%d,%d,%d\n' % (
"{0}:{1:06.6f}".format(tstr, float(secs)),
soln.n, soln.e, soln.d,
soln.h_accuracy, soln.v_accuracy,
dist,
soln.n_sats,
soln.flags,
self.num_hyps)
)
self.log_file.flush()
self.last_mode = get_mode(soln)
if self.last_mode < 1:
table.append(('GPS Time', EMPTY_STR))
table.append(('GPS Week', EMPTY_STR))
table.append(('GPS TOW', EMPTY_STR))
table.append(('N', EMPTY_STR))
table.append(('E', EMPTY_STR))
table.append(('D', EMPTY_STR))
table.append(('h_accuracy', EMPTY_STR))
table.append(('v_accuracy', EMPTY_STR))
table.append(('Dist.', EMPTY_STR))
table.append(('Num. Sats', EMPTY_STR))
table.append(('Flags', EMPTY_STR))
table.append(('Mode', EMPTY_STR))
else:
self.last_btime_update = time.time()
if self.week is not None:
table.append(('GPS Time', "{0}:{1:06.3f}".format(tstr, float(secs))))
table.append(('GPS Week', str(self.week)))
table.append(('GPS TOW', "{:.3f}".format(tow)))
table.append(('N', soln.n))
table.append(('E', soln.e))
table.append(('D', soln.d))
table.append(('h_accuracy', soln.h_accuracy))
table.append(('v_accuracy', soln.v_accuracy))
table.append(('Dist.', dist))
table.append(('Num. Sats', soln.n_sats))
table.append(('Flags', '0x%02x' % soln.flags))
table.append(('Mode', mode_dict[self.last_mode]))
self.table = table
# Rotate array, deleting oldest entries to maintain
# no more than N in plot
self.n[1:] = self.n[:-1]
self.e[1:] = self.e[:-1]
self.d[1:] = self.d[:-1]
self.mode[1:] = self.mode[:-1]
# Insert latest position
if self.last_mode > 1:
self.n[0], self.e[0], self.d[0] = soln.n, soln.e, soln.d
else:
self.n[0], self.e[0], self.d[0] = [np.NAN, np.NAN, np.NAN]
self.mode[0] = self.last_mode
if np.any(self.mode):
float_indexer = (self.mode == FLOAT_MODE)
fixed_indexer = (self.mode == FIXED_MODE)
dgnss_indexer = (self.mode == DGNSS_MODE)
if np.any(fixed_indexer):
self.plot_data.set_data('n_fixed', self.n[fixed_indexer])
self.plot_data.set_data('e_fixed', self.e[fixed_indexer])
self.plot_data.set_data('d_fixed', self.d[fixed_indexer])
if np.any(float_indexer):
self.plot_data.set_data('n_float', self.n[float_indexer])
self.plot_data.set_data('e_float', self.e[float_indexer])
self.plot_data.set_data('d_float', self.d[float_indexer])
if np.any(dgnss_indexer):
self.plot_data.set_data('n_dgnss', self.n[dgnss_indexer])
self.plot_data.set_data('e_dgnss', self.e[dgnss_indexer])
self.plot_data.set_data('d_dgnss', self.d[dgnss_indexer])
# Update our last solution icon
if self.last_mode == FIXED_MODE:
self._reset_remove_current()
self.plot_data.set_data('cur_fixed_n', [soln.n])
self.plot_data.set_data('cur_fixed_e', [soln.e])
self.plot_data.set_data('cur_fixed_d', [soln.d])
elif self.last_mode == FLOAT_MODE:
self._reset_remove_current()
self.plot_data.set_data('cur_float_n', [soln.n])
self.plot_data.set_data('cur_float_e', [soln.e])
self.plot_data.set_data('cur_float_d', [soln.d])
elif self.last_mode == DGNSS_MODE:
self._reset_remove_current()
self.plot_data.set_data('cur_dgnss_n', [soln.n])
self.plot_data.set_data('cur_dgnss_e', [soln.e])
self.plot_data.set_data('cur_dgnss_d', [soln.d])
else:
pass
# make the zoomall win over the position centered button
# position centered button has no effect when zoom all enabled
if not self.zoomall and self.position_centered:
d = (self.plot.index_range.high - self.plot.index_range.low) / 2.
self.plot.index_range.set_bounds(soln.e - d, soln.e + d)
d = (self.plot.value_range.high - self.plot.value_range.low) / 2.
self.plot.value_range.set_bounds(soln.n - d, soln.n + d)
if self.zoomall:
plot_square_axes(self.plot, ('e_fixed', 'e_float', 'e_dgnss'), ('n_fixed', 'n_float', 'n_dgnss'))
def _zoomall(self):
plot_square_axes(self.plot, ('e_fixed', 'e_float', 'e_preset'), ('n_fixed', 'n_float', 'n_preset'))
def baseline_callback(self, sbp_msg):
#soln = MsgBaselineNED(sbp_msg)
soln = sbp_msg
soln.n = soln.n * 1e-3
soln.e = soln.e * 1e-3
soln.d = soln.d * 1e-3
dist = np.sqrt(soln.n**2 + soln.e**2 + soln.d**2)
tow = soln.tow * 1e-3
if self.nsec is not None:
tow += self.nsec * 1e-9
#row_data = [soln.sender, soln.n, soln.e, soln.d, soln.n_sats, soln.flags, soln.depth]
row_data = [soln.sender, soln.n, soln.e, soln.d, soln.n_sats, soln.flags]
try:
key = int(row_data[0])
self.data_dict[key] = row_data
except:
pass
self.utils.setDataViewTable(self.data_dict)
if soln.sender not in self.dev_list:
self.dev_list.append(soln.sender)
self.dev_all_list.append(str(soln.sender))
# Rotate array, deleting oldest entries to maintain
# no more than N in plot
self.neds[1:] = self.neds[:-1]
self.fixeds[1:] = self.fixeds[:-1]
self.devs[1:] = self.devs[:-1]
self.times[1:] = self.times[:-1]
# Insert latest position
self.neds[0][:] = [soln.n, soln.e, soln.d]
self.fixeds[0] = (soln.flags & 1) == 1
self.devs[0] = int(soln.sender)
self.times[0]= int(time.time())
neds_all = []
neds_fixed = []
neds_float = []
neds_satisfied = []
neds_unsatisfied = []
devs = np.unique(self.devs)
if devs[0] == 0:
devs = devs[1:]
for dev in devs:
is_dev = np.equal(dev, self.devs)
neds_all.append(self.neds[is_dev][0])
try:
neds_fixed.append(self.neds[np.logical_and(is_dev, self.fixeds)][0])
except:
pass
try:
neds_float.append(self.neds[np.logical_and(is_dev, np.logical_not(self.fixeds))][0])
except:
pass
position_satisfied, depth_satisfied, time_satisfied = self._threshold_satisfied()
is_satisfied = np.logical_and(position_satisfied, depth_satisfied, time_satisfied)
try:
neds_satisfied.append(self.neds[np.logical_and(is_dev, is_satisfied)][0])
except:
pass
try:
neds_unsatisfied.append(self.neds[np.logical_and(is_dev, np.logical_not(is_satisfied))][0])
except:
pass
neds_all = np.array(neds_all)
neds_fixed = np.array(neds_fixed)
neds_float = np.array(neds_float)
neds_satisfied = np.array(neds_satisfied)
neds_unsatisfied = np.array(neds_unsatisfied)
self.neds_all = neds_all
self.neds_satisfied = neds_satisfied
self.neds_unsatisfied = neds_unsatisfied
neds_focused = np.empty((0, 3))
if self.focused_dev == '':
pass
elif self.focused_dev == 'All':
neds_focused = neds_all
elif self.focused_dev != 'Preset':
neds_focused = np.array([self.neds[np.equal(self.devs, int(self.focused_dev))][0]])
#if not all(map(any, np.isnan(neds_fixed))):
if len(neds_fixed) > 0:
self.plot_data.set_data('n_fixed', neds_fixed.T[0])
self.plot_data.set_data('e_fixed', neds_fixed.T[1])
self.plot_data.set_data('d_fixed', neds_fixed.T[2])
#if not all(map(any, np.isnan(neds_float))):
if len(neds_float) > 0:
self.plot_data.set_data('n_float', neds_float.T[0])
self.plot_data.set_data('e_float', neds_float.T[1])
self.plot_data.set_data('d_float', neds_float.T[2])
if len(neds_satisfied) > 0:
self.plot_data.set_data('n_satisfied', neds_satisfied.T[0])
self.plot_data.set_data('e_satisfied', neds_satisfied.T[1])
if len(neds_unsatisfied) > 0:
self.plot_data.set_data('n_unsatisfied', neds_unsatisfied.T[0])
self.plot_data.set_data('e_unsatisfied', neds_unsatisfied.T[1])
if len(self.presets) > 0:
self.plot_data.set_data('n_preset', self.presets['n'])
self.plot_data.set_data('e_preset', self.presets['e'])
if len(neds_focused) > 0:
self.plot_data.set_data('n_focused', neds_focused.T[0])
self.plot_data.set_data('e_focused', neds_focused.T[1])
if self.zoomall:
self._zoomall()
if self.zoom_once:
if self.focused_dev == 'All':
self._zoomall()
elif self.focused_dev == 'Preset':
plot_square_axes(self.plot, 'e_preset', 'n_preset')
else:
plot_square_axes(self.plot, 'e_focused', 'n_focused')
self.zoom_once = False
