def write_image(self, filenames): for f in filenames: input_image, draw_image, output_scale = posenet.read_imgfile( f, scale_factor=self.scale_factor, output_stride=self.output_stride) print("Pose_ID:", self.pose_dance(input_image, output_scale))
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 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 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 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 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_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(): 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 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 annotate_pose(img_path, out_img_path): model_cfg, model_outputs, sess = load_model() output_stride = model_cfg['output_stride'] # read image input_image, draw_image, output_scale = posenet.read_imgfile( img_path, scale_factor=POSENET_SCALE_FACTOR, output_stride=output_stride ) # extract pose features pose_scores, keypoint_scores, keypoint_coords = extract_pose(img_path) # annotate pose features onto image 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) # write image to path cv2.imwrite(out_img_path, draw_image)
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_parts_dict(self, image_filepath): with tf.Session() as sess: model_cfg, model_outputs = posenet.load_model(101, sess) output_stride = model_cfg["output_stride"] scale_factor = 0.7125 input_image, display_image, output_scale = posenet.read_imgfile( image_filepath, scale_factor=scale_factor, output_stride=output_stride) _, parts_dict = image_utils.process_frame( sess, model_outputs, output_stride, input_image, display_image, output_scale, MAX_POSE_DETECTIONS, MIN_POSE_SCORE, MIN_PART_SCORE, ) return parts_dict
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 main(): test_total_class = list() # 미리 학습한 모델을 불러와 스켈레톤 벡터 추출 준비(PoseNet) posenet_model = posenet.load_model(args.model) posenet_model = posenet_model.cuda() output_stride = posenet_model.output_stride # 비디오를 이미지로 변환 video_filenames = [ v.path for v in os.scandir(args.video_dir) if v.is_file() and v.path.endswith(('.mp4')) ] if args.image_dir: if not os.path.exists(args.image_dir): os.makedirs(args.image_dir) for iv, v in enumerate(video_filenames): if not os.path.exists(args.image_dir + '/' + v[10:-4] + '/'): os.makedirs(args.image_dir + '/' + v[10:-4] + '/') video2frame(v, args.image_dir + '/' + v[10:-4] + '/') if args.output_dir: if not os.path.exists(args.output_dir + '/' + v[10:-4] + '/'): os.makedirs(args.output_dir + '/' + v[10:-4] + '/') # 비디오에서 추출된 이미지를 통한 스켈레톤 벡터 추출 시작 for iv, v in enumerate(video_filenames): filenames = [ f.path for f in os.scandir(args.image_dir + '/' + v[10:-4] + '/') if f.is_file() and f.path.endswith(('.png', '.jpg')) ] for i, f in enumerate(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() # PoseNet을 통해 벡터 추출 heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = posenet_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: max_score = 0 max_index = 0 ignore = 0 for pi in range(len(pose_scores)): if max_score > pose_scores[pi]: max_index = pi if pose_scores[pi] == 0.: ignore = 1 break # Posenet을 통해 추출한 스켈레톤 벡터를 가지고 Hand Craft Feature 계산 if pose_scores[max_index] != 0.: tmp_data = dict() out_data = dict(image_name=[f[10:-4]]) for ki, (s, c) in enumerate( zip(keypoint_scores[max_index, :], keypoint_coords[max_index, :, :])): tmp_data[posenet.PART_NAMES[ki]] = c.tolist() out_data['feature_1'] = xy_to_feature_1( tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftHip'], tmp_data['rightHip']) out_data['feature_2'] = xy_to_feature_2( tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftElbow'], tmp_data['rightElbow']) out_data['feature_3'] = xy_to_feature_3( tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftKnee'], tmp_data['rightKnee']) out_data['feature_4'] = xy_to_feature_4( tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftShoulder'], tmp_data['rightShoulder']) out_data['feature_5'] = xy_to_feature_5( tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftElbow'], tmp_data['rightElbow'], tmp_data['leftWrist'], tmp_data['rightWrist']) out_data['feature_6'] = xy_to_feature_6( tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftKnee'], tmp_data['rightKnee'], tmp_data['leftAnkle'], tmp_data['rightAnkle']) out_data['total_feature'] = list() out_data['total_feature'].extend([out_data['feature_1']]) out_data['total_feature'].extend([out_data['feature_2']]) out_data['total_feature'].extend([out_data['feature_3']]) out_data['total_feature'].extend([out_data['feature_4']]) out_data['total_feature'].extend( [out_data['feature_5'][0]]) out_data['total_feature'].extend( [out_data['feature_5'][1]]) out_data['total_feature'].extend( [out_data['feature_6'][0]]) out_data['total_feature'].extend( [out_data['feature_6'][1]]) test_total_class.append(out_data['total_feature']) if len(test_total_class) is 150: break ############################################################################ # 해당 코드는 첫번째 버전으로 Classification으로 춤을 검색함 ############################################################################ class_cnt = 20 test_total_class = np.array(test_total_class) test_total_class = test_total_class.reshape(150, 1, 8) x_test_data = torch.from_numpy(test_total_class[:, :class_cnt, :]) # 스켈레톤 벡터를 BLSTM을 통해 새로운 피처로 기술(이때도 사전에 학습한 pretrained weight를 사용한다.) base_BLSTM_model = LSTM(8, 32, batch_size=1, output_dim=class_cnt, num_layers=2) base_BLSTM_model.load_state_dict(torch.load( './models/checkpoints/chekcpoint_20200523_best_top3_total.pth'), strict=True) y_test_pred, _ = base_BLSTM_model(x_test_data) # topk에 결과 출력(Classificication) _, test_label = torch.topk(y_test_pred, 3) print(test_label)
def main(): model = posenet.load_model(args.model) model = model.cuda() output_stride = model.output_stride video_filenames = [v.path for v in os.scandir(args.video_dir) if v.is_file() and v.path.endswith(('.mp4'))] if args.image_dir: if not os.path.exists(args.image_dir): os.makedirs(args.image_dir) for iv,v in enumerate(video_filenames): if not os.path.exists(args.image_dir+'/'+v[11:-4]+'/'): os.makedirs(args.image_dir+'/'+v[11:-4]+'/') video2frame(v,args.image_dir+'/'+v[11:-4]+'/') if args.output_dir: if not os.path.exists(args.output_dir+'/'+v[11:-4]+'/'): os.makedirs(args.output_dir+'/'+v[11:-4]+'/') for iv,v in enumerate(video_filenames): filenames = [f.path for f in os.scandir(args.image_dir+'/'+v[11:-4]+'/') if f.is_file() and f.path.endswith(('.png', '.jpg'))] start = time.time() for i,f in enumerate(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) max_score = 0 max_index = 0 ignore = 0 for pi in range(len(pose_scores)): if max_score > pose_scores[pi] : max_index = pi if pose_scores[pi] == 0.: ignore = 1 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)) if pose_scores[max_index] != 0. : tmp_data = dict() out_data = dict(image_name=[f[10:-4]]) for ki, (s, c) in enumerate(zip(keypoint_scores[max_index, :], keypoint_coords[max_index, :, :])): tmp_data[posenet.PART_NAMES[ki]] = c.tolist() out_data['feature_1'] = xy_to_feature_1(tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftHip'], tmp_data['rightHip']) out_data['feature_2'] = xy_to_feature_2(tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftElbow'], tmp_data['rightElbow']) out_data['feature_3'] = xy_to_feature_3(tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftKnee'], tmp_data['rightKnee']) out_data['feature_4'] = xy_to_feature_4(tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftShoulder'], tmp_data['rightShoulder']) out_data['feature_5'] = xy_to_feature_5(tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftElbow'], tmp_data['rightElbow'], tmp_data['leftWrist'], tmp_data['rightWrist']) out_data['feature_6'] = xy_to_feature_6(tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftKnee'], tmp_data['rightKnee'], tmp_data['leftAnkle'], tmp_data['rightAnkle']) out_data['total_feature'] = list() out_data['total_feature'].extend([out_data['feature_1']]) out_data['total_feature'].extend([out_data['feature_2']]) out_data['total_feature'].extend([out_data['feature_3']]) out_data['total_feature'].extend([out_data['feature_4']]) out_data['total_feature'].extend([out_data['feature_5'][0]]) out_data['total_feature'].extend([out_data['feature_5'][1]]) out_data['total_feature'].extend([out_data['feature_6'][0]]) out_data['total_feature'].extend([out_data['feature_6'][1]]) out_data['skeleton_vector'] = tmp_data with open(os.path.join(args.output_dir,f[10:-4]+".json"),"w") as json_file : json.dump(out_data, json_file, indent="\t") print('Average FPS:', len(filenames) / (time.time() - start))
def main(): test_total_class = list() posenet_model = posenet.load_model(args.model) posenet_model = posenet_model.cuda() output_stride = posenet_model.output_stride video_filenames = [ v.path for v in os.scandir(args.video_dir) if v.is_file() and v.path.endswith(('.mp4')) ] if args.image_dir: if not os.path.exists(args.image_dir): os.makedirs(args.image_dir) for iv, v in enumerate(video_filenames): if not os.path.exists(args.image_dir + '/' + v[10:-4] + '/'): os.makedirs(args.image_dir + '/' + v[10:-4] + '/') video2frame(v, args.image_dir + '/' + v[10:-4] + '/') if args.output_dir: if not os.path.exists(args.output_dir + '/' + v[11:-4] + '/'): os.makedirs(args.output_dir + '/' + v[11:-4] + '/') for iv, v in enumerate(video_filenames): filenames = [ f.path for f in os.scandir(args.image_dir + '/' + v[11:-4] + '/') if f.is_file() and f.path.endswith(('.png', '.jpg')) ] for i, f in enumerate(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 = posenet_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: max_score = 0 max_index = 0 ignore = 0 for pi in range(len(pose_scores)): if max_score > pose_scores[pi]: max_index = pi if pose_scores[pi] == 0.: ignore = 1 break if pose_scores[max_index] != 0.: tmp_data = dict() out_data = dict(image_name=[f[10:-4]]) for ki, (s, c) in enumerate( zip(keypoint_scores[max_index, :], keypoint_coords[max_index, :, :])): tmp_data[posenet.PART_NAMES[ki]] = c.tolist() out_data['feature_1'] = xy_to_feature_1( tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftHip'], tmp_data['rightHip']) out_data['feature_2'] = xy_to_feature_2( tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftElbow'], tmp_data['rightElbow']) out_data['feature_3'] = xy_to_feature_3( tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftKnee'], tmp_data['rightKnee']) out_data['feature_4'] = xy_to_feature_4( tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftShoulder'], tmp_data['rightShoulder']) out_data['feature_5'] = xy_to_feature_5( tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftElbow'], tmp_data['rightElbow'], tmp_data['leftWrist'], tmp_data['rightWrist']) out_data['feature_6'] = xy_to_feature_6( tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftKnee'], tmp_data['rightKnee'], tmp_data['leftAnkle'], tmp_data['rightAnkle']) out_data['total_feature'] = list() out_data['total_feature'].extend([out_data['feature_1']]) out_data['total_feature'].extend([out_data['feature_2']]) out_data['total_feature'].extend([out_data['feature_3']]) out_data['total_feature'].extend([out_data['feature_4']]) out_data['total_feature'].extend( [out_data['feature_5'][0]]) out_data['total_feature'].extend( [out_data['feature_5'][1]]) out_data['total_feature'].extend( [out_data['feature_6'][0]]) out_data['total_feature'].extend( [out_data['feature_6'][1]]) test_total_class.append(out_data['total_feature']) if len(test_total_class) is 150: break ################## 여기서부터는 유사도 검색 base_feature = np.load( '/content/drive/My Drive/Colab Notebooks/Train_for_pca_DIY') base_feature_label = np.load( '/content/drive/My Drive/Colab Notebooks/Train_label_for_pca_DIY') class_cnt = 20 test_total_class = np.array(test_total_class) test_total_class = test_total_class.reshape(150, 1, 8) x_test_data = torch.from_numpy(test_total_class) back_bone_model = LSTM(8, 32, batch_size=1, output_dim=class_cnt, num_layers=2) net_vlad = NetVLAD(num_clusters=40, dim=64, alpha=1.0) vlad_model = EmbedNet(back_bone_model, net_vlad) vlad_model.load_state_dict(torch.load( '/content/drive/My Drive/Colab Notebooks/VLAD_Checkpoint_20200609_Best_DIY_total.pth' ), strict=True) test_out_feature = vlad_model(x_test_data) test_out_feature = np.array(test_out_feature) test_out_feature = test_out_feature.reshape(-1, 2560) pca = PCA(n_components=2) X_Train_pca = pca.fit_transform(base_feature) X_test_pca = pca.transform(test_out_feature) check = np.concatenate((X_Train_pca, X_test_pca), axis=0) pairwise_dist_t = _pairwise_distances(torch.from_numpy(check)) pairwise_dist_t = pairwise_dist_t.cpu().detach().numpy() pairwise_dist_sort = np.sort(pairwise_dist_t[-1][:-1]) final_out_bef = list() final_out = list() final_score = list() for i in range(len(pairwise_dist_t)): if pairwise_dist_sort[0] == pairwise_dist_t[-1][i]: final_out_bef.append(i) score = 100 - (500 * pairwise_dist_sort[0]) if score < 0: final_score.append(0) else: final_score.append(score) break for i in range(len(pairwise_dist_t)): if pairwise_dist_sort[1] == pairwise_dist_t[-1][i]: final_out_bef.append(i) score = 100 - (500 * pairwise_dist_sort[1]) if score < 0: final_score.append(0) else: final_score.append(score) break for i in range(len(pairwise_dist_t)): if pairwise_dist_sort[2] == pairwise_dist_t[-1][i]: final_out_bef.append(i) score = 100 - (500 * pairwise_dist_sort[2]) if score < 0: final_score.append(0) else: final_score.append(score) break final_out.append(base_feature_label[final_out[0]]) final_out.append(base_feature_label[final_out[1]]) final_out.append(base_feature_label[final_out[2]]) print(final_out) print(final_score)
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() output_data = [] 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) score = pose_scores[0] kp = keypoint_scores[0] splitted = [] for kc in keypoint_coords[0]: splitted.append(kc[0]) splitted.append(kc[1]) output_data.append([score, *kp, *splitted]) with open('output.csv', 'w') as f: writer = csv.writer(f) for row in output_data: writer.writerow(row) print('csv created') # 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) # # try on white background... # #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 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))
def main(): print("What side of your body are you filming? r/l") side = input() if side == "l": side = True #filming the left side else: side = False #filming the right side 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')) ] 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 not args.notxt: print("Results for image: %s" % f) #manual scores manual_keypoint_scores = [[]] manual_keypoint_coords = [[]] for pi in range(len(pose_scores)): if pose_scores[pi] == 0.: break print('Score = %f' % (pose_scores[pi])) manual_pose_score = [pose_scores[pi]] #ki is keypoint index, s = score, c = coord 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)) if side == True: if (posenet.PART_NAMES[ki] == "leftEye"): Leye = (posenet.PART_NAMES[ki], s, c) print( 'Collected by scrapper Keypoint %s, score = %f, coord = %s' % Leye) elif (posenet.PART_NAMES[ki] == "leftShoulder"): Lshoulder = (posenet.PART_NAMES[ki], s, c) print( 'Collected by scrapper Keypoint %s, score = %f, coord = %s' % Lshoulder) elif (posenet.PART_NAMES[ki] == "leftHip"): Lhip = (posenet.PART_NAMES[ki], s, c) print( 'Collected by scrapper Keypoint %s, score = %f, coord = %s' % Lhip) elif (posenet.PART_NAMES[ki] == "leftKnee"): Lknee = (posenet.PART_NAMES[ki], s, c) print( 'Collected by scrapper Keypoint %s, score = %f, coord = %s' % Lknee) elif (posenet.PART_NAMES[ki] == "leftAnkle"): Lankle = (posenet.PART_NAMES[ki], s, c) print( 'Collected by scrapper Keypoint %s, score = %f, coord = %s' % Lankle) elif side == False: if (posenet.PART_NAMES[ki] == "rightEye"): Reye = (posenet.PART_NAMES[ki], s, c) Reye_score = s.tolist() Reye_coord = c.tolist() manual_keypoint_scores[pi].append(Reye_score) manual_keypoint_coords[pi].append(Reye_coord) print( 'Collected by scrapper Keypoint %s, score = %f, coord = %s' % Reye) elif (posenet.PART_NAMES[ki] == "rightShoulder"): Rshoulder = (posenet.PART_NAMES[ki], s, c) Rshoulder_score = s.tolist() Rshoulder_coord = c.tolist() manual_keypoint_scores[pi].append( [Rshoulder_score]) manual_keypoint_coords[pi].append( [Rshoulder_coord]) print( 'Collected by scrapper Keypoint %s, score = %f, coord = %s' % Rshoulder) elif (posenet.PART_NAMES[ki] == "rightHip"): Rhip = (posenet.PART_NAMES[ki], s, c) Rhip_score = s.tolist() Rhip_coord = c.tolist() manual_keypoint_scores[pi].append([Rhip_score]) manual_keypoint_coords[pi].append([Rhip_coord]) print( 'Collected by scrapper Keypoint %s, score = %f, coord = %s' % Rhip) elif (posenet.PART_NAMES[ki] == "rightKnee"): Rknee = (posenet.PART_NAMES[ki], s, c) Rknee_score = s.tolist() Rknee_coord = c.tolist() print(Rknee_coord) print(Rknee_score) manual_keypoint_scores[pi].append([Rknee_score]) manual_keypoint_coords[pi].append([Rknee_coord]) print( 'Collected by scrapper Keypoint %s, score = %f, coord = %s' % Rknee) elif (posenet.PART_NAMES[ki] == "rightAnkle"): Rankle = (posenet.PART_NAMES[ki], s, c) Rankle_score = s.tolist() Rankle_coord = c.tolist() manual_keypoint_scores[pi].append([Rankle_score]) manual_keypoint_coords[pi].append([Rankle_coord]) print( 'Collected by scrapper Keypoint %s, score = %f, coord = %s' % Rankle) print(manual_keypoint_coords) print(manual_keypoint_scores) print(keypoint_coords) print(keypoint_scores) 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)
def getpoints(image_input, flag, model_black_image): with tf.Session() as sess: model_cfg, model_outputs = posenet.load_model(101, sess) output_stride = model_cfg['output_stride'] pos_temp_data = [] sum = 0 input_image, draw_image, output_scale = posenet.read_imgfile( image_input, scale_factor=1.0, 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 draw_image = posenet.draw_skel_and_kp(flag, draw_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.1, min_part_score=0.0001) black_image = numpy.zeros( (draw_image.shape[0], draw_image.shape[1], 3), dtype='uint8') if flag == 1: black_image = posenet.draw_skel_and_kp(flag, black_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.1, min_part_score=0.0001) if flag == 0: black_image = posenet.draw_skel_and_kp(flag, model_black_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.1, min_part_score=0.0001) 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, draw_image, black_image
def posenet_predict(self, filename, base_out_image=None, hidden_depth=None): input_image, draw_image, output_scale = posenet.read_imgfile( filename, scale_factor=args.scale_factor, output_stride=self.output_stride) with torch.no_grad(): if self.use_cuda: input_image = torch.Tensor(input_image).cuda() else: input_image = torch.Tensor(input_image).cpu() heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result = self.posenet_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.25) keypoint_coords *= output_scale if self.save_visualisations: base_out_image = draw_image if base_out_image is None else base_out_image kp_labels, clusters_interpersonali, persone_vicine = self.find_near_keypoints( keypoint_coords, hidden_depth) id_persone_vicine = [] for p in persone_vicine: if p[0] not in id_persone_vicine: id_persone_vicine.append(p[0]) if p[1] not in id_persone_vicine: id_persone_vicine.append(p[1]) num_persone_vicine = len(id_persone_vicine) print("Ci sono %d persone vicine: %s" % (num_persone_vicine, persone_vicine)) draw_image = posenet.draw_skel_and_kp(base_out_image, pose_scores, keypoint_scores, keypoint_coords, kp_labels, clusters_interpersonali, min_pose_score=0.25, min_part_score=0.25) if base_out_image is None: vis_save_path = os.path.join( self.save_dir, "visualisations", "posenet_ " + os.path.basename(filename) + '.jpg') cv2.imwrite(vis_save_path, draw_image) print("Image saved to", vis_save_path) if self.more_output: print() print("Results for image: %s" % filename) 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)) return draw_image, num_persone_vicine
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() with open('thesavedones.csv', 'w') as csvfile: filewriter = csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL) 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) for pi in range(len(pose_scores)): if pose_scores[ pi] == 0.: # breaks loop if no pose is found in image I think 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)) #Create file with keypoint coordinates saved here filewriter.writerow([ 'Image %s' % f, 'Pose #%d' % (pi), 'Keypoint %s' % (posenet.PART_NAMES[ki]), c ]) print('Average FPS:', len(filenames) / (time.time() - start))
def main(): model = posenet.load_model(args.model) model = model.to(DEVICE).eval() 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")) ] if args.use_tvm: import tvm from tvm.contrib import graph_runtime with open(args.tvm_graph) as f: tvm_graph = f.read() tvm_lib = tvm.runtime.load_module(args.tvm_lib) with open(args.tvm_params, "rb") as f: tvm_params = bytearray(f.read()) ctx = tvm.cpu() module = graph_runtime.create(tvm_graph, tvm_lib, ctx) module.load_params(tvm_params) preprocessing_time = [] inference_time = [] processing_time = [] for filename in tqdm(filenames, desc="Processed", unit="files"): start = now() input_image, draw_image, output_scale = posenet.read_imgfile( filename, scale_factor=args.scale_factor, output_stride=output_stride, resize=(args.processing_height, args.processing_width) if args.resize else None, ) preprocessing_time.append(now() - start) start = now() with torch.no_grad(): if args.use_tvm: input_data = tvm.nd.array(input_image) module.run(**{args.input_name: input_data}) out = [] for idx in range(module.get_num_outputs()): res = ( torch.Tensor(module.get_output(idx).asnumpy()) .squeeze(0) .to(DEVICE) ) out.append(res) else: input_image = torch.Tensor(input_image).to(DEVICE) out = [] for idx, res in enumerate(model(input_image)): out.append(res.squeeze(0)) inference_time.append(now() - start) ( heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result, ) = out start = now() if args.decoder == "multi": ( pose_scores, keypoint_scores, keypoint_coords, ) = posenet.decode_multiple_poses( heatmaps_result, offsets_result, displacement_fwd_result, displacement_bwd_result, output_stride, max_pose_detections=10, min_pose_score=0.25, ) elif args.decoder == "single": (keypoints, pose_score, keypoint_scores) = posenet.decode_single_pose( heatmaps_result, offsets_result, output_stride ) pose_scores = np.asarray([pose_score]) keypoint_scores = np.asarray([keypoint_scores]) keypoint_coords = np.asarray([keypoints]) else: raise NotImplementedError( "The decoder {} is not implemented.".format(args.decoder) ) processing_time.append(now() - start) 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(filename, args.image_dir) ), draw_image, ) if args.save_keypoints: with open( os.path.join( args.output_dir, os.path.relpath(filename, args.image_dir) + ".npy", ), "wb", ) as outfile: np.save( outfile, list(zip(pose_scores, keypoint_scores, keypoint_coords)), ) if args.verbose: print("Results for image: %s" % filename) for point_idx in range(len(pose_scores)): if pose_scores[point_idx] == 0.0: break print("Pose #%d, score = %f" % (point_idx, pose_scores[point_idx])) for keypoint_idx, (score, coord) in enumerate( zip(keypoint_scores[point_idx, :], keypoint_coords[point_idx, :, :]) ): print( "Keypoint %s, score = %f, coord = %s" % (posenet.PART_NAMES[keypoint_idx], score, coord) ) avg_preprocessing_time = np.mean(preprocessing_time) avg_postprocessing_time = np.mean(processing_time) avg_inference_time = np.mean(inference_time) print("=" * 80) print( "Decoder: {}, TVM Runtime: {}, Resize to {}x{} HxW: {}".format( args.decoder, "enabled" if args.use_tvm else "disabled", args.processing_height, args.processing_width, "enabled" if args.resize else "disabled", ) ) print("-" * 80) print("Average pre-processing FPS: {:.2f}".format(1 / avg_preprocessing_time)) print("Average inference FPS: {:.2f}".format(1 / avg_inference_time)) print("Average post-processing FPS: {:.2f}".format(1 / avg_postprocessing_time)) print( "Average FPS: {:.2f}".format( 1 / (avg_postprocessing_time + avg_inference_time + avg_preprocessing_time) ) )
def main(): with tf.Session() as sess: if os.path.exists('imagedemo.csv'): os.remove('imagedemo.csv') with open('imagedemo.csv', mode='w') as csvfile: writer = csv.DictWriter(csvfile, fieldnames=HEADER) writer.writeheader() 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) with open("imagedemo.csv", mode="a+", newline="") as csvfile: writer = csv.DictWriter(csvfile, fieldnames=HEADER) for pi in range(len(pose_scores)): if pose_scores[pi] == 0.: continue print('Pose #%d, score = %f' % (pi, pose_scores[pi])) for ki, (s, c) in enumerate( zip(keypoint_scores[pi, :], keypoint_coords[pi, :, :])): writer.writerow({ 'filename': f, 'Pose': pi, 'ki': ki, 'Keypoint': posenet.PART_NAMES[ki], 'coordinates': c, 'score': s }) print('Keypoint %s, score = %f, coordinates = %s' % (posenet.PART_NAMES[ki], s, c)) # 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, coordinates = %s' % (posenet.PART_NAMES[ki], s, c)) print('Average FPS:', len(filenames) / (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.file is not None: cap = cv2.VideoCapture(args.file) else: cap = cv2.VideoCapture(args.cam_id) cap.set(3, args.cam_width) cap.set(4, args.cam_height) video_dict = np.load('../atharva_old/stair_name_dict.npy',allow_pickle=True).item() frame_list = [] path_list = [] for video_name in video_dict: k = video_name[-12:-2] # video_path = '.' + video_name[:-1] video_path = '../atharva_old/' + video_name[2:-1] for j in range(video_dict[video_name]): path_list.append(video_path + str(j) + '.png') # print(video_path + str(j)) break # remove this for labelling # print(path_list) frame_c = 0 frame_n = len(path_list) # hasFrame, frame = cap.read() ret,frame = img_read(path_list,frame_c) frame_c += 1 if not ret: print('no frame') print(path_list[frame_c]) exit() # print(frame.shape) start = time.time() frame_count = 0 prvs = cv2.resize(frame,(224,224)) prvs = cv2.cvtColor(prvs,cv2.COLOR_BGR2GRAY) hsv = np.zeros((224,224,3),dtype=np.uint8) hsv[...,1] = 255 #intensity c = 0 while True: c += 1 flag = 0 t = time.time() # hasFrame, frame = cap.read() ret,frame = img_read(path_list,frame_c) frame_c += 1 if not ret: print('no frame') break next = cv2.resize(frame,(224,224)) # print(next.shape) next = cv2.cvtColor(next,cv2.COLOR_BGR2GRAY) prvs = cv2.medianBlur(prvs,5) next = cv2.medianBlur(next,5) # print(prvs.shape,next.shape) flow = cv2.calcOpticalFlowFarneback(prvs,next, None, 0.5,3,7,4,7,5, 0) mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1]) mag = (mag>1.4)*mag hsv[...,0] = ang*180/np.pi/2 #hue, colour hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX) #brightness up_mask = make_mask(hsv[...,0],125,150) #purple down_mask = make_mask(hsv[...,0],35,75) #green left_mask = make_mask(hsv[...,0],165,179) | make_mask(hsv[...,0],0,30)#red right_mask = make_mask(hsv[...,0],75,105) #blue hsv_up = apply_mask(hsv,up_mask) hsv_down = apply_mask(hsv,down_mask) hsv_left = apply_mask(hsv,left_mask) hsv_right = apply_mask(hsv,right_mask) #input_image, display_image, output_scale = posenet.read_cap( # cap, scale_factor=args.scale_factor, output_stride=output_stride) f= path_list[frame_c] 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_multi.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 #what the hell is this #for i in range(len(pose_scores)): for pts in keypoint_coords: dist1 = [0] dist2 = [0] if int(pts[9,0]) >0 and int(pts[9,0]) < 140 and int(pts[9,1]) >0 and int(pts[9,1]) < 140: cv2.circle(draw_image,(int(pts[9,1]),int(pts[9,0])-20), 20, (0,255,0), 2) cv2.circle(draw_image,(int(pts[9,1]),int(pts[9,0])+30), 20, (0,255,0), 2) if int(pts[10,0]) >0 and int(pts[10,0]) < 140 and int(pts[10,1]) >0 and int(pts[10,1]) < 140: cv2.circle(draw_image,(int(pts[10,1]),int(pts[10,0])-20), 20, (0,255,0), 2) cv2.circle(draw_image,(int(pts[10,1]),int(pts[10,0])+30), 20, (0,255,0), 2) valid_pts = 0 # print(pts.shape) for i in range(len(mag)): for j in range(len(mag[0])): if mag[j,i]>0: if (isInsideC(int(pts[9,1]),int(pts[9,0])-20,20,j,i) or isInsideC(int(pts[9,1]),int(pts[9,0])+30,20,j,i)) and (int(pts[9,0]) >0 and int(pts[9,0]) < 140 and int(pts[9,1]) >0 and int(pts[9,1]) < 140): valid_pts+=1 if (isInsideC(int(pts[10,1]),int(pts[10,0])-20,20,j,i) or isInsideC(int(pts[10,1]),int(pts[10,0])+30,20,j,i)) and (int(pts[10,0]) >0 and int(pts[10,0]) < 140 and int(pts[10,1]) >0 and int(pts[10,1]) < 140): valid_pts+=1 # pass # dist1.append(dist_from_line(j,i,pts[7,:],pts[9,:])) # left hand # dist2.append(dist_from_line(j,i,pts[8,:],pts[10,:]))# right hand # dist1.append(dist_from_pt(j,i,pts[9,:])) # left wrist # dist2.append(dist_from_pt(j,i,pts[10,:])) # right wrist # if True: thresh = 140 up_thresh = 34 down_thresh = 16 left_thresh = 24 right_thresh = 28 # if (np.mean(dist1) < thresh or np.mean(dist2)<thresh) and (np.mean(dist1) >0 and np.mean(dist2)>0): # if True: if valid_pts>100: #original # print('please print') # print(np.mean(hsv_right[...,0])) if np.mean(hsv_up[...,0])>up_thresh and np.mean(mag)>0.07: # print(np.mean(hsv_up[...,0])) print('UP',c) flag = 1 elif np.mean(hsv_down[...,0])>down_thresh and np.mean(mag)>0.07: # print(np.mean(hsv_down[...,0])) print('DOWN',c) flag = 1 elif np.mean(hsv_left[...,0])>left_thresh and np.mean(mag)>0.08: # print(np.mean(hsv_left[...,0])) print('LEFT',c) flag = 1 elif np.mean(hsv_right[...,0])>right_thresh and np.mean(mag)>0.08: # print(np.mean(hsv_right[...,0])) print('RIGHT',c) flag = 1 #modified # if np.mean(hsv_up[...,0])>38 and np.mean(mag)>0.08: # print('UP',np.mean(hsv_up[...,0])) # flag = 1 # if np.mean(hsv_down[...,0])>16.5 and np.mean(mag)>0.08: # print('DOWN',np.mean(hsv_down[...,0])) # flag = 1 # if np.mean(hsv_left[...,0])>24 and np.mean(mag)>0.08: # print('LEFT',c) # flag = 1 # if np.mean(hsv_right[...,0])>28 and np.mean(mag)>0.08: # print('RIGHT',c) # flag = 1 # TODO this isn't particularly fast, use GL for drawing and display someday... overlay_image = posenet.draw_skel_and_kp( draw_image, pose_scores, keypoint_scores, keypoint_coords, min_pose_score=0.15, min_part_score=0.1) bgr = cv2.cvtColor(hsv,cv2.COLOR_HSV2BGR) bgr = cv2.medianBlur(bgr,5) cv2.imshow('flow',bgr) cv2.imshow('posenet', overlay_image) prvs = next frame_count += 1 if cv2.waitKey(1) & 0xFF == ord('q'): exit() print('Average FPS: ', frame_count / (time.time() - start))
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 sorted(os.scandir(args.image_dir), key=lambda x: (x.is_dir(), x.name)) if f.is_file() and f.path.endswith(('.png', '.jpg')) ] keypoints_list = {} #單一frame的所有keypoints 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) p1 = None p2 = None area = 0 keypoints = [] if not args.notxt: print() print("Results for image: %s" % f) for pi in range(len(pose_scores)): if pose_scores[pi] == 0.: break index = 0 max_x = 0 max_y = 0 min_x = 9999 min_y = 9999 temp_keypoints = dict() 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)) if pi == 0: if (index > 4): keypoints.append(c.tolist()) else: index += 1 if c[0] > max_x: max_x = c[0] if c[1] > max_y: max_y = c[1] if c[0] < min_x: min_x = c[0] if c[1] < min_y: min_y = c[1] if area < (max_x - min_x) * (max_y - min_y): area = (max_x - min_x) * (max_y - min_y) keypoints_list[f[-10:-4]] = keypoints # keypoints_list['test'] = keypoints # keypoints_list[f[-10:-4]] = keypoints print('Average FPS:', len(filenames) / (time.time() - start)) result = dict() result[args.image_dir.split('/')[-1]] = keypoints_list ret = json.dumps(result) with open(args.image_dir.split('/')[-1] + '.json', 'w') as fp: fp.write(ret)
def main(): test_total_class = list() posenet_model = posenet.load_model(args.model) posenet_model = posenet_model.cuda() output_stride = posenet_model.output_stride video_filenames = [ v.path for v in os.scandir(args.video_dir) if v.is_file() and v.path.endswith(('.mp4')) ] if args.image_dir: if not os.path.exists(args.image_dir): os.makedirs(args.image_dir) for iv, v in enumerate(video_filenames): if not os.path.exists(args.image_dir + '/' + v[10:-4] + '/'): os.makedirs(args.image_dir + '/' + v[10:-4] + '/') video2frame(v, args.image_dir + '/' + v[10:-4] + '/') if args.output_dir: if not os.path.exists(args.output_dir + '/' + v[11:-4] + '/'): os.makedirs(args.output_dir + '/' + v[11:-4] + '/') for iv, v in enumerate(video_filenames): filenames = [ f.path for f in os.scandir(args.image_dir + '/' + v[11:-4] + '/') if f.is_file() and f.path.endswith(('.png', '.jpg')) ] for i, f in enumerate(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 = posenet_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: max_score = 0 max_index = 0 ignore = 0 for pi in range(len(pose_scores)): if max_score > pose_scores[pi]: max_index = pi if pose_scores[pi] == 0.: ignore = 1 break if pose_scores[max_index] != 0.: tmp_data = dict() out_data = dict(image_name=[f[10:-4]]) for ki, (s, c) in enumerate( zip(keypoint_scores[max_index, :], keypoint_coords[max_index, :, :])): tmp_data[posenet.PART_NAMES[ki]] = c.tolist() out_data['feature_1'] = xy_to_feature_1( tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftHip'], tmp_data['rightHip']) out_data['feature_2'] = xy_to_feature_2( tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftElbow'], tmp_data['rightElbow']) out_data['feature_3'] = xy_to_feature_3( tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftKnee'], tmp_data['rightKnee']) out_data['feature_4'] = xy_to_feature_4( tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftShoulder'], tmp_data['rightShoulder']) out_data['feature_5'] = xy_to_feature_5( tmp_data['leftShoulder'], tmp_data['rightShoulder'], tmp_data['leftElbow'], tmp_data['rightElbow'], tmp_data['leftWrist'], tmp_data['rightWrist']) out_data['feature_6'] = xy_to_feature_6( tmp_data['leftHip'], tmp_data['rightHip'], tmp_data['leftKnee'], tmp_data['rightKnee'], tmp_data['leftAnkle'], tmp_data['rightAnkle']) out_data['total_feature'] = list() out_data['total_feature'].extend([out_data['feature_1']]) out_data['total_feature'].extend([out_data['feature_2']]) out_data['total_feature'].extend([out_data['feature_3']]) out_data['total_feature'].extend([out_data['feature_4']]) out_data['total_feature'].extend( [out_data['feature_5'][0]]) out_data['total_feature'].extend( [out_data['feature_5'][1]]) out_data['total_feature'].extend( [out_data['feature_6'][0]]) out_data['total_feature'].extend( [out_data['feature_6'][1]]) test_total_class.append(out_data['total_feature']) if len(test_total_class) is 150: break ################## 여기서부터는 유사도 검색 class_cnt = 20 test_total_class = np.array(test_total_class) test_total_class = test_total_class.reshape(150, 1, 8) x_test_data = torch.from_numpy(test_total_class[:, :class_cnt, :]) base_BLSTM_model = LSTM(8, 32, batch_size=1, output_dim=class_cnt, num_layers=2) base_BLSTM_model.load_state_dict(torch.load( '/content/drive/My Drive/Colab Notebooks/chekcpoint_20200506_best_top3.pth' ), strict=True) y_test_pred, _ = base_BLSTM_model(x_test_data) _, test_label = torch.topk(y_te_stpred, 3) print(test_label)
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) # solo lee imagenes .png o .jpg filenames = [ f.path for f in sorted(os.scandir(args.image_dir), key=lambda e: e.name) if f.is_file() and f.path.endswith(('.png', '.jpg'))] tt = {} 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=2, min_pose_score=0.55) 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) pp = [] for pi in range(len(pose_scores)): if pose_scores[pi] <= 0.55: 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)) pp.append(keypoint_coords[pi,:,:]) if pp: ff = {f: pp} tt.update(ff) name ='./data/' + str(args.image_dir.split('/')[-1]) + '.pickle' filename = open(name, "wb") pickle.dump(tt, filename) # pickfile = open('datos.txt', 'w') # pickfile.write(str(tt)) print('Average FPS:', len(filenames) / (time.time() - start))