def calc_rules(self, tracklet_info):
"""
:param tracklet_info:
:return: a list of tuples with:
0- The distance (trust measurement)
1- The rule that was satisfied
2- The time that the rule has taken
satisfied
"""
found_local_rules = []
found_global_rules = []
last_update = tracklet_info.last_position_time
# Take the latest events or a minimum
last_speed_events = \
list(map(lambda x: x[1], takewhile(
lambda i_e:
diff_in_milliseconds(i_e[1].last_update, last_update) <
self.MIN_EVENTS_SPEED_TIME or
i_e[0] < self.MIN_EVENTS_SPEED_AMOUNT,
enumerate(reversed(tracklet_info.active_speed_events))
)))
last_dir_events = \
list(map(lambda x: x[1], takewhile(
lambda i_e:
diff_in_milliseconds(i_e[1].last_update, last_update) <
self.MIN_EVENTS_DIR_TIME or i_e[0] <
self.MIN_EVENTS_DIR_AMOUNT,
enumerate(reversed(tracklet_info.active_direction_events))
)))
# if any rule matches, the rule is added to found_rules
for rule in self.movement_change_rules:
satisfies_speed_events, dist1, time_from_start1 = \
self.check_ruleevents_in_activeevents(
rule.events, reversed(last_speed_events))
satisfies_dir_events, dist2, time_from_start2 = \
self.check_ruleevents_in_activeevents(
rule.events, reversed(last_dir_events))
satisfies_global_events, dist3, time_from_start3 = \
self.check_ruleevents_in_activeevents(
rule.events, [self.global_events[-1]]) if \
self.global_events else (None, None, None)
if satisfies_global_events:
found_global_rules.append((dist3, rule, time_from_start3))
if satisfies_speed_events or satisfies_dir_events:
found_local_rules.append((dist1 + dist2, rule,
min(time_from_start1,
time_from_start2)))
return found_local_rules, found_global_rules
def remove_abandoned_tracklets(self, last_update):
tracklet_to_delete = \
[t.id for t in self.tracklets_info.values()
if diff_in_milliseconds(t.last_position_time, last_update) >
self.TRACKLETS_LIVES_TIME]
for id_ in tracklet_to_delete:
del self.tracklets_info[id_]
def calc_movements_info(self, tracklet_info, new_position,
new_position_time):
time = diff_in_milliseconds(tracklet_info.last_position_time,
new_position_time)
(distance, angle) = self.calc_distance_and_angle_between_points(
tracklet_info.last_position, new_position)
return time, distance, angle
def calc_global_events(self, last_update, last_position, time_lapse):
counter = 0
current_global_events = []
# ## Look for AGGLOMERATION events ## #
# Calculate distance to each tracklet and check if it is close enough
for tracklet in self.tracklets_info.values():
if diff_in_milliseconds(
tracklet.last_position_time, last_update) < 1250 and \
euclidean_distance(last_position, tracklet.last_position) < \
self.AGGLOMERATION_MIN_DISTANCE:
counter += 1
else:
if counter > 1:
current_global_events.append(
EventAgglomeration(type_=counter,
value=time_lapse,
time_end=last_update,
duration=time_lapse))
# ## Place to verify future global events ## #
# ... ... ...
return current_global_events
def remove_old_global_events(self, last_update):
self.global_events = list(
dropwhile(
lambda e: diff_in_milliseconds(e.last_update, last_update) >
self.GLOBAL_EVENTS_LIVES_TIME, self.global_events))
def duration(self):
if None in (self.time_start, self.last_update):
return 0
return diff_in_milliseconds(self.time_start, self.last_update)
def __repr__(self):
return "Event %s TO %s TIME_START: %s DURATION: %s" % \
(self.quantifier, str(self.value), self.time_start,
diff_in_milliseconds(self.time_start, self.last_update))