def get_pose(frame, sess, output_stride, model_outputs, scale_factor=1): '''Passes frame through Posenet to determine the coordinates of key points of body''' input_image, display_image, output_scale = posenet.utils._process_input( frame, scale_factor, output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image}) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=1, min_pose_score=0.15) keypoint_coords *= output_scale #drawing nodes and lines on frame draw_image = posenet.draw_skel_and_kp(display_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.15, min_part_score=0.05) return (draw_image, keypoint_scores[0], keypoint_coords[0])
def main(): errors = 0 with tf.Session() as sess: model_cfg, model_outputs = posenet.load_model(args.model, sess) output_stride = model_cfg['output_stride'] if args.output_dir: if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) filenames = [f.path for f in os.scandir(args.image_dir) if f.is_file() and f.path.endswith(('.png', '.jpg'))] start = time.time() for f in filenames: input_image, draw_image, output_scale = posenet.read_imgfile( f, scale_factor=args.scale_factor, output_stride=output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image} ) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=1, min_pose_score=0.30) keypoint_coords *= output_scale if args.output_dir: draw_image = posenet.draw_skel_and_kp(draw_image, pose_scores, keypoint_scores, keypoint_coords,min_pose_score=0.25, min_part_score=0.25) cv2.imwrite(os.path.join(args.output_dir, os.path.relpath(f, args.image_dir)), draw_image) if not args.notxt: print("Results for image: %s" % f) coords = "{" for pi in range(len(pose_scores)): if pose_scores[pi] == 0.: break print('Pose #%d, score = %f' % (pi, pose_scores[pi])) for ki, (s, c) in enumerate(zip(keypoint_scores[pi, :], keypoint_coords[pi, :, :])): print('Keypoint %s, score = %f, coord = %s' % (posenet.PART_NAMES[ki], s, c)) coords += str(posenet.COORDENADAS[ki] % (c[0], c[1])) try: coords += ",\"atividade\"" + str(":") + "\"3\"" coords += "}" createFile(coords) except: print("Erro file: " + str(filenames)) errors +=1 print('Average FPS:', len(filenames) / (time.time() - start)) print('ERRROS:', errors)
def process_img(img): global tf_sess, model_cfg, model_outputs t = time.time() output_stride = model_cfg['output_stride'] input_image, _, output_scale = posenet.process_input( img, output_stride=output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = tf_sess.run( model_outputs, feed_dict={'image:0': input_image}) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.25) t = time.time() - t logging.debug("Pose estimated in {:.4f} secs".format(t)) keypoint_coords *= output_scale return pose_scores, keypoint_scores, keypoint_coords
def process_pose_frame(np_frame, resolution): frame = None with tf.Session() as sess: model_cfg, model_outputs = posenet.load_model(0, sess) output_stride = model_cfg['output_stride'] input_image, draw_image, output_scale = posenet.process_input( np_frame, output_stride=output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image}) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=1, min_pose_score=0.25) keypoint_coords *= output_scale frame = posenet.draw_skel_and_kp(draw_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.25, min_part_score=0.25) return frame
def main(): with tf.Session() as sess: model_cfg, model_outputs = posenet.load_model(args.model, sess) output_stride = model_cfg['output_stride'] num_images = args.num_images filenames = [ f.path for f in os.scandir(args.image_dir) if f.is_file() and f.path.endswith(('.png', '.jpg')) ] if len(filenames) > num_images: filenames = filenames[:num_images] images = { f: posenet.read_imgfile(f, 1.0, output_stride)[0] for f in filenames } start = time.time() for i in range(num_images): heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': images[filenames[i % len(filenames)]]}) output = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.25) print('Average FPS:', num_images / (time.time() - start))
def extract_pose(img_path): model_cfg, model_outputs, sess = load_model() output_stride = model_cfg['output_stride'] # read and preproess image input_image, draw_image, output_scale = posenet.read_imgfile( img_path, scale_factor=POSENET_SCALE_FACTOR, output_stride=output_stride) # evaluate image using posenet model heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image} ) # extract pose features from model outputs pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.25) keypoint_coords *= output_scale return pose_scores, keypoint_scores, keypoint_coords
def main(): with torch.no_grad(): model = posenet.load_model(args.model) model = model.cuda() output_stride = model.output_stride num_images = args.num_images filenames = [ f.path for f in os.scandir(args.image_dir) if f.is_file() and f.path.endswith(('.png', '.jpg'))] if len(filenames) > num_images: filenames = filenames[:num_images] images = {f: posenet.read_imgfile(f, 1.0, output_stride)[0] for f in filenames} start = time.time() for i in range(num_images): input_image = torch.Tensor(images[filenames[i % len(filenames)]]).cuda() results = model(input_image) heatmaps, offsets, displacement_fwd, displacement_bwd = results output = posenet.decode_multiple_poses( heatmaps.squeeze(0), offsets.squeeze(0), displacement_fwd.squeeze(0), displacement_bwd.squeeze(0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.25) print('Average FPS:', num_images / (time.time() - start))
def predict(self, input_image, output_scale): print("[INFO] Predict Start...") start = time.time() with torch.no_grad(): input_image = torch.Tensor(input_image).cuda() heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = self.model( input_image) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(0), offsets_result.squeeze(0), displacement_fwd_result.squeeze(0), displacement_bwd_result.squeeze(0), output_stride=self.output_stride, max_pose_detections=1, min_pose_score=0.25) ''' print("keypoint_coords") for pi in range(len(pose_scores)): if pose_scores[pi] == 0.: break print('Pose #%d, score = %f' % (pi, pose_scores[pi])) for ki, (s, c) in enumerate(zip(keypoint_scores[pi, :], keypoint_coords[pi, :, :])): print('Keypoint %s, score = %f, coord = %s' % (posenet.PART_NAMES[ki], s, c)) ''' print("FPS", 1 / (time.time() - start)) self.pose_scores = pose_scores self.keypoint_scores = keypoint_scores self.keypoint_coords = keypoint_coords / output_scale return #keypoint_coords #return max_pose_detections*17*2 np.array
def get_pose(image): global sess input_image, draw_image, output_scale = posenet.process_input( image, scale_factor=scale_factor, output_stride=output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image}) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.25) keypoint_coords *= output_scale # If you need to draw human poses # draw_image = posenet.draw_skel_and_kp( # draw_image, pose_scores, keypoint_scores, keypoint_coords, # min_pose_score=0.25, min_part_score=0.25) if keypoint_coords[0][0][0] == 0 and keypoint_coords[0][0][1] == 0: return image return get_face(image, keypoint_coords)
def getpoints(self, image_input, sess, model_cfg, model_outputs): sum = 0 pos_temp_data = [] output_stride = model_cfg['output_stride'] input_image, draw_image, output_scale = posenet.read_imgfile( image_input, scale_factor=0.5, output_stride=output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image}) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=1, min_pose_score=0.1) keypoint_coords *= output_scale for pi in range(len(pose_scores)): if pose_scores[pi] == 0.: break for ki, (s, c) in enumerate( zip(keypoint_scores[pi, :], keypoint_coords[pi, :, :])): pos_temp_data.append(c[1]) pos_temp_data.append(c[0]) for ki, (s, c) in enumerate( zip(keypoint_scores[pi, :], keypoint_coords[pi, :, :])): pos_temp_data.append(s) sum = sum + s pos_temp_data.append(sum) return pos_temp_data
def predict_2d_joints(filename, min_pose_score=0.5, min_part_score=0.1): # 读取图像文件 input_image, skeleton_2d_image, output_scale = posenet.read_imgfile( filename, scale_factor=args.scale_factor, output_stride=output_stride) # print(input_image.shape, draw_image.shape) # 检测热图offset heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image} ) # 检测坐标点 pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=10, min_pose_score=min_pose_score) keypoint_coords *= output_scale # 显示结果 skeleton_2d_image = posenet.draw_skel_and_kp( skeleton_2d_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=min_pose_score, min_part_score=min_part_score) skeleton_2d_image = cv2.cvtColor(skeleton_2d_image, cv2.COLOR_BGR2RGB) # 交换xy在数组中的位置 coords_2d = np.zeros_like(keypoint_coords) coords_2d[:, :, 0], coords_2d[:, :, 1] = keypoint_coords[:, :, 1], keypoint_coords[:, :, 0] return skeleton_2d_image, coords_2d
def main(): with tf.Session() as sess: model_cfg, model_outputs = posenet.load_model(args.model, sess) output_stride = model_cfg['output_stride'] if args.output_dir: if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) filenames = [ f.path for f in os.scandir(args.image_dir) if f.is_file() and f.path.endswith(('.png', '.jpg'))] start = time.time() for f in filenames: input_image, draw_image, output_scale = posenet.read_imgfile( f, scale_factor=args.scale_factor, output_stride=output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image} ) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.25) keypoint_coords *= output_scale if args.output_dir: draw_image = posenet.draw_skel_and_kp( draw_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.25, min_part_score=0.25) cv2.imwrite(os.path.join(args.output_dir, os.path.relpath(f, args.image_dir)), draw_image) if not args.notxt: print() print("Results for image: %s" % f) # Open file file = open("log.txt", "a") for pi in range(len(pose_scores)): if pose_scores[pi] == 0.: break print('Pose #%d, score = %f' % (pi, pose_scores[pi])) file.write('Pose #%d, score = %f \n' % (pi, pose_scores[pi])) for ki, (s, c) in enumerate(zip(keypoint_scores[pi, :], keypoint_coords[pi, :, :])): print('Keypoint %s, score = %f, coord = %s' % (posenet.PART_NAMES[ki], s, c)) file.write('Keypoint %s, score = %f, coord = %s \n' % (posenet.PART_NAMES[ki], s, c)) # Close file file.close() print('Average FPS:', len(filenames) / (time.time() - start))
def main(): # D:\Programming-Github\Sem-6\MiniProject\posenet-pytorch-master\posenet\converter\wget.py # go here and find # data = json.loads(response.content) # replace with # data = json.loads(response.content.decode('utf-8')) model = posenet.load_model(args.model) model = model.cuda() output_stride = model.output_stride cap = cv2.VideoCapture( "C:\\Users\\habil\\Pictures\\Camera Roll\\WIN_20200329_15_03_35_Pro.mp4" ) cap.set(3, args.cam_width) cap.set(4, args.cam_height) start = time.time() frame_count = 0 while True: try: input_image, display_image, output_scale = posenet.read_cap( cap, scale_factor=args.scale_factor, output_stride=output_stride) except OSError: break with torch.no_grad(): input_image = torch.Tensor(input_image).cuda() heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = model( input_image) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(0), offsets_result.squeeze(0), displacement_fwd_result.squeeze(0), displacement_bwd_result.squeeze(0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.15) keypoint_coords *= output_scale #overlay_image = posenet.draw_skel_and_kp( #display_image, pose_scores, keypoint_scores, keypoint_coords, #min_pose_score=0.15, min_part_score=0.1) print(keypoint_coords) #overlay_image = posenet.draw_skel_and_kp(display_image,[],[],[]) #cv2.imshow('posenet', overlay_image) frame_count += 1 if cv2.waitKey(1) & 0xFF == ord('q'): break print('Average FPS: ', frame_count / (time.time() - start))
def main(): with tf.Session() as sess: model_cfg, model_outputs = posenet.load_model(args.model, sess) output_stride = model_cfg['output_stride'] if args.output_csv_dir: if not os.path.exists(args.output_csv_dir): os.makedirs(args.output_csv_dir) filenames = [ f.path for f in os.scandir(args.image_dir) if f.is_file() and f.path.endswith(('.png', '.jpg')) ] start = time.time() for f in filenames: input_image, draw_image, output_scale = posenet.read_imgfile( f, scale_factor=args.scale_factor, output_stride=output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image}) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=1, min_pose_score=0.25) keypoint_coords *= output_scale with open(args.output_csv_dir + "/motion_model.csv", 'a') as write_file: writer = csv.writer(write_file) # clip keypoint_coords[0, :, 0] = keypoint_coords[0, :, 0] - min( keypoint_coords[0, :, 0]) keypoint_coords[0, :, 1] = keypoint_coords[0, :, 1] - min( keypoint_coords[0, :, 1]) # normalize x_l2_norm = np.linalg.norm(keypoint_coords[0, :, 0], ord=2) pose_coords_x = (keypoint_coords[0, :, 0] / x_l2_norm).tolist() y_l2_norm = np.linalg.norm(keypoint_coords[0, :, 1], ord=2) pose_coords_y = (keypoint_coords[0, :, 1] / y_l2_norm).tolist() tpm_row = [f.replace(args.image_dir, '') ] + pose_coords_x + pose_coords_y + keypoint_scores[ 0, :].tolist() + [pose_scores[0]] writer.writerow(tpm_row) print('Average FPS:', len(filenames) / (time.time() - start)) print('Complete making CSV File!!')
def main(): model = posenet.load_model(args.model) model = model.cuda() output_stride = model.output_stride if args.output_dir: if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) filenames = [ f.path for f in os.scandir(args.image_dir) if f.is_file() and f.path.endswith(('.png', '.jpg'))] start = time.time() for f in filenames: input_image, draw_image, output_scale = posenet.read_imgfile( f, scale_factor=args.scale_factor, output_stride=output_stride) with torch.no_grad(): input_image = torch.Tensor(input_image).cuda() heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = model(input_image) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(0), offsets_result.squeeze(0), displacement_fwd_result.squeeze(0), displacement_bwd_result.squeeze(0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.25) keypoint_coords *= output_scale if args.output_dir: draw_image = posenet.draw_skel_and_kp( draw_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.25, min_part_score=0.25) cv2.imwrite(os.path.join(args.output_dir, os.path.relpath(f, args.image_dir)), draw_image) if not args.notxt: print() print("Results for image: %s" % f) for pi in range(len(pose_scores)): if pose_scores[pi] == 0.: break print('Pose #%d, score = %f' % (pi, pose_scores[pi])) for ki, (s, c) in enumerate(zip(keypoint_scores[pi, :], keypoint_coords[pi, :, :])): print('Keypoint %s, score = %f, coord = %s' % (posenet.PART_NAMES[ki], s, c)) print('Average FPS:', len(filenames) / (time.time() - start))
def _video_loop(self): """ Get frame from the video stream and show it in Tkinter """ input_image, display_image, output_scale = posenet.read_cap( self._vs, scale_factor=PostureAidConfig.config("SCALE_FACTOR"), output_stride=self._output_stride ) with torch.no_grad(): if torch.cuda.is_available(): input_image = torch.Tensor(input_image).cuda() else: input_image = torch.Tensor(input_image) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = self._model(input_image) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(0), offsets_result.squeeze(0), displacement_fwd_result.squeeze(0), displacement_bwd_result.squeeze(0), output_stride=self._output_stride, max_pose_detections=10, min_pose_score=0.15 ) keypoint_coords *= output_scale current_pos = posenet.get_pos_from_img( display_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.15, min_part_score=0.1 ) if self._running: if not check_head_within_boundary(self._correct_pos, current_pos, self._pad_x, self._pad_y): if not self._alarm.is_playing(): self._alarm.play() else: if self._alarm.is_playing(): self._alarm.stop() else: self._correct_pos = current_pos imgtk = draw_boxes(display_image, self._correct_pos, current_pos, self._pad_x, self._pad_y) self.panel.imgtk = imgtk self.panel.config(image=imgtk) # call the same function after 30 milliseconds self.root.after(50, self._video_loop)
def infer_image(self, num_people, return_overlay=False, return_input_img=False): input_image, display_image, output_scale = p.read_cap( self.video, scale_factor=self.scale_factor, output_stride=self.output_stride) inputs = {self.input_names[0]: input_image} self.client.run(inputs) heatmaps_result = self.client.tensor('heatmap').map() offsets_result = self.client.tensor('offset_2').map() displacement_fwd_result = self.client.tensor( 'displacement_fwd_2').map() displacement_bwd_result = self.client.tensor( 'displacement_bwd_2').map() pose_scores, keypoint_scores, keypoint_coords = p.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=self.output_stride, max_pose_detections=num_people, min_pose_score=0.20) keypoint_coords *= output_scale # for pose in keypoint_coords: # pose[:, 1] += (display_image.shape[1] // 2) - (display_image.shape[0] // 2) if not return_overlay: return keypoint_coords[:num_people] # TODO this isn't particularly fast, use GL for drawing and display someday... overlay_image = p.draw_skel_and_kp(display_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.20, min_part_score=0.1) if return_input_img: return cv2.cvtColor( overlay_image, cv2.COLOR_BGR2RGB), keypoint_coords[:num_people], input_image return cv2.cvtColor(overlay_image, cv2.COLOR_BGR2RGB), keypoint_coords[:num_people]
def main(path): model = posenet.load_model(model_size) model = model.cuda() output_stride = model.output_stride filenames = [ f.path for f in os.scandir(path) if f.is_file() and f.path.endswith(('.png', '.jpg')) ] start = time.time() pre_centroids = [] cnt = 0 for f in filenames: time.sleep(0.03) input_image, draw_image, output_scale = posenet.read_imgfile( f, scale_factor=scale_factor, output_stride=output_stride) with torch.no_grad(): input_image = torch.Tensor(input_image).cuda() heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = model( input_image) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(0), offsets_result.squeeze(0), displacement_fwd_result.squeeze(0), displacement_bwd_result.squeeze(0), output_stride=output_stride, max_pose_detections=max_pose_detections, min_pose_score=min_pose_score) keypoint_coords *= output_scale centroids, tilt_angles, widths, heights, left_up_points, right_bottom_points = posenet.get_potential_information( pose_scores, keypoint_coords, min_pose_score=min_pose_score) isFailed = posenet.get_isFailed(pre_centroids, centroids, tilt_angles, widths, heights, 0.03) pre_centroids = centroids draw_image = posenet.draw_box_and_center(draw_image, centroids, left_up_points, right_bottom_points, isFailed) if isFailed.count(True): cv2.imwrite('output_image/' + str(cnt) + '.png', draw_image) cnt = cnt + 1 cv2.imshow('Fall detection system', draw_image) cv2.waitKey(1) cv2.destroyAllWindows()
def inference(model, image): with torch.no_grad(): input_image = torch.Tensor(image).cuda() heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = model( input_image) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(0), offsets_result.squeeze(0), displacement_fwd_result.squeeze(0), displacement_bwd_result.squeeze(0), output_stride=model.output_stride, max_pose_detections=10, min_pose_score=0.25) return pose_scores, keypoint_scores, keypoint_coords
def get_pose_coordinates(img): model = posenet.load_model(101) model = model.cuda() output_stride = model.output_stride scale_factor = 1.0 input_image, draw_image, output_scale = posenet.read_pil_img(img, scale_factor, output_stride) with torch.no_grad(): input_image = torch.Tensor(input_image).cuda() heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = model(input_image) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(0), offsets_result.squeeze(0), displacement_fwd_result.squeeze(0), displacement_bwd_result.squeeze(0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.25) keypoint_coords *= output_scale # draw_image = posenet.draw_skel_and_kp( # draw_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.25, min_part_score=0.25) # cv2.imwrite('poseimage.jpg', draw_image) results = [] for pi in range(len(pose_scores)): pose = dict() if pose_scores[pi] == 0.: break pose["PoseID"] = pi pose["PoseScore"] = pose_scores[pi] pose["Keypoints"] = [] for ki, (s, c) in enumerate(zip(keypoint_scores[pi, :], keypoint_coords[pi, :, :])): keypoint_dict = dict() keypoint = { "Score:" : s, "Position" : [c[0], c[1], 0] } keypoint_dict[posenet.PART_NAMES[ki]] = keypoint pose["Keypoints"].append(keypoint_dict) results.append(pose) return results
def estimate_multiple_poses(self, image, max_pose_detections=10): heatmap_result, offsets_result, displacement_fwd_result, displacement_bwd_result, image_scale = \ self.model.predict(image) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmap_result.numpy().squeeze(axis=0), offsets_result.numpy().squeeze(axis=0), displacement_fwd_result.numpy().squeeze(axis=0), displacement_bwd_result.numpy().squeeze(axis=0), output_stride=self.model.output_stride, max_pose_detections=max_pose_detections, min_pose_score=self.min_score) keypoint_coords *= image_scale return pose_scores, keypoint_scores, keypoint_coords
def main(): model = posenet.load_model(args.model) model = model.cuda() output_stride = model.output_stride cap = cv2.VideoCapture( "rtsp://*****:*****@192.168.15.220:554/Streaming/channels/402") cap.set(3, args.cam_width) cap.set(4, args.cam_height) start = time.time() frame_count = 0 while True: input_image, display_image, output_scale = posenet.read_cap( cap, scale_factor=args.scale_factor, output_stride=output_stride) with torch.no_grad(): input_image = torch.Tensor(input_image).cuda() heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = model( input_image) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(0), offsets_result.squeeze(0), displacement_fwd_result.squeeze(0), displacement_bwd_result.squeeze(0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.15) keypoint_coords *= output_scale # TODO this isn't particularly fast, use GL for drawing and display someday... overlay_image = posenet.draw_skel_and_kp(display_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.15, min_part_score=0.1) cv2.imshow('posenet', overlay_image) frame_count += 1 if cv2.waitKey(1) & 0xFF == ord('q'): break print('Average FPS: ', frame_count / (time.time() - start))
def main(): with tf.Session() as sess: model_cfg, model_outputs = posenet.load_model(args.model, sess) output_stride = model_cfg['output_stride'] cap = cv2.VideoCapture(args.cam_id) cap.set(3, args.cam_width) cap.set(4, args.cam_height) start = time.time() frame_count = 0 while True: input_image, display_image, output_scale = posenet.read_cap( cap, scale_factor=args.scale_factor, output_stride=output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image}) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.15) keypoint_coords *= output_scale # TODO this isn't particularly fast, use GL for drawing and display someday... overlay_image = posenet.draw_skel_and_kp(display_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.15, min_part_score=0.1) cv2.imshow('posenet', overlay_image) frame_count += 1 if cv2.waitKey(1) & 0xFF == ord('q'): break print('Average FPS: ', frame_count / (time.time() - start))
def compute(b64): input_image, draw_image, output_scale = posenet.utils._process_input( readb64(b64), scale_factor=args.scale_factor, output_stride=output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image}) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=1, min_pose_score=0.25) keypoint_coords *= output_scale rets = {} if not args.notxt: print() print("Results for image") for pi in range(len(pose_scores)): if pose_scores[pi] == 0.: break print('Pose #%d, score = %f' % (pi, pose_scores[pi])) for ki, (s, c) in enumerate( zip(keypoint_scores[pi, :], keypoint_coords[pi, :, :])): print('Keypoint %s, score = %f, coord = %s' % (posenet.PART_NAMES[ki], s, c)) rets[posenet.PART_NAMES[ki]] = { 'score': s, 'coords': c.tolist() } return json.dumps(rets) #print('Average FPS:', len(filenames) / (time.time() - start)) #compute(open("test.txt").read())
def return_keypoints(img): """ Take in a PIL image. Convert to a cv2 image, pass into the model, return keypoints for shoulders and hips. """ # Convert PIL image to cv2 image pil_image = img.convert('RGB') opencv_image = np.array(pil_image) opencv_image = opencv_image[:, :, ::-1].copy() # Open TensorFlow session with tf.Session() as sess: model_cfg, model_outputs = posenet.load_model(101, sess) output_stride = model_cfg['output_stride'] input_image, draw_image, output_scale = posenet.process_input(opencv_image) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image} ) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.25) keypoint_coords *= output_scale # print(keypoint_scores[0, :]) # print(keypoint_coords[0, :, :]) scores_and_coords = {} keypoint_nums = [5, 6, 11, 12] for ki, (s, c) in enumerate(zip(keypoint_scores[0, keypoint_nums], keypoint_coords[0, keypoint_nums, :])): # print('Keypoint %s, score = %f, coord = %s' % (posenet.PART_NAMES[keypoint_nums[ki]], s, c)) scores_and_coords[posenet.PART_NAMES[keypoint_nums[ki]]] = c return scores_and_coords
def get_pose(image_path): #try: with tf.Session() as sess: model_cfg, model_outputs = posenet.load_model(101, sess) output_stride = model_cfg['output_stride'] start = time.time() input_image, draw_image, output_scale = posenet.read_imgfile( image_path, scale_factor=1, output_stride=output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_outputs, feed_dict={'image:0': input_image}) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.25) keypoint_coords *= output_scale print() print("Results for image: %s" % 'image_path') count = 0 for pi in range(len(pose_scores)): if pose_scores[pi] == 0.: break count = count + 1 return count # except Exception as e: ## error = True # error_message = str(e) #except ValueError as e: # print("\n", image_path, e) # error = True # error_message = str(e) return None
def get_2d_pose_torch(input_image, output_stride, model): with torch.no_grad(): input_image = torch.Tensor(input_image).cuda() heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = model( input_image) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(0), offsets_result.squeeze(0), displacement_fwd_result.squeeze(0), displacement_bwd_result.squeeze(0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.15) #keypoint_coords *= output_scale joint2 = np.zeros(keypoint_coords[0].shape) joint2[:, 0] = keypoint_coords[0][:, 1].copy() joint2[:, 1] = keypoint_coords[0][:, 0].copy() return joint2
def predict_2d_joints(filename, min_pose_score=0.5, min_part_score=0.1): # 读取图像文件 input_image, skeleton_2d_image, output_scale = posenet.read_imgfile( filename, scale_factor=args.scale_factor, output_stride=output_stride) # 检测热图offset start_time = time.time() with torch.no_grad(): # noinspection PyArgumentList input_image = torch.Tensor(input_image).to(device) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = model( input_image) # 检测坐标点 pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=10, min_pose_score=min_pose_score) keypoint_coords *= output_scale global predictor_2d_time predictor_2d_time += time.time() - start_time # 显示结果 skeleton_2d_image = posenet.draw_skel_and_kp(skeleton_2d_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=min_pose_score, min_part_score=min_part_score) skeleton_2d_image = cv2.cvtColor(skeleton_2d_image, cv2.COLOR_BGR2RGB) # 交换xy在数组中的位置 coords_2d = np.zeros_like(keypoint_coords) coords_2d[:, :, 0], coords_2d[:, :, 1] = keypoint_coords[:, :, 1], keypoint_coords[:, :, 0] return skeleton_2d_image, coords_2d
def predict_posenet(): output_stride = 16 scale_factor = 0.7125 data = {"success": False} r = flask.request if r.method == "POST": if r.data: nparr = np.fromstring(r.data, np.uint8) img = cv2.imdecode(nparr, cv2.IMREAD_COLOR) input_image, display_image, output_scale = prepare_image_posenet( img, scale_factor=scale_factor, output_stride=output_stride) heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = sess.run( model_posenet['model_outputs'], feed_dict={'image:0': input_image}) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(axis=0), offsets_result.squeeze(axis=0), displacement_fwd_result.squeeze(axis=0), displacement_bwd_result.squeeze(axis=0), output_stride=output_stride, max_pose_detections=5, min_pose_score=0.15 ) keypoint_coords *= output_scale data["pose_scores"] = pose_scores.tolist() data["keypoint_scores"] = keypoint_scores.tolist() data["keypoint_coords"] = keypoint_coords.tolist() #data["predictions"] = postprocess_posenet_ouput(pose_scores, keypoint_scores, keypoint_coords) data["success"] = True #print(data) return flask.jsonify(data)
def main(): model = posenet.load_model(args.model) #model = model.cuda() output_stride = model.output_stride if args.output_dir: if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) filenames = [ f.path for f in os.scandir(args.image_dir) if f.is_file() and f.path.endswith(('.png', '.jpg', '.jpeg')) ] start = time.time() for f in filenames: input_image, draw_image, output_scale = posenet.read_imgfile( f, scale_factor=args.scale_factor, output_stride=output_stride) with torch.no_grad(): input_image = torch.Tensor(input_image) #.cuda() heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = model( input_image) pose_scores, keypoint_scores, keypoint_coords = posenet.decode_multiple_poses( heatmaps_result.squeeze(0), offsets_result.squeeze(0), displacement_fwd_result.squeeze(0), displacement_bwd_result.squeeze(0), output_stride=output_stride, max_pose_detections=10, min_pose_score=0.20) keypoint_coords *= output_scale if args.output_dir: draw_image = posenet.draw_skel_and_kp(draw_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.20, min_part_score=0.20) cv2.imwrite( os.path.join(args.output_dir, os.path.relpath(f, args.image_dir)), draw_image) if not args.notxt: print() datos_pose_imagen = dict() datos_pose_imagen['image'] = f print("Results for image: %s" % datos_pose_imagen['image']) for pi in range(len(pose_scores)): if pose_scores[pi] == 0.: break print('Pose #%d, score = %f' % (pi, pose_scores[pi])) puntos = dict() listado_puntos_pose = list() for ki, (s, coordenadas) in enumerate( zip(keypoint_scores[pi, :], keypoint_coords[pi, :, :])): key_point_pose = dict() key_point_pose["part"] = posenet.PART_NAMES[ki] key_point_pose["score"] = s position = dict() position['x'] = coordenadas[0] position['y'] = coordenadas[1] key_point_pose["position"] = position listado_puntos_pose.append(key_point_pose) #print('Keypoint %s, score = %f, coord = %s' % (posenet.PART_NAMES[ki], s, coordenadas)) puntos["keypoints"] = listado_puntos_pose puntos["score"] = pose_scores[pi] datos_pose_imagen[str(pi)] = puntos nameFile = "." + os.path.join( args.output_dir, os.path.relpath( f, args.image_dir)).split(".")[1] + ".json" with open(nameFile, 'w', encoding='utf-8') as outfile: json.dump(datos_pose_imagen, outfile, ensure_ascii=False, indent=4) print('Average FPS:', len(filenames) / (time.time() - start))