def compare_function(): kd_m = KdTreeMatcher() li_m = LinearMatcher() smaller_dict = PickleUtils.read_pickle( '../session/db/smaller_reg_dict.pkl', default={}) if smaller_dict == {}: print('Missing ../session/db/smaller_reg_dict.pkl') return -1 test_img_ids = list(smaller_dict.keys()) test_embs = [ PickleUtils.read_pickle( os.path.join(Config.LIVE_DIR, '{}.{}'.format(image_id, Config.PKL_EXT)))[1] for image_id in test_img_ids ] same = 0 not_same = 0 for emb in test_embs: kd_id, _ = kd_m.match(emb) li_id, _ = li_m.match(emb) if kd_id == li_id: same += 1 else: not_same += 1 print('Same: {}\nNot Same: {}'.format(same, not_same))
def main(src, dst): # his_dic = get_history_in_send_folder() his_dic = PickleUtils.read_pickle('/home/manho/data/his_dic.pkl') NEW_TRACKING_DIR = dst create_if_not_exist(NEW_TRACKING_DIR) track_id_dirs = glob.glob(src + '/*') for track_id_dir in track_id_dirs: print('Processing ' + track_id_dir) splited_file_name = glob.glob(track_id_dir + '/*')[0].split('/')[-1].replace( '.jpg', '').split('_') face_id = splited_file_name[0] track_id = track_id_dir.split('/')[-1] print('FACEID: {}, TRACKID: {}'.format(face_id, track_id)) face_id_dir = os.path.join(NEW_TRACKING_DIR, face_id) create_if_not_exist(face_id_dir) new_track_id_dir = os.path.join(face_id_dir, track_id) subprocess.call(["cp", "-r", track_id_dir, face_id_dir]) this_mtime = -1 if face_id in list(his_dic.keys()): this_mtime = his_dic[face_id].pop(0) if his_dic[face_id] == []: his_dic.pop(face_id, None) else: this_mtime = os.stat(track_id_dir).st_mtime modify_image_id(new_track_id_dir, track_id, time_stamp=this_mtime) PickleUtils.save_pickle('/home/manho/data/his_dic_remain.pkl', his_dic) print('Done!')
def extract_images(trackers, person_id): print('Extract Register Images ...') reg_dict = PickleUtils.read_pickle(Config.REG_IMAGE_FACE_DICT_FILE) if reg_dict is None: reg_dict = {} # Clear reg_dict and pickles in live folder reg_dict = clear_person_id_in_reg(reg_dict, person_id) print('Tracker len {}'.format(len(trackers))) print('Tracker ids') for i in trackers.keys(): print(i) first_frame_id_tracked = trackers[0].elements[0].frame_id b_f = first_frame_id_tracked - 5 a_f = first_frame_id_tracked + 5 the_last_fids = [ fid for fid in trackers.keys() if (b_f <= trackers[fid].elements[0].frame_id <= a_f) ] # counter_dict = {fid: len(trackers[fid].elements) for fid in trackers.keys()} # max_len_fid = max(counter_dict, key=counter_dict.get) if not os.path.exists('../data/tracking/register-{}'.format(person_id)): os.mkdir('../data/tracking/register-{}'.format(person_id)) face_embs = [] face_labels = [] if len(the_last_fids) > 1: return face_embs, face_labels, 'many_faces' for fid in the_last_fids: if len(trackers[fid].elements) < 100: return face_embs, face_labels, 'not_good' with open('register_function_log.txt', 'a') as f: f.write('Len of elements {}\n'.format(len(trackers[fid].elements))) for index, element in enumerate(trackers[fid].elements): face_embs.append(element.embedding) # Write images out image_id = '{}_{}_{}_{}'.format(person_id, element.frame_id, index, element.time_stamp) live_tup = ((element.display_image), (element.embedding)) PickleUtils.save_pickle('{}/{}.pkl'.format(Config.LIVE_DIR, image_id), value=live_tup) with open('register_function_log.txt', 'a') as f: f.write('Save pkl {}/{}.pkl'.format(Config.LIVE_DIR, image_id)) face_embs.append(element.embedding) # if not os.path.exists('../data/register/register-{}'.format(person_id)): # os.mkdir('../data/register/register-{}'.format(person_id)) # img_path = '../data/register/register-{}/{}.jpg'.format(person_id, # image_id) # misc.imsave(img_path, element.display_image) # Save register reg_dict[image_id] = person_id PickleUtils.save_pickle(Config.REG_IMAGE_FACE_DICT_FILE, value=reg_dict) face_labels = [person_id] * len(face_embs) return face_embs, face_labels, 'ok'
def regdict_to_faceinfo(): mongodb_faceinfo.remove({}) reg_dict = PickleUtils.read_pickle(reg_dict_path) reg_dict_length = len(reg_dict) for i, i_id in enumerate(reg_dict): print(reg_dict_length - i) splitted_image_id = i_id.split('_') track_id = int(splitted_image_id[0]) image_id = i_id face_id = reg_dict[i_id] time_stamp = float(splitted_image_id[5]) bounding_box = splitted_image_id[1:5] bounding_box = [int(bb_num) for bb_num in bounding_box] padded_bbox = splitted_image_id[-4:len(splitted_image_id)] padded_bbox = '_'.join(padded_bbox) display_img = PickleUtils.read_pickle(live_folder + '/' + i_id + '.pkl')[0] display_img = cv2.cvtColor(display_img, cv2.COLOR_BGR2RGB) cropped_img = CropperUtils.reverse_display_face( display_img, padded_bbox) # Extract feature preprocessed_image = preprocessor.process(cropped_img) emb_array, _ = face_extractor.extract_features(preprocessed_image) mongodb_faceinfo.insert_one({ 'track_id': track_id, 'image_id': image_id, 'face_id': face_id, 'time_stamp': time_stamp, 'bounding_box': bounding_box, 'embedding': emb_array.tolist(), 'points': None, 'is_registered': True })
def generate_smaller_reg_dict(): reg_image_face_dict = PickleUtils.read_pickle( Config.REG_IMAGE_FACE_DICT_FILE, default={}) ids = set([reg_image_face_dict[fid] for fid in reg_image_face_dict]) smaller_reg_dict = {} for single_id in ids: img_ids = [ key for key, value in reg_image_face_dict.items() if value == single_id ] for i in range(5): smaller_reg_dict[img_ids[i]] = single_id PickleUtils.save_pickle('../session/db/smaller_reg_dict.pkl', value=smaller_reg_dict) print('Smaller reg dict created.')
labels = [] for face_ids, face_embs in UNKNOW_EMBS_DICT.items(): face_ids = [face_id] * len(face_embs) embs = embs + face_embs labels = labels + face_ids self.matcher.fit(embs, labels) # check that KNOWN set dist > 0 for face_id, embs in KNOW_EMBS_DICT.items(): for emb in embs: top_ids, dist = self.matcher.match(emb, 2, return_dists=True) self.assertNotAlmostEqual(dist[0], 0) if __name__ == '__main__': reg_face_dict = PickleUtils.read_pickle( Config.PickleFile.REG_IMAGE_FACE_DICT_FILE, default={}) face_ids = list(set(reg_face_dict.values())) known_faces = face_ids[:-5] unknown_faces = face_ids[-5:] print('Know face', known_faces) print('Unknow face', unknown_faces) KNOW_EMBS_DICT = defaultdict(list) KNOW_IMGID_EMBS_DICT = defaultdict(list) UNKNOW_EMBS_DICT = defaultdict(list) for image_id, face_id in reg_face_dict.items(): emb = PickleUtils.read_pickle( os.path.join('/mnt/data/tch-data/tch-data/session/live/', '{}.pkl'.format(image_id)))[1] if face_id in known_faces: KNOW_EMBS_DICT[face_id].append(emb) KNOW_IMGID_EMBS_DICT[image_id].append(emb)
def generic_function(cam_url, area): ''' This is main function ''' print("Generic function") print("Cam URL: {}".format(cam_url)) print("Area: {}".format(area)) # Variables for tracking faces # Variables holding the correlation trackers and the name per faceid list_of_trackers = TrackersList() clear_tracking_folder() matcher = KdTreeMatcher() print("Load sample") frame_sample = PickleUtils.read_pickle('../session/db/sample.pkl') frame_counter = 0 track_results = TrackerResultsDict() predict_dict = {} if Config.CALC_FPS: start_time = time.time() if args.cam_url is not None: frame_reader = URLFrameReader(args.cam_url, scale_factor=1) else: frame_reader = RabbitFrameReader(rabbit_mq) video_out = None video_out_fps = 24 video_out_w = 1920 video_out_h = 1080 print(video_out_fps, video_out_w, video_out_h) center = (int(video_out_w / 2), int(video_out_h / 2)) bbox = [ int(center[0] - 0.35 * video_out_w), int(center[1] - video_out_h * 0.35), int(center[0] + 0.35 * video_out_w), int(center[1] + 0.35 * video_out_h) ] if Config.Track.TRACKING_VIDEO_OUT: video_out = VideoHandle('../data/tracking_video_out.avi', video_out_fps, int(video_out_w), int(video_out_h)) try: while True: # frame_reader.has_next(): frame = frame_sample[frame_counter].read_image if frame is None: print("Waiting for the new image") trackers_return_dict, predict_trackers_dict = \ list_of_trackers.check_delete_trackers(matcher, rabbit_mq) track_results.update_two_dict(trackers_return_dict) predict_dict.update(predict_trackers_dict) continue print("Frame ID: %d" % frame_counter) print('Num of ids in matcher: {}'.format(matcher._numofids)) if Config.Track.TRACKING_VIDEO_OUT: video_out.tmp_video_out(frame) if Config.CALC_FPS: fps_counter = time.time() list_of_trackers.update_dlib_trackers(frame) if frame_counter % Config.Frame.FRAME_INTERVAL == 0: origin_bbs = frame_sample[frame_counter].origin_bbs points = frame_sample[frame_counter].points for i, origin_bb in enumerate(origin_bbs): print(is_inner_bb(bbox, origin_bb)) if not is_inner_bb(bbox, origin_bb): continue display_face, _ = CropperUtils.crop_display_face( frame, origin_bb) # Calculate embedding emb_array = frame_sample[frame_counter].embs[i] # Calculate angle angle = FaceAngleUtils.calc_angle(points[:, i]) # TODO: refractor matching_detected_face_with_trackers matched_fid = list_of_trackers.matching_face_with_trackers( frame, origin_bb, emb_array) # Update list_of_trackers list_of_trackers.update_trackers_list( matched_fid, time.time(), origin_bb, display_face, emb_array, angle, area, frame_counter, i, matcher, rabbit_mq) trackers_return_dict, predict_trackers_dict = \ list_of_trackers.check_delete_trackers(matcher, rabbit_mq) track_results.update_two_dict(trackers_return_dict) predict_dict.update(predict_trackers_dict) # Check extract trackers history time (str(frame_counter) + '_' + str(i)) list_of_trackers.trackers_history.check_time() frame_counter += 1 if Config.CALC_FPS: print("FPS: %f" % (1 / (time.time() - fps_counter))) if Config.Track.TRACKING_VIDEO_OUT: print('Write track video') video_out.write_track_video(track_results.tracker_results_dict) if Config.Track.PREDICT_DICT_OUT: PickleUtils.save_pickle(Config.PREDICTION_DICT_FILE, predict_dict) except KeyboardInterrupt: print('Keyboard Interrupt !!! Release All !!!') if Config.CALC_FPS: print('Time elapsed: {}'.format(time.time() - start_time)) print('Avg FPS: {}'.format( (frame_counter + 1) / (time.time() - start_time))) frame_reader.release() if Config.Track.TRACKING_VIDEO_OUT: print('Write track video') video_out.write_track_video(track_results.tracker_results_dict) video_out.release() if Config.Track.PREDICT_DICT_OUT: PickleUtils.save_pickle(Config.PREDICTION_DICT_FILE, predict_dict)