def live(camera_id, filename, hrnet_m, hrnet_c, hrnet_j, hrnet_weights, hrnet_joints_set, image_resolution, disable_tracking, max_batch_size, disable_vidgear, save_heatmap_video, video_format, video_framerate, device): if device is not None: device = torch.device(device) else: if torch.cuda.is_available(): torch.backends.cudnn.deterministic = True device = torch.device('cuda') else: device = torch.device('cpu') # print(device) if save_heatmap_video : print('save video.') image_resolution = ast.literal_eval(image_resolution) has_display = 'DISPLAY' in os.environ.keys() or sys.platform == 'win32' video_writer = None if filename is not None: rotation_code = check_video_rotation(filename) video = cv2.VideoCapture(filename) assert video.isOpened() else: rotation_code = None if disable_vidgear: video = cv2.VideoCapture(camera_id) assert video.isOpened() else: video = CamGear(camera_id).start() model = OnlySimpleHRNet( hrnet_c, hrnet_j, hrnet_weights, model_name=hrnet_m, resolution=image_resolution, max_batch_size=max_batch_size, return_bounding_boxes=True, device=device ) nof_frames = video.get(cv2.CAP_PROP_FRAME_COUNT) if not disable_tracking: prev_boxes = None prev_pts = None prev_person_ids = None next_person_id = 0 ############################# MAKE JSON FORMAT ##################################### json_data = {} json_data['videos'] = [] json_data['annotations'] = [] json_data['categories'] = [] frame_idx = 0 while True: t = time.time() if filename is not None or disable_vidgear: ret, frame = video.read() if not ret: break if rotation_code is not None: frame = cv2.rotate(frame, rotation_code) else: frame = video.read() if frame is None: break _ = None if frame_idx==0: video_dict = {} video_dict['filename'] = str(filename) video_dict['height'] = frame.shape[0] video_dict['width'] = frame.shape[1] video_dict['date_captured'] = str(strftime("%Y-%m-%d %H:%M:%S", gmtime())) json_data['videos'].append(video_dict) pts = model.predict(frame) if not disable_tracking: boxes, pts = pts # import pdb;pdb.set_trace() object_idx = 0 if len(boxes)==0: annotation_dict = {} annotation_dict['filename'] = str(filename) annotation_dict['num_keypoints'] = 0 # number of keypoints annotation_dict['area'] = 0.0 # w*h area annotation_dict['iscrowd'] = 0 # 0 : one person , 1 : more than one person annotation_dict['keypoints'] = [0.0 for i in range(0,54)] # if 18 keypoints : number of points is 54 annotation_dict['frame_id'] = int(frame_idx) annotation_dict['bbox'] = [0.0, 0.0, 0.0, 0.0] annotation_dict['category_id'] = 1 annotation_dict['object_id'] = 0 json_data['annotations'].append(annotation_dict) else: for idx, (box,pt) in enumerate(zip(boxes,pts)): # frame = Image.open('/home/mmlab/CCTV_Server/000000469067.jpg') # draw = ImageDraw.Draw(frame) # draw.rectangle(((0,184.8),(557.32,288.86+184.8)), outline='red') # # draw.rectangle(((box[0], box[1]), (box[2], box[3])), outline='red') # frame.save(os.path.join(output_root,'test.jpg')) # import pdb;pdb.set_trace() bbox_x = round(float(box[0]),2) # visipedia annotation tool x1,y1,x2,y2 bbox format bbox_y = round(float(box[1]),2) bbox_w = round(float(box[2]-box[0]),2) bbox_h = round(float(box[3]-box[1]),2) keypoints_x = [x for y,x,conf in pt] keypoints_y = [y for y,x,conf in pt] confidences = [conf for y,x,conf in pt] keypoints = list() num_keypoints = 0 iscrowd = 0 if len(pts)>1: iscrowd =1 for pt_x,pt_y,confidence in zip(keypoints_x,keypoints_y,confidences): visibility = 0 if int(pt_x)==0 and int(pt_y)==0: pt_x = 0 pt_y = 0 confidence =0 else : pt_x = int(pt_x) pt_y = int(pt_y) num_keypoints+=1 confidence=float(confidence) keypoints.append(pt_x) keypoints.append(pt_y) keypoints.append(confidence) annotation_dict = {} annotation_dict['filename'] = str(filename) annotation_dict['num_keypoints'] = num_keypoints # number of keypoints annotation_dict['area'] = bbox_w*bbox_h # w*h area annotation_dict['iscrowd'] = iscrowd # 0 : one person , 1 : more than one person annotation_dict['keypoints'] = keypoints # if 18 keypoints : number of points is 54 annotation_dict['frame_id'] = int(frame_idx) annotation_dict['bbox'] = [bbox_x, bbox_y, bbox_w, bbox_h] annotation_dict['category_id'] = 1 annotation_dict['object_id'] = int(object_idx) object_idx+=1 json_data['annotations'].append(annotation_dict) # import pdb;pdb.set_trace() if save_heatmap_video: frame = cv2.imread('/home/mmlab/CCTV_Server/golf/heatmap_club_head/%05d.png'%frame_idx) frame_idx+=1 fps = 1. / (time.time() - t) print('\rframe: % 4d / %d - framerate: %f fps ' % (frame_idx, nof_frames - 1, fps), end='') video_full_name = filename.split('/')[-1] output_root = '/home/mmlab/CCTV_Server/golf/output_heatmap' if frame_idx==1: makedir(output_root) output_path = os.path.join(output_root,video_full_name) if save_heatmap_video: if video_writer is None: fourcc = cv2.VideoWriter_fourcc(*video_format) # video format video_writer = cv2.VideoWriter(output_path, fourcc, video_framerate, (frame.shape[1], frame.shape[0])) video_writer.write(frame) if save_heatmap_video: video_writer.release() output_root = '/home/mmlab/CCTV_Server/golf/output_json' output_path = os.path.join(output_root,video_full_name) json_data['categories'].append({'supercategory': 'person', 'id': '1', 'name': 'person', 'keypoints': ['nose', 'left_eye', 'right_eye', 'left_ear', 'right_ear', 'left_shoulder', 'right_shoulder', 'left_elbow', 'right_elbow', 'left_wrist', 'right_wrist', 'left_hip', 'right_hip', 'left_knee', 'right_knee', 'left_ankle', 'right_ankle', 'club_head'], 'skeleton': [[16, 14], [14, 12], [17, 15], [15, 13], [12, 13], [6, 12], [7, 13], [6, 7], [6, 8], [7, 9], [8, 10], [9, 11], [2, 3], [1, 2], [1, 3], [2, 4], [3, 5], [4, 6], [5, 7], [10, 18]]}) file_basename = video_basename(video_full_name) json_output_filename = file_basename+'.json' assert json_output_filename.endswith('.json') with open(os.path.join(output_root, json_output_filename), "w") as json_file: json.dump(json_data, json_file)
def demo(opt): os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpus_str opt.debug = max(opt.debug, 1) detector = Detector(opt) org = (50, 100) font = cv2.FONT_HERSHEY_SIMPLEX fontScale = 1 color = (255, 0, 0) thickness = 2 if opt.demo == 'webcam' or \ opt.demo[opt.demo.rfind('.') + 1:].lower() in video_ext: is_video = True # demo on video stream cam = cv2.VideoCapture(0 if opt.demo == 'webcam' else opt.demo) elif 'http' in opt.demo: is_video = True cam = CamGear(source=opt.demo, stream_mode=True, logging=True).start() else: is_video = False # Demo on images sequences if os.path.isdir(opt.demo): image_names = [] ls = os.listdir(opt.demo) for file_name in sorted(ls): ext = file_name[file_name.rfind('.') + 1:].lower() if ext in image_ext: image_names.append(os.path.join(opt.demo, file_name)) else: image_names = [opt.demo] # Initialize output video out = None out_name = opt.demo[opt.demo.rfind('/') + 1:] print('out_name', out_name) if not os.path.exists('../results'): os.mkdir('../results') if opt.save_video: fourcc = cv2.VideoWriter_fourcc(*'MPEG') out = cv2.VideoWriter( '../results/{}.avi'.format(opt.exp_id + '_' + out_name[:-4]), fourcc, opt.save_framerate, (opt.video_w, opt.video_h)) if opt.debug < 5: detector.pause = False cnt = 0 results = {} det_hist = {} ad = ActionDetection(opt) bowling_df = pd.DataFrame(columns=action_col_names) last_det_cnt = {} flag_dup_det = {} if opt.start_time and not opt.start_frame: opt.start_frame = timecode_to_frames(opt.start_time) opt.end_frame = timecode_to_frames(opt.end_time) cam.set(cv2.CAP_PROP_POS_FRAMES, opt.start_frame) cnt = opt.start_frame if opt.end_frame == -1: opt.end_frame = int(cam.get(cv2.CAP_PROP_FRAME_COUNT)) print("Frame range", opt.start_frame, opt.end_frame) ex_start_time = time.time() while True: if is_video: if 'http' in opt.demo: img = cam.read() else: _, img = cam.read() if img is None or cnt > opt.end_frame: print("time taken to process ", opt.end_frame - opt.start_frame, "frames", time.time() - ex_start_time) bowling_df.to_pickle( '/content/drive/MyDrive/cric_actions/results/results_df_' + str(opt.start_frame) + '_' + str(opt.end_frame) + '.df') save_and_exit(opt, out, results, out_name) else: if cnt < len(image_names): img = cv2.imread(image_names[cnt]) else: save_and_exit(opt, out, results, out_name) cnt += 1 # resize the original video for saving video results if opt.resize_video: img = cv2.resize(img, (opt.video_w, opt.video_h)) # skip the first X frames of the video if cnt < opt.skip_first: continue # cv2.imshow('input', img) # track or detect the image. ret = detector.run(img) # log run time time_str = 'frame {} |'.format(cnt) for stat in time_stats: time_str = time_str + '{} {:.3f}s |'.format(stat, ret[stat]) # print(time_str) # results[cnt] is a list of dicts: # [{'bbox': [x1, y1, x2, y2], 'tracking_id': id, 'category_id': c, ...}] results[cnt] = ret['results'] for res in ret['results']: if res['score'] > opt.vis_thresh: if 'active' in res and res['active'] == 0: continue if res['tracking_id'] in det_hist: det_hist[res['tracking_id']] = np.append( det_hist[res['tracking_id']], res['ct'].reshape(1, 2), axis=0) else: det_hist[res['tracking_id']] = np.array(res['ct'].reshape( 1, 2)) bowling_df_frame, results[cnt] = ad.detect_action( cnt, ret['results'], det_hist) print("[Frame : " + str(cnt) + "]") for ind, res in enumerate(results[cnt]): ret['generic'] = cv2.putText( ret['generic'], str(res['tracking_id']) + " : " + res['action'], (org[0], org[1] + (ind + 1) * 50), font, fontScale, color, thickness, cv2.LINE_AA) ret['generic'] = cv2.putText(ret['generic'], "Frame : " + str(cnt), (org[0], org[1]), font, fontScale, color, thickness, cv2.LINE_AA) if bowling_df_frame: tracking_id = bowling_df_frame[-2] if not tracking_id in last_det_cnt: last_det_cnt.update({tracking_id: cnt}) if not tracking_id in flag_dup_det: flag_dup_det.update({tracking_id: False}) if cnt > last_det_cnt[tracking_id] + 50: flag_dup_det[tracking_id] = False if not flag_dup_det[tracking_id]: print("bowling detected by ", tracking_id) cv2.imwrite( '/content/drive/MyDrive/cric_actions/results/demo{}.jpg'. format(cnt), ret['generic']) bowling_df.loc[len(bowling_df)] = bowling_df_frame last_det_cnt.update({tracking_id: cnt}) flag_dup_det[tracking_id] = True else: [ results[cnt][ind].update({'action': 'idle'}) for ind, res in enumerate(results[cnt]) if res['tracking_id'] == tracking_id ] # save debug image to video if opt.save_video: out.write(ret['generic']) if not is_video: cv2.imwrite('../results/demo{}.jpg'.format(cnt), ret['generic']) if cnt % 1000 == 0: save_and_exit(opt, out, results, "inter" + out_name, False) bowling_df.to_pickle( '/content/drive/MyDrive/cric_actions/results/results.df') # esc to quit and finish saving video if cv2.waitKey(1) == 27: save_and_exit(opt, out, results, out_name) return save_and_exit(opt, out, results)
def start_checking(start_time, video_path, minimum_distance, seconds, waits, frame_width, audio_path, audio_length, camera_target, model): # event = threading.Event() good_to_run = False good_to_write = True output_video_1 = None loop_count = 0 # frame_count = 0 ###################################################### # START THE VIDEO STREAM # ###################################################### if video_path == 0: try: # event.set() vs = cv2.VideoCapture(0) frame_per_seconds = int(vs.get(cv2.CAP_PROP_FPS)) good_to_run = True good_to_write = True except: # event.clear() good_to_run = False good_to_write = False end = time.time() time_elapsed = int(end - start_time) # Final("WebCam Failed", f"Time consumed: {time_elapsed} \n Webcam not connected." ) elif video_path.startswith("http"): try: vs = CamGear(source=video_path, y_tube=True, time_delay=1, logging=True).start() # event.set() frame_per_seconds = 30 good_to_run = True good_to_write = True except: # event.clear() good_to_run = False good_to_write = False end = time.time() time_elapsed = int(end - start_time) print(f"Time consumed: {time_elapsed} seconds.") print( "Youtube Video Load Failed. Online video link stopped working." ) # Final("Youtube Video Load Failed.",f"Time consumed: {time_elapsed} seconds. \n Online video link stopped working.") else: try: # event.set() vs = cv2.VideoCapture(video_path) frame_per_seconds = int(vs.get(cv2.CAP_PROP_FPS)) good_to_run = True good_to_write = True except: # event.clear() good_to_run = False good_to_write = False end = time.time() time_elapsed = int(end - start_time) print(f"Time consumed: {time_elapsed} seconds.") print("Webcam not connected.") os._exit(0) # Final("Video Load Failed", f"Time consumed: {time_elapsed} seconds. \n Something wrong in videopath provided." ) # Loop until the end of the video stream while True and good_to_run == True: if type(video_path) != int: if video_path.startswith("http"): try: frame = vs.read() # event.set() good_to_run = True good_to_write = True except: # event.clear() good_to_run = False good_to_write = False end = time.time() time_elapsed = int(end - start_time) print(f"Time consumed: {time_elapsed} seconds.") print("Online video link stopped working.") os._exit(0) # Final("Youtube Video Read Failed",f"Time consumed: {time_elapsed} seconds. \n Online video link stopped working.") else: try: (frame_exist, frame) = vs.read() # event.set() good_to_run = True good_to_write = True except: # event.clear() good_to_run = False good_to_write = False end = time.time() time_elapsed = int(end - start_time) print(f"Time consumed: {time_elapsed} seconds.") print("Could not get frames from video.") os._exit(0) # Final("Video load Failed.",f"Time consumed: {time_elapsed} seconds. \n Could not get frames from video.") else: try: (frame_exist, frame) = vs.read() # event.set() good_to_run = True good_to_write = True except: # event.clear() good_to_run = False good_to_write = False end = time.time() time_elapsed = int(end - start_time) print(f"Time consumed: {time_elapsed} seconds.") print("Could not get frames from video.") os._exit(0) # Final("Video load Failed.",f"Time consumed: {time_elapsed} seconds. \n Could not get frames from video.") if frame is None: break else: # event.set() good_to_run = True good_to_write = True # frame_count += 1 # Resize the image to the correct size frame = image_resize(frame, width=frame_width) # Make the predictions for this frame (boxes, scores, classes) = model.predict(frame) # print(type(boxes)) # print(type(scores)) # print(type(classes)) if len(boxes) > 0: # Get the human detected in the frame and return the 2 points to build the bounding box array_boxes_detected = get_human_box_detection( boxes, scores[0].tolist(), classes[0].tolist(), frame.shape[0], frame.shape[1]) if len(array_boxes_detected) > 0: # Both of our lists that will contain the centroïds coordonates and the ground points array_centroids = get_centroids(array_boxes_detected) box_and_centroid = list( zip(array_centroids, array_boxes_detected)) # Check if 2 or more people have been detected (otherwise no need to detect) if len(array_centroids) >= 2: close_pairs = [] for i, pair in enumerate( itertools.combinations(array_centroids, r=2)): # for i,pair in enumerate(itertools.combinations(array_centroids, r=2)): # Check if the distance between each combination of points is less than the minimum distance chosen distance_between_pair = math.sqrt( (pair[0][0] - pair[1][0])**2 + (pair[0][1] - pair[1][1])**2) # print(distance_between_pair) #Pairs with probability that will not maintain social distancing. if distance_between_pair <= int( minimum_distance) * 2: #Creating new dictionary containing distances between pairs distance_between_pairs[ f"pairs{i}"] = distance_between_pair #Checking and creating timer for pairs from distance_between_pairs if f"pairs{i}" not in timer_for_each_pairs.keys( ): timer_for_each_pairs[f"pairs{i}"] = 0 if distance_between_pair < int(minimum_distance): close_pairs.append(pair) flat_list = [] for sublist in close_pairs: for item in sublist: flat_list.append(item) common_close_pairs = list(set(flat_list)) # print(common_close_pairs) boxes_to_make_red = [] for ccp in common_close_pairs: for b_and_c in box_and_centroid: if ccp == b_and_c[0]: boxes_to_make_red.append(b_and_c[1]) # print(boxes_to_make_red) for i, items in enumerate(boxes_to_make_red): first_point = boxes_to_make_red[i][0] second_point = boxes_to_make_red[i][1] third_point = boxes_to_make_red[i][2] fourth_point = boxes_to_make_red[i][3] cv2.rectangle(frame, (second_point, first_point), (fourth_point, third_point), COLOR_RED, 2) box_and_centroid.clear() close_pairs.clear() flat_list.clear() common_close_pairs.clear() boxes_to_make_red.clear() # else: # print(f"Something is wrong in frame {frame_count}.") if len(distance_between_pairs) > 0: threading1 = [] for key, value in distance_between_pairs.items(): t1 = threading.Thread(target=check_current_value, args=[key, value, minimum_distance], daemon=True) t1.start() threading1.append(t1) for thread1 in threading1: t1.join() t = timer_for_each_pairs.values() t_max = max(t) if t_max >= seconds and time_to_wait == 0: threading.Thread( target=play_warning, args=[start_time, audio_path, frame_per_seconds], daemon=True).start() threading.Thread(target=waiting_time, args=[audio_length, waits, frame_per_seconds], daemon=True).start() #Update dictionary to remove far away pairs. Check for it in only 10 loop to save computation power. if loop_count >= 10: for k, v in distance_between_pairs.items(): if v > int(minimum_distance) * 2: del distance_between_pairs[k] del timer_for_each_pairs[k] loop_count = 0 loop_count += 1 cv2.imshow("Output", frame) # cv2.namedWindow("Final_Output", cv2.WND_PROP_FULLSCREEN) # cv2.setWindowProperty("Final_Output",cv2.WND_PROP_FULLSCREEN,cv2.WINDOW_FULLSCREEN) # cv2.imshow("Final_Output", frame) key = cv2.waitKey(1) & 0xFF if video_path != 0: if output_video_1 is None: fourcc1 = cv2.VideoWriter_fourcc(*"MJPG") output_video_1 = cv2.VideoWriter( "../output_video/video.avi", fourcc1, 25, (frame.shape[1], frame.shape[0]), True) elif output_video_1 is not None: output_video_1.write(frame) # Break the loop if key == ord("q"): break if video_path != 0 and good_to_write == True: # while cv2.getWindowProperty('Output', cv2.WND_PROP_VISIBLE)==1.0: # cv2.destroyWindow("Output") end = time.time() time.sleep(1) time_elapsed = int(end - start_time) print(f"Time consumed: {time_elapsed} seconds.") print("Successful execution. Video saved in output_folder.") os._exit(0)
def live(camera_id, filename, hrnet_m, hrnet_c, hrnet_j, hrnet_weights, hrnet_joints_set, image_resolution, disable_tracking, max_batch_size, disable_vidgear, save_video, video_format, video_framerate, device): if device is not None: device = torch.device(device) else: if torch.cuda.is_available(): torch.backends.cudnn.deterministic = True device = torch.device('cuda') else: device = torch.device('cpu') # print(device) if save_video: print('save video.') image_resolution = ast.literal_eval(image_resolution) has_display = 'DISPLAY' in os.environ.keys() or sys.platform == 'win32' video_writer = None if filename is not None: rotation_code = check_video_rotation(filename) video = cv2.VideoCapture(filename) assert video.isOpened() else: rotation_code = None if disable_vidgear: video = cv2.VideoCapture(camera_id) assert video.isOpened() else: video = CamGear(camera_id).start() model = OnlySimpleHRNet(hrnet_c, hrnet_j, hrnet_weights, model_name=hrnet_m, resolution=image_resolution, max_batch_size=max_batch_size, return_bounding_boxes=True, device=device) nof_frames = video.get(cv2.CAP_PROP_FRAME_COUNT) if not disable_tracking: prev_boxes = None prev_pts = None prev_person_ids = None next_person_id = 0 index = 0 while True: t = time.time() if filename is not None or disable_vidgear: ret, frame = video.read() if not ret: break if rotation_code is not None: frame = cv2.rotate(frame, rotation_code) else: frame = video.read() if frame is None: break _ = None pts = model.predict(frame) if not disable_tracking: boxes, pts = pts # import pdb;pdb.set_trace() if not disable_tracking: if len(pts) > 0: if prev_pts is None and prev_person_ids is None: person_ids = np.arange(next_person_id, len(pts) + next_person_id, dtype=np.int32) next_person_id = len(pts) + 1 else: boxes, pts, person_ids = find_person_id_associations( boxes=boxes, pts=pts, prev_boxes=prev_boxes, prev_pts=prev_pts, prev_person_ids=prev_person_ids, next_person_id=next_person_id, pose_alpha=0.2, similarity_threshold=0.4, smoothing_alpha=0.1, ) next_person_id = max(next_person_id, np.max(person_ids) + 1) else: person_ids = np.array((), dtype=np.int32) prev_boxes = boxes.copy() prev_pts = pts.copy() prev_person_ids = person_ids else: person_ids = np.arange(len(pts), dtype=np.int32) for i, (pt, pid) in enumerate(zip(pts, person_ids)): frame = draw_points_and_skeleton( frame, pt, joints_dict()[hrnet_joints_set]['skeleton'], person_index=pid, points_color_palette='gist_rainbow', skeleton_color_palette='jet', points_palette_samples=10) color_map = ['red', 'green', 'blue', 'yellow', 'purple', 'white'] fps = 1. / (time.time() - t) print('\rframe: % 4d / %d - framerate: %f fps ' % (index, nof_frames - 1, fps), end='') index += 1 # if has_display: # cv2.imshow('frame.png', frame) # k = cv2.waitKey(1) # if k == 27: # Esc button # if disable_vidgear: # video.release() # else: # video.stop() # break # else: # cv2.imwrite('frame.png', frame) video_full_name = filename.split('/')[-1] output_root = '/home/mmlab/CCTV_Server/golf/output' output_path = os.path.join(output_root, video_full_name) if save_video: if video_writer is None: fourcc = cv2.VideoWriter_fourcc(*video_format) # video format video_writer = cv2.VideoWriter( output_path, fourcc, video_framerate, (frame.shape[1], frame.shape[0])) video_writer.write(frame) if save_video: video_writer.release()
def main(camera_id, filename, hrnet_m, hrnet_c, hrnet_j, hrnet_weights, hrnet_joints_set, image_resolution, single_person, use_tiny_yolo, disable_tracking, max_batch_size, disable_vidgear, save_video, video_format, video_framerate, device): if device is not None: device = torch.device(device) else: if torch.cuda.is_available(): torch.backends.cudnn.deterministic = True device = torch.device('cuda') else: device = torch.device('cpu') # print(device) image_resolution = ast.literal_eval(image_resolution) has_display = 'DISPLAY' in os.environ.keys() or sys.platform == 'win32' video_writer = None if filename is not None: rotation_code = check_video_rotation(filename) video = cv2.VideoCapture(filename) assert video.isOpened() #nof_frames = video.get(cv2.CAP_PROP_FRAME_COUNT) else: rotation_code = None if disable_vidgear: video = cv2.VideoCapture(camera_id) assert video.isOpened() else: video = CamGear(camera_id).start() if use_tiny_yolo: yolo_model_def = "./models/detectors/yolo/config/yolov3-tiny.cfg" yolo_class_path = "./models/detectors/yolo/data/coco.names" yolo_weights_path = "./models/detectors/yolo/weights/yolov3-tiny.weights" else: yolo_model_def = "./models/detectors/yolo/config/yolov3.cfg" yolo_class_path = "./models/detectors/yolo/data/coco.names" yolo_weights_path = "./models/detectors/yolo/weights/yolov3.weights" model = SimpleHRNet(hrnet_c, hrnet_j, hrnet_weights, model_name=hrnet_m, resolution=image_resolution, multiperson=not single_person, return_bounding_boxes=not disable_tracking, max_batch_size=max_batch_size, yolo_model_def=yolo_model_def, yolo_class_path=yolo_class_path, yolo_weights_path=yolo_weights_path, device=device) if not disable_tracking: prev_boxes = None prev_pts = None prev_person_ids = None next_person_id = 0 steps_cnt = 1 flag = 0 while True: t = time.time() if filename is not None or disable_vidgear: ret, frame = video.read() nof_frames = video.get(cv2.CAP_PROP_POS_FRAMES) print(nof_frames) # #Code for bounding box and cropping of the video # bbox, label, conf = cv.detect_common_objects(frame) # frame_bounding = draw_bbox(frame, bbox, label, conf) # #bb.add(image, left, top, right, bottom, label, color) # if save_video: # if video_writer is None: # fourcc = cv2.VideoWriter_fourcc(*video_format) # video format # video_writer = cv2.VideoWriter('output_bounding.avi', fourcc, video_framerate, (frame.shape[1], frame.shape[0])) # video_writer.write(frame_bounding) if not ret: print('\rstep_count: %d' % steps_cnt, end='\n') #print (steps_cnt) break if rotation_code is not None: frame = cv2.rotate(frame, rotation_code) else: frame = video.read() if frame is None: break pts = model.predict(frame) #print(pts[1][0][0][2]) left_hip = np.array(pts[1][0][11]) left_knee = np.array(pts[1][0][13]) left_ankle = np.array(pts[1][0][15]) right_hip = np.array(pts[1][0][12]) right_knee = np.array(pts[1][0][14]) right_ankle = np.array(pts[1][0][16]) ba = left_hip - left_knee bc = left_ankle - left_knee left_cosine_angle = np.dot( ba, bc) / (np.linalg.norm(ba) * np.linalg.norm(bc)) left_angle = np.arccos(left_cosine_angle) left_angle = np.degrees(left_angle) position1 = (10, 50) position1_1 = (200, 50) de = right_hip - right_knee df = right_ankle - right_knee right_cosine_angle = np.dot( de, df) / (np.linalg.norm(de) * np.linalg.norm(df)) right_angle = np.arccos(right_cosine_angle) right_angle = np.degrees(right_angle) position2 = (10, 100) position2_1 = (200, 100) if (left_angle >= 130 and right_angle < 110) or (right_angle >= 130 and left_angle < 110): gc = 'Yes' flag = 0 else: gc = 'No' if (flag == 0): steps_cnt = steps_cnt + 1 flag = 1 position3 = (10, 150) position3_1 = (300, 150) # fontScale fontScale = 1 # Blue color in BGR color = (0, 0, 255) # Line thickness of 2 px thickness = 2 #print (left_angle) #print (right_angle) if not disable_tracking: boxes, pts = pts if not disable_tracking: if len(pts) > 0: if prev_pts is None and prev_person_ids is None: person_ids = np.arange(next_person_id, len(pts) + next_person_id, dtype=np.int32) next_person_id = len(pts) + 1 else: boxes, pts, person_ids = find_person_id_associations( boxes=boxes, pts=pts, prev_boxes=prev_boxes, prev_pts=prev_pts, prev_person_ids=prev_person_ids, next_person_id=next_person_id, pose_alpha=0.2, similarity_threshold=0.4, smoothing_alpha=0.1, ) next_person_id = max(next_person_id, np.max(person_ids) + 1) else: person_ids = np.array((), dtype=np.int32) prev_boxes = boxes.copy() prev_pts = pts.copy() prev_person_ids = person_ids else: person_ids = np.arange(len(pts), dtype=np.int32) for i, (pt, pid) in enumerate(zip(pts, person_ids)): frame = draw_points_and_skeleton( frame, pt, joints_dict()[hrnet_joints_set]['skeleton'], person_index=pid, points_color_palette='gist_rainbow', skeleton_color_palette='jet', points_palette_samples=10) fps = 1. / (time.time() - t) print('\rframerate: %f fps' % fps, end='\n') #print(steps_cnt) if has_display: cv2.imshow('frame.png', frame) k = cv2.waitKey(1) if k == 27: # Esc button if disable_vidgear: video.release() else: video.stop() break else: frame = cv2.putText(frame, str('left_angle:'), position1, cv2.FONT_HERSHEY_SIMPLEX, fontScale, color, thickness, cv2.LINE_AA) frame = cv2.putText(frame, str(left_angle), position1_1, cv2.FONT_HERSHEY_SIMPLEX, fontScale, color, thickness, cv2.LINE_AA) frame = cv2.putText(frame, str('right_angle:'), position2, cv2.FONT_HERSHEY_SIMPLEX, fontScale, color, thickness, cv2.LINE_AA) frame = cv2.putText(frame, str(right_angle), position2_1, cv2.FONT_HERSHEY_SIMPLEX, fontScale, color, thickness, cv2.LINE_AA) frame = cv2.putText(frame, str('Ground_Contact:'), position3, cv2.FONT_HERSHEY_SIMPLEX, fontScale, color, thickness, cv2.LINE_AA) frame = cv2.putText(frame, str(gc), position3_1, cv2.FONT_HERSHEY_SIMPLEX, fontScale, color, thickness, cv2.LINE_AA) #bbox, label, conf = cv.detect_common_objects(frame) #frame = draw_bbox(frame, bbox, label, conf) #bb.add(image, left, top, right, bottom, label, color) cv2.imwrite('frame.png', frame) if save_video: if video_writer is None: fourcc = cv2.VideoWriter_fourcc(*video_format) # video format video_writer = cv2.VideoWriter( 'output.avi', fourcc, video_framerate, (frame.shape[1], frame.shape[0])) video_writer.write(frame) if save_video: video_writer.release()