def __init__(self, size='432x368', model='mobilenet_thin'):
w, h = model_wh(size)
if w == 0 or h == 0:
self.e = TfPoseEstimator(get_graph_path(model), target_size=(432, 368))
else:
self.e = TfPoseEstimator(get_graph_path(model), target_size=(w, h))
self.w, self.h = w, h
def infer(image, model='cmu', resize='0x0', resize_out_ratio=4.0):
"""
:param image:
:param model:
:param resize:
:param resize_out_ratio:
:return: coco_style_keypoints array
"""
w, h = model_wh(resize)
e = get_estimator(model, resize)
# estimate human poses from a single image !
image = common.read_imgfile(image, None, None)
if image is None:
raise Exception('Image can not be read, path=%s' % image)
humans = e.inference(image, resize_to_default=(w > 0 and h > 0), upsample_size=resize_out_ratio)
image_h, image_w = image.shape[:2]
if "TERM_PROGRAM" in os.environ and 'iTerm' in os.environ["TERM_PROGRAM"]:
image = TfPoseEstimator.draw_humans(image, humans, imgcopy=False)
image_str = cv2.imencode(".jpg", image)[1].tostring()
print("\033]1337;File=name=;inline=1:" + base64.b64encode(image_str).decode("utf-8") + "\a")
return [(eval.write_coco_json(human, image_w, image_h), human.score) for human in humans]
def run_video(video, folder_name, id_value, visual=False):
print(f"Running on {folder_name} Video ID: {id_value}")
fps_time = 0
w, h = model_wh('0x0')
if w > 0 and h > 0:
e = TfPoseEstimator(get_graph_path(model),
target_size=(w, h),
trt_bool=tensorrt)
else:
e = TfPoseEstimator(get_graph_path(model),
target_size=(432, 368),
trt_bool=tensorrt)
cam = cv2.VideoCapture(video)
ret_val, image = cam.read()
while True:
ret_val, image = cam.read()
if not ret_val:
break
humans = e.inference(image,
resize_to_default=(w > 0 and h > 0),
upsample_size=resize_out_ratio)
print(humans)
image = TfPoseEstimator.draw_humans(image, humans, imgcopy=False)
cv2.putText(image, "FPS: %f" % (1.0 / (time.time() - fps_time)),
(10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.imshow('tf-pose-estimation result', image)
fps_time = time.time()
if cv2.waitKey(1) == 27:
break
cv2.destroyAllWindows()
def __init__(self, model=None, image_size=None):
if model is None:
model = "cmu"
if image_size is None:
image_size = "432x368" # 7 fps
models = set({"mobilenet_thin", "cmu"})
self.model = model if model in models else "mobilenet_thin"
self.resize_out_ratio = 4.0
w, h = model_wh(image_size)
if w == 0 or h == 0:
e = TfPoseEstimator(get_graph_path(self.model),
target_size=(432, 368),
tf_config=config)
else:
e = TfPoseEstimator(get_graph_path(self.model),
target_size=(w, h),
tf_config=config)
# self.args = args
self.w, self.h = w, h
self.e = e
self.fps_time = time.time()
self.cnt_image = 0
def detection_loop():
global outputFrame, outputArray, lock
w, h = model_wh("432x368")
e = TfPoseEstimator(get_graph_path("mobilenet_thin"), target_size=(w, h))
cam = cv2.VideoCapture(0)
cam.set(3, 1280)
cam.set(4, 720)
print("------------openpose_finished---------")
try:
for img in getframe(cam, e, w, h):
if img is not None:
with lock:
outputFrame = img
outputArray = "a"
mystr = '{"timestamp":"2020-11-16 03:14:43.430204","nodeid":"0","nodeid":"0","sensor":"image","car_count":"0"}'
mqtt_client.publish(
"{}/{}".format(args.mqtt_topic, 'car_count'),
str(mystr))
mqtt_client.publish(
"{}/{}".format(args.mqtt_topic, 'car_count'),
str(outputArray))
else:
print(
"--------------Thread_finished(ctl + C)-----------------")
except:
os._exit(1)
def makeData(self):
w, h = model_wh('432x368')
e = TfPoseEstimator(get_graph_path('mobilenet_thin'), target_size=(w, h))
i = 0
cap = cv2.VideoCapture(WEBCAM_FILE_NAME)
while cap.isOpened():
endFlag, frame = cap.read()
if endFlag == False:
break
cv2.imwrite('./results/webcam/webcamRaw/'+'img_%s.png' % str(i).zfill(6), frame)
i += 1
j = 0
path_w = './results/webcam/webcamData.txt'
with open(path_w, mode='w') as f:
f.write('')
while j < i:
image = common.read_imgfile('./results/webcam/webcamRaw/'+'img_%s.png' % str(j).zfill(6))
humans = e.inference(image, resize_to_default=True, upsample_size=4.0)
centers = TfPoseEstimator.get_centers(image, humans, imgcopy=False)
with open(path_w, mode='a') as f:
f.write('t' + str(j) + ':' + str(centers) + '\n')
j += 1
k = 30
while k < 80:
image = common.read_imgfile('./results/webcam/webcamRaw/'+'img_%s.png' % str(k).zfill(6))
humans = e.inference(image, resize_to_default=True, upsample_size=4.0)
image = TfPoseEstimator.draw_humans(image, humans, imgcopy=False)
cv2.imwrite('./results/webcam2/webcamOpenpose/'+'img_%s.png' % str(k).zfill(6), image)
k += 1
def __init__(self, image, resize='0x0', model='mobilenet_thin'):
self.logger = logging.getLogger('TfPoseEstimator-WebCam')
self.logger.setLevel(logging.DEBUG)
self.ch = logging.StreamHandler()
self.ch.setLevel(logging.DEBUG)
self.formatter = logging.Formatter(
'[%(asctime)s] [%(name)s] [%(levelname)s] %(message)s')
self.ch.setFormatter(self.formatter)
self.logger.addHandler(self.ch)
self.logger.debug('initialization %s : %s' %
(model, get_graph_path(model)))
self.w, self.h = model_wh(resize)
if self.w > 0 and self.h > 0:
self.e = TfPoseEstimator(get_graph_path(model),
target_size=(self.w, self.h))
else:
self.e = TfPoseEstimator(get_graph_path(model),
target_size=(432, 368))
self.logger.debug('cam read+')
# cam = cv2.VideoCapture(camera)
# ret_val, image = cam.read()
self.image_h, self.image_w = image.shape[:2]
# logger.info('cam image=%dx%d' % (image.shape[1], image.shape[0]))
self.fps_time = 0
self.videostep = 0
self.human_keypoint = {
0: [
np.array([
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
])
]
}
self.hisfps = [] # Historical FPS data
def initial_pose_model(config):
w, h = model_wh(config["resize"])
if w == 0 or h == 0:
pose = TfPoseEstimator(get_graph_path(config["pose_model"]), target_size=(432, 368))
else:
pose = TfPoseEstimator(get_graph_path(config["pose_model"]), target_size=(w, h))
return pose
def infer(image, model='cmu', resize='0x0', resize_out_ratio=4.0):
"""
:param image:
:param model:
:param resize:
:param resize_out_ratio:
:return:
"""
w, h = model_wh(resize)
if w == 0 or h == 0:
e = TfPoseEstimator(get_graph_path(model), target_size=(432, 368))
else:
e = TfPoseEstimator(get_graph_path(model), target_size=(w, h))
# estimate human poses from a single image !
image = common.read_imgfile(image, None, None)
if image is None:
raise Exception('Image can not be read, path=%s' % image)
humans = e.inference(image,
resize_to_default=(w > 0 and h > 0),
upsample_size=resize_out_ratio)
if "TERM_PROGRAM" in os.environ and 'iTerm' in os.environ["TERM_PROGRAM"]:
image = TfPoseEstimator.draw_humans(image, humans, imgcopy=False)
image_str = cv2.imencode(".jpg", image)[1].tostring()
print("\033]1337;File=name=;inline=1:" +
base64.b64encode(image_str).decode("utf-8") + "\a")
return humans
def __init__(self, model="cmu"):
models = set({"mobilenet_thin", "cmu"})
self.model = model if model in models else "mobilenet_thin"
# parser = argparse.ArgumentParser(description='tf-pose-estimation run')
# parser.add_argument('--image', type=str, default='./images/p1.jpg')
# parser.add_argument('--model', type=str, default='cmu', help='cmu / mobilenet_thin')
# parser.add_argument('--resize', type=str, default='0x0',
# help='if provided, resize images before they are processed. default=0x0, Recommends : 432x368 or 656x368 or 1312x736 ')
# parser.add_argument('--resize-out-ratio', type=float, default=4.0,
# help='if provided, resize heatmaps before they are post-processed. default=1.0')
self.resize_out_ratio = 4.0
# args = parser.parse_args()
# w, h = model_wh(args.resize)
w, h = model_wh("432x368")
if w == 0 or h == 0:
e = TfPoseEstimator(get_graph_path(self.model),
target_size=(432, 368))
else:
e = TfPoseEstimator(get_graph_path(self.model), target_size=(w, h))
# self.args = args
self.w, self.h = w, h
self.e = e
self.fps_time = time.time()
def run(self):
try:
w, h = model_wh(self.resolution)
e = self.__load_model()
cap = self.__open_video()
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = cap.get(cv2.CAP_PROP_FPS)
output = self.__open_video_writer()
while cap.isOpened():
ret_val, image = cap.read()
try:
humans = e.inference(image,
resize_to_default=(w > 0 and h > 0),
upsample_size=4.0)
except Exception:
break
if not self.show_bg:
image = np.zeros(image.shape)
image = TfPoseEstimator.draw_humans(image,
humans,
imgcopy=False)
if self.output_video != '':
output.write(image)
output.release()
cv2.destroyAllWindows()
except Exception as e:
VideoProcesserThread.error_signal.emit(e)
def infer(image,
model='mobilenet_thin',
resize='368x368',
resize_out_ratio=4.0):
"""
:param image:
:param model:
:param resize:
:param resize_out_ratio:
:return:
"""
w, h = model_wh(resize)
if w == 0 or h == 0:
e = TfPoseEstimator(get_graph_path(model), target_size=(432, 368))
else:
e = TfPoseEstimator(get_graph_path(model), target_size=(w, h))
# estimate human poses from a single image !
image = common.read_imgfile(image, None, None)
if image.shape[0] != 480 or image.shape[1] != 640:
image = cv2.resize(image, (368, 368))
if image is None:
raise Exception('Image can not be read, path=%s' % image)
humans = e.inference(image,
resize_to_default=(w > 0 and h > 0),
upsample_size=resize_out_ratio)
image = TfPoseEstimator.draw_humans(image, humans, imgcopy=False)
return image
def load(model='mobilenet_thin', resize='656x368'):
w, h = model_wh(resize)
global estimator
if w == 0 or h == 0:
estimator = TfPoseEstimator(
get_graph_path(model), target_size=(432, 368))
else:
estimator = TfPoseEstimator(get_graph_path(model), target_size=(w, h))
def get_estimator(model='cmu', resize='0x0'):
w, h = model_wh(resize)
if w == 0 or h == 0:
e = TfPoseEstimator(get_graph_path(model), target_size=(432, 368))
else:
e = TfPoseEstimator(get_graph_path(model), target_size=(w, h))
return e
def create_estimator():
'''
:return: TfPoseEstimator 생성
'''
w, h = model_wh(FLAGS.resize)
e = TfPoseEstimator(get_graph_path(FLAGS.model), target_size=(w, h))
return e
def __init__(self):
"""
Initialize the graphics window and mesh surface
"""
# setup the view window
self.app = QtGui.QApplication(sys.argv)
self.window = gl.GLViewWidget()
self.window.setWindowTitle('Terrain')
self.window.setGeometry(0, 110, 1920, 1080)
self.window.setCameraPosition(distance=30, elevation=12)
self.window.show()
gx = gl.GLGridItem()
gy = gl.GLGridItem()
gz = gl.GLGridItem()
gx.rotate(90, 0, 1, 0)
gy.rotate(90, 1, 0, 0)
gx.translate(-10, 0, 0)
gy.translate(0, -10, 0)
gz.translate(0, 0, -10)
self.window.addItem(gx)
self.window.addItem(gy)
self.window.addItem(gz)
modeln = 'mobilenet_thin'
modelr = '432x368'
camera = 0
self.lines = {}
self.connection = [
[0, 1], [1, 2], [2, 3], [0, 4], [4, 5], [5, 6],
[0, 7], [7, 8], [8, 9], [9, 10], [8, 11], [11, 12],
[12, 13], [8, 14], [14, 15], [15, 16]
]
w, h = model_wh(modelr)
self.e = TfPoseEstimator(get_graph_path(modeln), target_size=(w, h))
self.cam = cv2.VideoCapture(camera)
ret_val, image = self.cam.read()
self.poseLifting = Prob3dPose('./skeleton_humanactivity/lifting/models/prob_model_params.mat')
keypoints = self.mesh(image)
self.points = gl.GLScatterPlotItem(
pos=keypoints,
color=pg.glColor((0, 255, 0)),
size=15
)
self.window.addItem(self.points)
for n, pts in enumerate(self.connection):
self.lines[n] = gl.GLLinePlotItem(
pos=np.array([keypoints[p] for p in pts]),
color=pg.glColor((0, 0, 255)),
width=3,
antialias=True
)
self.window.addItem(self.lines[n])
def get_2d_estimator(model='mobilenet_thin', resize='432x368'):
w, h = model_wh(resize)
if w == 0 or h == 0:
e = TfPoseEstimator(get_graph_path(model), target_size=(432, 368))
else:
e = TfPoseEstimator(get_graph_path(model), target_size=(w, h))
e.__w = w
e.__h = h
return e
def __init__(self):
self.w, self.h = model_wh('432x368')
if self.w > 0 and self.h > 0:
self.e = TfPoseEstimator(get_graph_path('mobilenet_thin'),
target_size=(self.w, self.h),
trt_bool=True)
else:
self.e = TfPoseEstimator(get_graph_path('mobilenet_thin'),
target_size=(432, 368),
trt_bool=True)
def __init__(self, model='mobilenet_thin'):
self.d = edict(camera=2,
model=model,
resize='432x368',
resize_out_ratio=4.0,
show_process=False,
tensorrt='False')
self.e = TfPoseEstimator(get_graph_path(self.d.model),
target_size=model_wh(self.d.resize),
trt_bool=str2bool(self.d.tensorrt))
def __init__(self, gpu_id=0):
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
config.log_device_placement = True
model = "cmu"
resize = "656x368"
self._w, self._h = model_wh(resize)
self._model = init_model(gpu_id, model, self._w, self._h, config)
self._logger = logging.getLogger(__name__)
def openposeMain():
parser = argparse.ArgumentParser(description='tf-pose-estimation Video')
# parser.add_argument('--video', type=str, default='')
parser.add_argument('--resolution',
type=str,
default='512x512',
help='network input resolution. default=432x368')
parser.add_argument(
'--model',
type=str,
default='mobilenet_thin',
help='cmu / mobilenet_thin / mobilenet_v2_large / mobilenet_v2_small')
parser.add_argument(
'--show-process',
type=bool,
default=False,
help='for debug purpose, if enabled, speed for inference is dropped.')
parser.add_argument('--showBG',
type=bool,
default=True,
help='False to show skeleton only.')
args = parser.parse_args()
logger.debug('initialization %s : %s' %
(args.model, get_graph_path(args.model)))
w, h = model_wh(args.resolution)
e = TfPoseEstimator(get_graph_path(args.model), target_size=(w, h))
while True:
image = openposeBeforeQ.get()
humans = e.inference(image, resize_to_default=True, upsample_size=4.0)
# print('len(humans):',len(humans)) #frame하나당 사람의 좌표
if not args.showBG:
image = np.zeros(image.shape)
(image, hands_centers) = TfPoseEstimator.draw_humans(image,
humans,
imgcopy=False)
# return value
openposeAfterQ.put(hands_centers)
num_hands = len(hands_centers)
# if num_hands != 0:
# for i in range(num_hands):
# print('i:',i,'hands_centers_inin:',hands_centers[i])
cv2.putText(image, "FPS: %f" % (1.0 / (time.time() - fps_time)),
(10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
# cv2.imshow('tf-pose-estimation result', image)
fps_time = time.time()
def __load_model(self):
if self.is_active:
self.__clear_thread()
w, h = model_wh(self.resolution)
try:
return TfPoseEstimator(get_graph_path(self.model),
target_size=(w, h))
except Exception:
raise ModelError("Не удалось загрузить модель: {}. Убедитесь, что модель находится в директории models/graph"\
.format(self.model))
def create_dataframe(self,
path,
model='cmu',
resize_out_ratio=4.0,
resize="432x368"):
"""Analyzes the frame and returns a jupyter array where the relativ positons of the joints are located in the picture"""
a = [str(x) if x > 9 else '0' + str(x) for x in range(1, 19)]
b = ['x', 'y', 'score']
temp_dic = {
'bp' + str(key[0]) + str(key[1]): []
for key in product(a, b)
}
frame = 0
logger.debug('initialization %s : %s' % (model, get_graph_path(model)))
w, h = model_wh(resize)
e = TfPoseEstimator(get_graph_path(model), target_size=(w, h))
cap = cv2.VideoCapture(path)
while cap.isOpened():
frame += 1
if frame % 100 == 0:
print(frame)
ret_val, image = cap.read()
try:
humans = e.inference(image,
resize_to_default=(w > 0 and h > 0),
upsample_size=resize_out_ratio)
except:
break
for human in humans:
for key, value in temp_dic.items():
key = int(key[2:4])
found = human.body_parts.keys()
if key in found:
#print("found something")
skey = str(key) if key > 9 else '0' + str(key)
temp_dic['bp' + skey + "score"].append(
human.body_parts[key].score)
temp_dic['bp' + skey + "y"].append(
human.body_parts[key].x)
temp_dic['bp' + skey + "x"].append(
human.body_parts[key].y)
else:
skey = str(key) if key > 9 else '0' + str(key)
temp_dic['bp' + skey + "score"].append(None)
temp_dic['bp' + skey + "y"].append(None)
temp_dic['bp' + skey + "x"].append(None)
cv2.destroyAllWindows()
self.df = pd.DataFrame(temp_dic)
def get_keypoints_from_directory(direction_path, format='jpg', model='mobilenet_v2_large', resolution='432x368'):
all_keypoints = [] # 返回一个关节位置序列的列表（一张图片中可能有多人）
w, h = model_wh(resolution)
estimator = TfPoseEstimator(get_graph_path(model), target_size=(w, h))
files_grabbed = glob.glob(os.path.join(direction_path, '*.' + format))
for i, file in enumerate(files_grabbed):
image = common.read_imgfile(file, None, None)
humans = estimator.inference(image, True, 4.0)
results = get_keypoints_from_humans(humans)
for item in results:
all_keypoints.append(item)
return all_keypoints
def run(self):
try:
w, h = model_wh(self.resolution)
e = self.__load_model(w, h)
cap = self.__open_video()
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = cap.get(cv2.CAP_PROP_FPS)
frames_total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
current_frame = 0
csv_file, csv_writer = self.__open_csv()
video_output = self.__open_video_writer(
width, height, fps) if self.output_video else None
while cap.isOpened():
if not self.is_active:
raise ProcessingInterruptedException(
"Работа прервана извне")
ret_val, image = cap.read()
try:
humans = e.inference(image,
resize_to_default=(w > 0 and h > 0),
upsample_size=4.0)
except Exception:
break
csv_writer.writerow([humans])
if not self.show_bg:
image = np.zeros(image.shape)
image = TfPoseEstimator.draw_humans(image,
humans,
imgcopy=False)
if video_output:
video_output.write(image)
current_frame += 1
self.__update_progress(frames_total, current_frame)
video_output.release()
csv_file.close()
cv2.destroyAllWindows()
self.finish_signal.emit()
except ProcessingInterruptedException:
self.interrupted_signal.emit()
except Exception as e:
self.error_signal.emit(e)
def initial_preprocessing(estimator, image_file, resize='0x0'):
w, h = model_wh(resize)
w, h = (432, 368) if (w, h) == (0, 0) else (w, h)
estimator.initialize_hyperparams(target_size=(w, h))
image = common.read_imgfile(image_file, None, None)
if image is None:
logger.error('Image can not be read, path=%s' % image)
sys.exit(-1)
return estimator, image, (w, h)
def __read_model__(self):
# model読み込み
print "model読み込み"
try:
w, h = model_wh(self.resolution)
graph_path = get_graph_path(self.model)
ros_pack = rospkg.RosPack()
graph_path = os.path.join(ros_pack.get_path('tfpose_ros'), graph_path)
pose_estimator = TfPoseEstimator(graph_path, target_size=(w, h))
return pose_estimator
except Exception as e:
rospy.logerr('invalid model: %s, e=%s' % (self.model, e))
sys.exit(-1)
def record(args):
# Open output file:
"""
Output filename: <in_filename>_<model_name>
"""
global out_data, out_file_path
in_file = getFileName(args.video)
out_file = ''.join([in_file, '_', args.model])
out_file_path = os.path.join(args.output, out_file)
logger.info(out_file_path)
#with open(outfile, 'wb') as f:
frame_idx = 0
det_frame = 0
w, h = model_wh(args.resolution)
e = TfPoseEstimator(get_graph_path(args.model), target_size=(w, h))
cap = cv2.VideoCapture(args.video)
if cap.isOpened() is False:
print("Error opening video stream or file.")
num_frames = cap.get(cv2.CAP_PROP_FRAME_COUNT)
logger.info('Num frames to process: %d' % num_frames)
pcnt = 0.0
logger.info('Recording pose data to %s' % out_file_path)
while cap.isOpened():
ret, image = cap.read()
if image is None:
break
humans = e.inference(image,
resize_to_default=True,
upsample_size=args.resize_out_ratio)
if len(humans) > 0:
out_data[frame_idx] = humans
pcnt = (frame_idx + 1) / num_frames * 100.0
sys.stdout.write("\rDone {0:.2f}%".format(pcnt))
sys.stdout.flush()
frame_idx += 1
cap.release()
logger.info('Writing data to %s' % out_file)
pickleData()
def on_stream(client, params):
redis_store = redis.Redis(host='redis',
password='******',
port=6379,
db=0)
global stream_running
print(params)
gpu_options = tf.GPUOptions()
gpu_options.allow_growth = True
w, h = model_wh(params['resize'])
if w > 0 and h > 0:
e = TfPoseEstimator(get_graph_path(params['model']),
target_size=(w, h),
tf_config=tf.ConfigProto(gpu_options=gpu_options))
else:
e = TfPoseEstimator(get_graph_path(params['model']),
target_size=(432, 368),
tf_config=tf.ConfigProto(gpu_options=gpu_options))
cam = cv2.VideoCapture(params['camera'])
ret_val, image = cam.read()
while stream_running:
ret_val, image = cam.read()
humans = e.inference(image,
resize_to_default=(w > 0 and h > 0),
upsample_size=params['resize_out_ratio'])
all_humans = []
for human in humans:
body_parts = []
for part in human.body_parts.values():
body_parts.append({
'index': part.part_idx,
'x': part.x,
'y': part.y,
'score': part.score
})
all_humans.append(body_parts)
image_id = str(uuid.uuid4())
retval, buffer = cv2.imencode('.png', image)
png = base64.b64encode(buffer)
redis_store.set(image_id, png, ex=EXPIRATION_TIME)
frame = {'humans': all_humans, 'image': image_id}
frame_json = json.dumps(frame)
client.publish(SERVICE_NAME + '/pose', frame_json)
def get_keypoints_from_image(image_path, model='mobilenet_v2_large', resolution='432x368', normalizetion=True):
all_keypoints = [] # 返回一个关节位置序列的列表（一张图片中可能有多人）
w, h = model_wh(resolution)
estimator = TfPoseEstimator(get_graph_path(model), target_size=(w, h))
image = common.read_imgfile(image_path, None, None)
humans = estimator.inference(image, True, 4.0)
for human in humans:
body_dict = dict()
human_split = str(human).split('BodyPart:')
for bodypart in human_split:
left_parenthesis = bodypart.find('(')
if left_parenthesis != -1:
if left_parenthesis == 2:
bodypart_index = int(bodypart[left_parenthesis - 2:left_parenthesis - 1])
else:
bodypart_index = int(bodypart[left_parenthesis - 3:left_parenthesis - 1])
x_pos = float(bodypart[left_parenthesis + 1:left_parenthesis + 5])
y_pos = float(bodypart[left_parenthesis + 7:left_parenthesis + 11])
confidence_score = float(bodypart[left_parenthesis + 19:left_parenthesis + 23])
body_dict[bodypart_index] = [x_pos, y_pos, confidence_score]
else:
continue
# 缺失的关节点补0
for q in range(18):
if q not in body_dict.keys():
body_dict[q] = [0, 0, 0]
keypoints = [
body_dict[0][0], body_dict[0][1],
body_dict[1][0], body_dict[1][1],
body_dict[2][0], body_dict[2][1],
body_dict[3][0], body_dict[3][1],
body_dict[4][0], body_dict[4][1],
body_dict[5][0], body_dict[5][1],
body_dict[6][0], body_dict[6][1],
body_dict[7][0], body_dict[7][1],
body_dict[8][0], body_dict[8][1],
body_dict[9][0], body_dict[9][1],
body_dict[10][0], body_dict[10][1],
body_dict[11][0], body_dict[11][1],
body_dict[12][0], body_dict[12][1],
body_dict[13][0], body_dict[13][1],
body_dict[14][0], body_dict[14][1],
body_dict[15][0], body_dict[15][1],
body_dict[16][0], body_dict[16][1],
body_dict[17][0], body_dict[17][1],
]
if not normalizetion:
all_keypoints.append(keypoints) # 不归一化
else:
all_keypoints.append(normalization_from_list(keypoints)) # 归一化
return all_keypoints