def test_new(self): # Attempt construction using a bunch of random, non-zero integers random.seed(0) for i in range(100): n = random.randint(1, 4096) new_descriptor(n, 'd') new_descriptor(n, 'f')
def test_new_with_descriptors(self): # Try creating a descriptor set with multiple descriptors as input. descriptor_list = [ new_descriptor(1), new_descriptor(1), new_descriptor(1), ] ds = DescriptorSet(descriptor_list)
def test_num_bytes(self): # While not calling the C function, it should still be a correct value random.seed(0) for i in range(100): n = random.randint(1, 4096) print(n, end=' ') nose.tools.assert_equal(new_descriptor(n, 'd').nbytes, 8 * n) nose.tools.assert_equal(new_descriptor(n, 'f').nbytes, 4 * n)
def test_operators(self): d = new_descriptor(10) b = new_descriptor(10) c = new_descriptor(5) d[:] = 1 b[:] = 1 nose.tools.ok_(d == b) nose.tools.ok_(c != b) nose.tools.ok_(not c != c)
def _step(self): object_tracks = self.grab_input_using_trait('object_track_set') for object_track in object_tracks.tracks(): for track_state in object_track: if track_state.frame_id == self.current_idx: cur = self.conn.cursor() cur.execute("SELECT track_descriptor.uid FROM track_descriptor " "INNER JOIN track_descriptor_track ON track_descriptor.uid = track_descriptor_track.uid " "INNER JOIN track_descriptor_history ON track_descriptor.uid = track_descriptor_history.uid " "WHERE track_descriptor.video_name = %(video_name)s AND track_descriptor_history.frame_number = %(frame_number)s AND track_descriptor_track.track_id = %(track_id)s", { "video_name": self.video_name, "frame_number": track_state.frame_id, "track_id": object_track.id, }) rows = list(cur.fetchall()) if len(rows) != 1: raise RuntimeError("Could not get track descriptor") uid = rows[0][0] smqtk_descriptor = self.smqtk_descriptor_index.get_descriptor(uid) vital_descriptor = new_descriptor(len(smqtk_descriptor.vector()), "d") vital_descriptor[:] = smqtk_descriptor.vector() track_state.detection.set_descriptor(vital_descriptor) print("Finished track state: %i %i" % (object_track.id, track_state.frame_id)) self.push_to_port_using_trait('object_track_set', object_tracks) self.current_idx += 1 self._base_step()
def test_tobytearray(self): # Expect 0-valued descriptor to have 0-valued byte array of the # appropriate size d = new_descriptor(64) d[:] = 0 b = d.tobytearray() nose.tools.assert_equal(len(b), d.nbytes) nose.tools.assert_equal(sum(b), 0)
def test_size_multiple(self): # Check that size accurately report number of descriptors constructed # with. d_list = [ new_descriptor(), ] ds = DescriptorSet(d_list) self.assertEqual(ds.size(), 1) self.assertEqual(len(ds), 1)
def test_raw_data(self): d = new_descriptor(64) d[:] = 1 nose.tools.assert_equal(d.sum(), 64) # Check that slicing the array data yields an array with the same # values. d2 = d[:] numpy.testing.assert_equal(d.todoublearray(), d2)
def to_vital(raw_data): if len(raw_data) == 0: return DescriptorSet() vital_descriptors = [] for item in raw_data: new_desc = new_descriptor(item.size) new_desc[:] = item vital_descriptors.append(new_desc) return DescriptorSet(vital_descriptors)
def _step(self): try: # Grab image container from port using traits in_img_c = self.grab_input_using_trait('image') timestamp = self.grab_input_using_trait('timestamp') dos_ptr = self.grab_input_using_trait('detected_object_set') print('timestamp = {!r}'.format(timestamp)) # Get current frame and give it to app feature extractor im = get_pil_image(in_img_c.image()) self._app_feature_extractor.frame = im bbox_num = 0 # Get detection bbox dos = dos_ptr.select(self._select_threshold) bbox_num = dos.size() det_obj_set = DetectedObjectSet() if bbox_num == 0: print( '!!! No bbox is provided on this frame and skip this frame !!!' ) else: # appearance features (format: pytorch tensor) app_f_begin = timer() pt_app_features = self._app_feature_extractor(dos, False) app_f_end = timer() print('%%%app feature eclapsed time: {}'.format(app_f_end - app_f_begin)) # get new track state from new frame and detections for idx, item in enumerate(dos): bbox = item.bounding_box() fid = timestamp.get_frame() ts = timestamp.get_time_usec() d_obj = item # store app feature to detectedObject app_f = new_descriptor(pt_app_features[idx].numpy().size) app_f[:] = pt_app_features[idx].numpy() # print( pt_app_features[idx].numpy() ) d_obj.set_descriptor(app_f) det_obj_set.add(d_obj) # push track set to output port self.push_to_port_using_trait('detected_object_set', det_obj_set) self._base_step() except BaseException as e: print(repr(e)) import traceback print(traceback.format_exc()) sys.stdout.flush() raise
def test_get_descriptors_multiple(self): # Test getting descriptors given to the set in its constructor. d_list = [ new_descriptor(1), new_descriptor(2), new_descriptor(3), ] d_list[0][:] = [0] d_list[1][:] = [1, 2] d_list[2][:] = [3, 4, 5] ds = DescriptorSet(d_list) ds_descriptors = ds.descriptors() self.assertEqual(len(ds), 3) self.assertEqual(len(ds_descriptors), 3) numpy.testing.assert_array_equal(ds_descriptors[0], d_list[0]) numpy.testing.assert_array_equal(ds_descriptors[1], d_list[1]) numpy.testing.assert_array_equal(ds_descriptors[2], d_list[2])
def _step(self): # # Grab input values from ports using traits. # # Vector of UIDs for vector of descriptors in descriptor_set. # #: :type: list[str] string_tuple = self.grab_input_using_trait('string_vector') descriptors = self.smqtk_descriptor_index.get_many_descriptors( string_tuple) vital_descriptors = [] for desc in descriptors: vector = desc.vector() vital_desc = new_descriptor(len(vector), "d") vital_desc[:] = vector vital_descriptors.append(vital_desc) vital_descriptor_set = DescriptorSet(vital_descriptors) self.push_to_port_using_trait('descriptor_set', vital_descriptor_set) self._base_step()
def _step(self): try: def timing(desc, f): """Return f(), printing a message about how long it took""" start = timer() result = f() end = timer() print('%%%', desc, ' elapsed time: ', end - start, sep='') return result print('step', self._step_id) # grab image container from port using traits in_img_c = self.grab_input_using_trait('image') timestamp = self.grab_input_using_trait('timestamp') dos_ptr = self.grab_input_using_trait('detected_object_set') print('timestamp =', repr(timestamp)) # Get current frame im = get_pil_image(in_img_c.image()).convert('RGB') # Get detection bbox if self._gtbbox_flag: dos = self._m_bbox[self._step_id] bbox_num = len(dos) else: dos = dos_ptr.select(self._select_threshold) bbox_num = dos.size() #print('bbox list len is', dos.size()) det_obj_set = DetectedObjectSet() if bbox_num == 0: print('!!! No bbox is provided on this frame. Skipping this frame !!!') else: # interaction features grid_feature_list = timing('grid feature', lambda: self._grid(im.size, dos, self._gtbbox_flag)) # appearance features (format: pytorch tensor) pt_app_features = timing('app feature', lambda: self._app_feature_extractor(im, dos, self._gtbbox_flag)) track_state_list = [] next_track_id = int(self._track_set.get_max_track_id()) + 1 # get new track state from new frame and detections for idx, item in enumerate(dos): if self._gtbbox_flag: bbox = item fid = self._step_id ts = self._step_id d_obj = DetectedObject(bbox=item, confidence=1.0) else: bbox = item.bounding_box() fid = timestamp.get_frame() ts = timestamp.get_time_usec() d_obj = item if self._add_features_to_detections: # store app feature to detected_object app_f = new_descriptor(g_config.A_F_num) app_f[:] = pt_app_features[idx].numpy() d_obj.set_descriptor(app_f) det_obj_set.add(d_obj) # build track state for current bbox for matching cur_ts = track_state(frame_id=self._step_id, bbox_center=bbox.center(), interaction_feature=grid_feature_list[idx], app_feature=pt_app_features[idx], bbox=[int(bbox.min_x()), int(bbox.min_y()), int(bbox.width()), int(bbox.height())], detected_object=d_obj, sys_frame_id=fid, sys_frame_time=ts) track_state_list.append(cur_ts) # if there are no tracks, generate new tracks from the track_state_list if not self._track_flag: next_track_id = self._track_set.add_new_track_state_list(next_track_id, track_state_list, self._track_initialization_threshold) self._track_flag = True else: # check whether we need to terminate a track for track in list(self._track_set.iter_active()): # terminating a track based on readin_frame_id or original_frame_id gap if (self._step_id - track[-1].frame_id > self._terminate_track_threshold or fid - track[-1].sys_frame_id > self._sys_terminate_track_threshold): self._track_set.deactivate_track(track) # call IOU tracker if self._IOU_flag: self._track_set, track_state_list = timing('IOU tracking', lambda: ( self._iou_tracker(self._track_set, track_state_list) )) #print('***track_set len', len(self._track_set)) #print('***track_state_list len', len(track_state_list)) # estimate similarity matrix similarity_mat, track_idx_list = timing('SRNN association', lambda: ( self._srnn_matching(self._track_set, track_state_list, self._ts_threshold) )) # reset update_flag self._track_set.reset_updated_flag() # Hungarian algorithm row_idx_list, col_idx_list = timing('Hungarian algorithm', lambda: ( sp.optimize.linear_sum_assignment(similarity_mat) )) for i in range(len(row_idx_list)): r = row_idx_list[i] c = col_idx_list[i] if -similarity_mat[r, c] < self._similarity_threshold: # initialize a new track if (track_state_list[c].detected_object.confidence() >= self._track_initialization_threshold): self._track_set.add_new_track_state(next_track_id, track_state_list[c]) next_track_id += 1 else: # add to existing track self._track_set.update_track(track_idx_list[r], track_state_list[c]) # for the remaining unmatched track states, we initialize new tracks if len(track_state_list) - len(col_idx_list) > 0: for i in range(len(track_state_list)): if (i not in col_idx_list and (track_state_list[i].detected_object.confidence() >= self._track_initialization_threshold)): self._track_set.add_new_track_state(next_track_id, track_state_list[i]) next_track_id += 1 print('total tracks', len(self._track_set)) # push track set to output port ot_list = ts2ot_list(self._track_set) ots = ObjectTrackSet(ot_list) self.push_to_port_using_trait('object_track_set', ots) self.push_to_port_using_trait('detected_object_set', det_obj_set) self._step_id += 1 self._base_step() except BaseException as e: print( repr( e ) ) import traceback print( traceback.format_exc() ) sys.stdout.flush() raise
def test_size(self): # Check that we can check the size of the descriptor array. random.seed(0) for i in range(100): n = random.randint(1, 4096) nose.tools.assert_equal(new_descriptor(n).size, n)
def setUp(self): self.f1 = FeatureF([1, 1], 1, 2, 1) self.desc = new_descriptor(33, 'd') self.ts = TrackState(0)