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