def test_detection(self):
"""
Test detected object set in track state
"""
do = self._create_detected_object()
ts = ObjectTrackState(0, 0, do)
nose.tools.assert_equal(ts.detection(), do)
def test_new_ts(self):
"""
Test object track set creation with and without a detected object
"""
do = self._create_detected_object()
ObjectTrackState(0, 0, None)
ObjectTrackState(0, 0, do)
def test_time_usec(self):
"""
Test time in microsecond stored in a track state with >= 0 values
"""
do = self._create_detected_object()
ts = ObjectTrackState(0, 0, do)
nose.tools.assert_equal(ts.time_usec, 0)
ts = ObjectTrackState(0, 14691234578, do)
nose.tools.assert_equal(ts.time_usec, 14691234578)
def test_frame_id(self):
"""
Test frame id stored in a track state with >= 0 values
"""
do = self._create_detected_object()
ts = ObjectTrackState(0, 0, do)
nose.tools.assert_equal(ts.frame_id, 0)
ts = ObjectTrackState(14691234578, 0, do)
nose.tools.assert_equal(ts.frame_id, 14691234578)
def _create_object_track_set(self):
bbox = BoundingBox(10, 10, 20, 20)
dot = DetectedObjectType("test", 0.4)
do = DetectedObject(bbox, 0.4, dot)
track = Track()
for i in range(10):
track.append(ObjectTrackState(i, i, do))
return ObjectTrackSet([track])
def ts2ot_list(track_set):
ot_list = [Track(id=t.track_id) for t in track_set]
for idx, t in enumerate(track_set):
ot = ot_list[idx]
for ti in t:
ot_state = ObjectTrackState(ti.sys_frame_id, ti.sys_frame_time,
ti.detected_object)
if not ot.append(ot_state):
print('Error: Cannot add ObjectTrackState')
return ot_list
def to_ObjectTrackSet(tracks):
"""Create an ObjectTrackSet from a dict whose keys are track IDs
and values are lists of pairs of Kwiver timestamps and Kwiver DetectedObjects"""
# Modeled after similar code in srnn_tracker.py
result = []
for tid, states in tracks.items():
t = Track(id=tid)
for ts, do in states:
ots = ObjectTrackState(ts.get_frame(), ts.get_time_usec(), do)
if not t.append(ots):
raise ValueError("Unsorted input to to_ObjectTrackSet")
result.append(t)
return ObjectTrackSet(result)
def _create_track(self):
"""
Helper function to create a track
:return: Track with 10 object track state. Every track state has same
detected object however the fram number and time varies from
[0, 10)
"""
bbox = BoundingBox(10, 10, 20, 20)
cm = ClassMap("test", 0.4)
do = DetectedObject(bbox, 0.4, cm)
track = Track()
for i in range(10):
track.append(ObjectTrackState(i, i, do))
return track
def setUp(self):
bbox = BoundingBox(10, 10, 20, 20)
dot = DetectedObjectType("test", 0.4)
do = DetectedObject(bbox, 0.4, dot)
track = Track()
for i in range(10):
track.append(ObjectTrackState(i, i, do))
self.track_ = track
self.time_1 = Timestamp()
self.time_1.set_time_seconds(1234)
self.time_2 = Timestamp()
self.time_2.set_time_seconds(4321)
self.obj_ts = ObjectTrackSet([self.track_])
self.act_type = ActivityType("self_act", 0.87)
self.act = Activity(1, "self_act", 0.87, self.act_type, self.time_1,
self.time_2, self.obj_ts)
def test_id(self):
a = self.act
self.assertEqual(a.id, 1)
a.id = 10
self.assertEqual(a.id, 10)
self.assertEqual(a.label, "self_act")
a.label = "second_act"
self.assertEqual(a.label, "second_act")
self.assertEqual(a.activity_type.score("self_act"), 0.87)
a.activity_type = ActivityType()
self.assertEqual(a.confidence, 0.87)
a.confidence = 1
self.assertEqual(a.confidence, 1)
self.assertEqual(a.start_time.get_time_seconds(), 1234)
tmp_time = Timestamp().set_time_seconds(1237)
a.start_time = tmp_time
self.assertEqual(a.start_time.get_time_seconds(), 1237)
self.assertEqual(a.end_time.get_time_seconds(), 4321)
tmp_time = Timestamp()
tmp_time.set_time_seconds(4322)
a.end_time = tmp_time
self.assertEqual(a.end_time.get_time_seconds(), 4322)
self.assertEqual(a.participants.all_frame_ids(), set(range(10)))
bbox = BoundingBox(10, 10, 20, 20)
dot = DetectedObjectType("test", 0.4)
do = DetectedObject(bbox, 0.4, dot)
track = Track()
for i in range(5):
track.append(ObjectTrackState(i, i, do))
new_t = track
new_ots = ObjectTrackSet([new_t])
a.participants = new_ots
self.assertEqual(a.participants.all_frame_ids(), set(range(5)))
self.assertEqual(a.duration[0].get_time_seconds(),
a.start_time.get_time_seconds())
self.assertEqual(a.duration[1].get_time_seconds(),
a.end_time.get_time_seconds())
def _step(self):
# Get all inputs even ones we don't use
in_img_c = self.grab_input_using_trait('image')
timestamp = self.grab_input_using_trait('timestamp')
if not timestamp.has_valid_frame():
raise RuntimeError("Frame timestamps must contain frame IDs")
frame_id = timestamp.get_frame()
if self.has_input_port_edge_using_trait('detected_object_set'):
detections = self.grab_input_using_trait('detected_object_set')
else:
detections = DetectedObjectSet()
if self.has_input_port_edge_using_trait('initializations'):
initializations = self.grab_input_using_trait('initializations')
else:
initializations = ObjectTrackSet()
if self.has_input_port_edge_using_trait('recommendations'):
recommendations = self.grab_input_using_trait('recommendations')
else:
recommendations = ObjectTrackSet()
if self.has_input_port_edge_using_trait('evaluation_requests'):
requests = self.grab_input_using_trait('evaluation_requests')
else:
requests = DetectedObjectSet()
print('mdnet tracker timestamp = {!r}'.format(timestamp))
# Handle new track external initialization
init_track_pool = initializations.tracks()
recc_track_pool = recommendations.tracks()
init_track_ids = []
img_used = False
if len(init_track_pool) != 0 or len(self._trackers) != 0:
img_npy = self.format_image(in_img_c)
img_used = True
for trk in init_track_pool:
# Special case, initialize a track on a previous frame
if trk[trk.last_frame].frame_id == self._last_frame_id and \
( not trk.id in self._track_init_frames or \
self._track_init_frames[ trk.id ] < self._last_frame_id ):
tid = trk.id
cbox = trk[trk.last_frame].detection().bounding_box()
bbox = [
cbox.min_x(),
cbox.min_y(),
cbox.width(),
cbox.height()
]
self._last_frame = self.format_image(self._last_frame)
self._trackers[tid] = mdnet.MDNetTracker(
self._last_frame, bbox)
self._tracks[tid] = [ObjectTrackState(timestamp, cbox, 1.0)]
self._track_init_frames[tid] = self._last_frame_id
# This track has an initialization signal for the current frame
elif trk[trk.last_frame].frame_id == frame_id:
tid = trk.id
cbox = trk[trk.last_frame].detection().bounding_box()
bbox = [
cbox.min_x(),
cbox.min_y(),
cbox.width(),
cbox.height()
]
self._trackers[tid] = mdnet.MDNetTracker(img_npy, bbox)
self._tracks[tid] = [ObjectTrackState(timestamp, cbox, 1.0)]
init_track_ids.append(tid)
self._track_init_frames[tid] = frame_id
# Update existing tracks
for tid in self._trackers.keys():
if tid in init_track_ids:
continue # Already processed (initialized) on frame
# Check if there's a recommendation for the update
recc_bbox = []
for trk in recc_track_pool:
if trk.id == tid and trk[trk.last_frame].frame_id == frame_id:
cbox = trk[trk.last_frame].detection().bounding_box()
recc_bbox = [
cbox.min_x(),
cbox.min_y(),
cbox.width(),
cbox.height()
]
break
bbox, score = self._trackers[tid].update(img_npy,
likely_bbox=recc_bbox)
if score > mdnet.opts['success_thr']:
cbox = BoundingBoxD(bbox[0], bbox[1], bbox[0] + bbox[2],
bbox[1] + bbox[3])
new_state = ObjectTrackState(timestamp, cbox, score)
self._tracks[tid].append(new_state)
# Handle track termination
# TODO: Remove old or dead tracks
# Classify requested evaluations
# TODO: Evaluate input detections
output_evaluations = DetectedObjectSet()
# Output results
output_tracks = ObjectTrackSet(
[Track(tid, trk) for tid, trk in self._tracks.items()])
self.push_to_port_using_trait('timestamp', timestamp)
self.push_to_port_using_trait('object_track_set', output_tracks)
self.push_to_port_using_trait('evaluations', output_evaluations)
self._last_frame_id = timestamp.get_frame()
if img_used:
self._last_frame = img_npy
else:
self._last_frame = in_img_c
self._base_step()
def create_object_track_state():
return ObjectTrackState(10, 15, create_detected_object())