def grab_frame(the_time, channel, vehicle, author):
"""
Do the actual frame grab
:param the_time:
:param channel:
:return:
"""
imageset = None
try:
print('Grabbing frame for %s at %s' %
(str(vehicle), the_time.isoformat()))
imageset = grab_frame_from_time(the_time, vehicle, author,
vehicle.name)
except OperationalError:
reconnect_db()
imageset = grab_frame_from_time(the_time, vehicle, author,
vehicle.name)
except Exception as e:
persist_error(e)
traceback.print_exc()
if imageset:
print 'created image'
print imageset
return imageset
return 'No image created!!!'
def deserialize(self, msg):
row = None
updated_row = False
try:
try:
values = msg.split(self.delimiter)
row = {k: v for k, v in zip(self.keys, values)}
row = self.importer.update_row(row)
updated_row = True
if self.needs_flight:
flight = getActiveFlight()
row['flight'] = flight
result = self.model(**row)
if self.verbose:
print result
return result
except OperationalError as oe:
reconnect_db()
if not updated_row:
row = self.importer.update_row(row)
if self.needs_flight:
flight = getActiveFlight()
row['flight'] = flight
result = self.model(**row)
if self.verbose:
print result
return result
except Exception as e:
print 'deserializing:', msg
if row:
print 'deserialized:', row
traceback.print_exc()
persist_error(e, traceback.format_exc())
return None
def deserialize(self, msg):
"""
In this case the deserialize also stores the models
:param msg:
:return:
"""
row = None
print(msg)
try:
values = msg.split(self.delimiter)
row = {k: v for k, v in zip(self.keys, values)}
updated_row = False
try:
row['flight'] = getActiveFlight()
row = self.importer.update_row(row)
updated_row = True
models = self.importer.build_models(row)
except OperationalError as oe:
reconnect_db()
if not updated_row:
row['flight'] = getActiveFlight()
row = self.importer.update_row(row)
models = self.importer.build_models(row)
if self.verbose:
print(models)
return None # because the importer build models stores them
except Exception as e:
print 'deserializing:', msg
if row:
print 'deserialized:', row
traceback.print_exc()
persist_error(e, traceback.format_exc())
return None
def do_write_buffer(self):
print 'saving %d models from %s' % (len(self.buffer), self.channel_name)
model = type(self.buffer[0])
if model is not None:
try:
model.objects.bulk_create(self.buffer)
except Exception as e:
persist_error(e, traceback.format_exc())
self.buffer = []
self.last_write_time = datetime.datetime.utcnow()
def interpolate(self):
# Interpolate a pose for the current desired_pose_time and return it
prev_latlon = self.latlon_queue.get_closest_before(
self.desired_pose_time)
next_latlon = self.latlon_queue.get_closest_after(
self.desired_pose_time)
if prev_latlon is None or next_latlon is None:
return None
t = self.desired_pose_time
t1 = prev_latlon['timestamp']
t2 = next_latlon['timestamp']
params = {'timestamp': t}
for k in ['longitude', 'latitude']:
params[k] = interpolate(t, t1, prev_latlon[k], t2, next_latlon[k])
prev_rpyad = self.rpyad_queue.get_closest_before(
self.desired_pose_time)
next_rpyad = self.rpyad_queue.get_closest_after(self.desired_pose_time)
if prev_rpyad is None or next_rpyad is None:
return None
t1 = prev_rpyad['timestamp']
t2 = next_rpyad['timestamp']
for k in ['altitude', 'depth']:
if k in prev_rpyad and k in next_rpyad:
params[k] = interpolate(t, t1, prev_rpyad[k], t2,
next_rpyad[k])
for k in ['roll', 'pitch', 'yaw']:
if k in prev_rpyad and k in next_rpyad:
params[k] = interpolate(t,
t1,
prev_rpyad[k],
t2,
next_rpyad[k],
unwrap=True)
desired_pose = None
current_pose = None
try:
params['track'] = get_active_track(self.vehicle)
desired_pose = PastResourcePoseDepth(**params)
current_pose = ResourcePoseDepth(**params)
except OperationalError as oe:
traceback.print_exc()
reconnect_db()
params['track'] = get_active_track(self.vehicle)
desired_pose = PastResourcePoseDepth(**params)
current_pose = ResourcePoseDepth(**params)
except Exception as e:
persist_error(e)
traceback.print_exc()
return desired_pose, current_pose
def run(self):
for msg in self.tq.listen():
try:
data = msg['data']
the_time, channel = self.parse_data(data)
vehicle = self.hercules
if channel == 2:
vehicle = self.argus
t = Timer(settings.XGDS_VIDEO_RECORDING_LAG_SECONDS,
grab_frame,
[the_time, channel, vehicle, self.author])
t.start()
except Exception as e:
persist_error(e)
def run(self):
print '%s listener started' % self.config['input_channel']
# polling loop:
for msg in self.tq.listen():
try:
payload = msg['data'].split('\t')[3]
for payload_identifier, output_channel in self.config[
'outputs'].iteritems():
strlen = len(payload_identifier)
if payload[0:strlen] == payload_identifier:
if verbose:
print '%s %s -> %s' % (
self.config['input_channel'],
payload_identifier, output_channel)
self.r.publish(output_channel, msg['data'])
except Exception as e:
persist_error(e)
def run(self):
for msg in self.tq.listen():
try:
data = msg['data']
# data = data.lower()
if 'divestatusevent:inwater' in data.lower():
print data
reconnect_db()
parsed_data = self.parse_data(data)
# see if we got an inwater with an invalid / completed dive
try:
GROUP_FLIGHT_MODEL.get().objects.get(
name=parsed_data['group_flight_name'])
# this group flight already exists so we do not want this script to create one.
return
except ObjectDoesNotExist:
pass
# make the dive and start it
self.start_dive(parsed_data['group_flight_name'],
parsed_data['time'])
elif 'divestatusevent:ondeck' in data.lower():
print data
reconnect_db()
parsed_data = self.parse_data(data)
end_time = None
if self.active_dive:
if parsed_data['dive_number']:
if parsed_data[
'dive_number'] in self.active_dive.name:
end_time = parsed_data['time']
self.end_dive(end_time)
else:
# no active dive, but we got an end so let's end that dive
self.end_other_dive(parsed_data['dive_number'],
parsed_data['time'])
except Exception as e:
persist_error(e, traceback.format_exc())
def run(self):
print 'bridging udp port %d -> redis "%s"' % (self.udp_port,
self.channel_name)
connected = True
while connected:
try:
rcv = self.socket.recv(2048).strip()
if len(rcv) < 1:
print 'DISCONNECTED %s' % self.channel_name
connected = False
else:
# status message showing the udp port data came in,
# the redis channel it is goingn to, and the contents
# of the message
if self.verbose:
print '%d->%s: %s' % (self.udp_port, self.channel_name,
rcv)
self.r.publish(self.channel_name, rcv)
except Exception as e:
persist_error(e)
self.socket.shutdown()
def handle_msg(self, msg):
deserialized = self.deserialize(msg)
if deserialized:
past_positions, self.current_position = deserialized
else:
return
if self.current_position:
try:
self.current_position.saveCurrent()
except OperationalError as oe:
reconnect_db()
self.current_position.saveCurrent()
except Exception as e:
persist_error(e)
# The result should be None, a model object, or a list of model objects
if past_positions is not None:
if type(past_positions) is list:
if past_positions:
self.buffer.extend(past_positions)
else:
self.buffer.append(past_positions)
def deserialize(self, msg):
row = None
updated_row = False
try:
try:
values = msg.split(self.delimiter)
row = {k: v for k, v in zip(self.keys, values)}
row = self.importer.update_row(row)
updated_row = True
if self.needs_flight:
flight = getActiveFlight()
row['flight'] = flight
if self.verbose:
print 'deserialized', row
self.queue.append(row['timestamp'], row)
except OperationalError as oe:
reconnect_db()
if not updated_row:
row = self.importer.update_row(row)
if self.needs_flight:
flight = getActiveFlight()
row['flight'] = flight
if self.verbose:
print 'deserialized', row
self.queue.append(row['timestamp'], row)
# On the first time through we need to set set up the first desired time to interpolate
# It should be the first whole interval timestamp after the first timestamp we get
if self.desired_sample_time is None:
self.desired_sample_time = row['timestamp']
desired_second = int(1 + self.desired_sample_time.second / self.resample_interval_sec) * \
self.resample_interval_sec
self.desired_sample_time = self.desired_sample_time.replace(
second=desired_second)
self.desired_sample_time = self.desired_sample_time.replace(
microsecond=0)
if self.verbose:
print 'resample interval is', self.resample_interval_sec
print 'first desired sample time is', self.desired_sample_time
# Get interpolated values if we can
if len(self.queue.queue) > 1:
models = []
while self.queue.queue[-1][0] > self.desired_sample_time:
# We should have the information we need to interpolate
values = self.interpolate()
if values:
print 'interpolated', values
models.append(self.model(**values))
# Get rid of queued data we won't need again
self.queue.delete_before(self.desired_sample_time)
# Increment the next desired pose time
self.desired_sample_time += datetime.timedelta(
seconds=self.resample_interval_sec)
return models
return None
except Exception as e:
print 'deserializing:', msg
if row:
print 'deserialized:', row
traceback.print_exc()
persist_error(e, traceback.format_exc())
return None
