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))
