def openpose_25_kp(image):
datum = op.Datum()
image_to_process = copy.copy(image)
datum.cvInputData = image_to_process
opWrapper.emplaceAndPop([datum])
pose_key_points = datum.poseKeypoints
return pose_key_points
def init():
# Try to import OpenPose
try:
# Get path from system environment
OPENPOSE_ROOT = os.environ["OPENPOSE_ROOT"]
sys.path.append(OPENPOSE_ROOT + '/' + 'build/python/')
from openpose import pyopenpose as op
except ImportError as e:
print(
'Error: OpenPose library could not be found. '
'Did you enable `BUILD_PYTHON` in CMake and have this Python script in the right folder?'
)
raise e
# Init OpenPose
global Data, PoseDetector
# Set OpenPose parameters
params = dict()
params["model_folder"] = OPENPOSE_ROOT + os.sep + "models" + os.sep
params["face"] = False
params["hand"] = False
params["disable_blending"] = True
# Start OpenPose wrapper
op_wrapper = op.WrapperPython()
op_wrapper.configure(params)
op_wrapper.start()
# Init Datum object
Data = op.Datum()
# Rename op_wrapper
PoseDetector = op_wrapper
def analyze():
ret_val, final_image = cam.read()
final_image = edit_video(final_image)
###############
# Process openpose
############
# Process image
datum = op.Datum()
datum.cvInputData = final_image
opWrapper.emplaceAndPop([datum])
# Display Image
frame = datum.poseKeypoints
cv2.imshow("Frame", datum.cvOutputData)
############
# Classify current passenger state.
######
prediction = safety_check(frame)
return prediction, frame, datum.cvOutputData
def detect_poses(self, image):
# `op` added to globals in the constructor
datum = op.Datum() # pylint: disable=undefined-variable # noqa: F821
datum.cvInputData = image
self._openpose_wrapper.emplaceAndPop(op.VectorDatum([datum]))
keypoints = datum.poseKeypoints
overlayed_image = datum.cvOutputData
recognitions = []
if keypoints is not None and len(
keypoints.shape
) == 3: # If no detections, keypoints will be None
num_persons, num_bodyparts, _ = keypoints.shape
for person_id in range(0, num_persons):
for body_part_id in range(0, num_bodyparts):
body_part = self._model["body_parts"][body_part_id]
x, y, probability = keypoints[person_id][body_part_id]
if probability > 0:
recognitions.append(
Recognition(group_id=person_id,
roi=RegionOfInterest(width=1,
height=1,
x_offset=int(x),
y_offset=int(y)),
categorical_distribution=
CategoricalDistribution(probabilities=[
CategoryProbability(
label=body_part,
probability=float(probability))
])))
return recognitions, overlayed_image
def get_keypoints(image):
try:
# Starting OpenPose
opWrapper = op.WrapperPython()
opWrapper.configure(params)
opWrapper.start()
# Process Image
datum = op.Datum()
datum.cvInputData = image
opWrapper.emplaceAndPop([datum])
if (datum.poseKeypoints.ndim == 0):
print("No person found in image!")
sys.exit(-1)
num = len(datum.poseKeypoints)
if (num is 0):
print("No person found in image!")
sys.exit(-1)
return datum
except Exception as e:
print("Openpose Error: ")
print(e)
def predict_image(self, image_path):
datum = op.Datum()
image_to_process = cv2.imread(image_path)
datum.cvInputData = image_to_process
self.opWrapper.emplaceAndPop([datum])
return datum.poseKeypoints
def hand_skel(self, image_path, is_left=False):
from openpose import pyopenpose as op
# Read image and face rectangle locations
img = cv2.imread(image_path)
if img is None:
return None
height, width = img.shape[:2]
top, bottom, left, right = get_square_padding(img)
img = squarify(img, (top, bottom, left, right))
hand_rect = op.Rectangle(0.0, 0.0, img.shape[0], img.shape[0])
null_rect = op.Rectangle(0.0, 0.0, 0.0, 0.0)
if is_left:
hand_rects = [[hand_rect, null_rect]]
else:
hand_rects = [[null_rect, hand_rect]]
datum = op.Datum()
datum.cvInputData = img
datum.handRectangles = hand_rects
self.op_wrap.emplaceAndPop(op.VectorDatum([datum]))
if is_left:
kps = datum.handKeypoints[0][0]
else:
kps = datum.handKeypoints[1][0]
if left:
kps[:, 0] -= left
elif top:
kps[:, 1] -= top
return kps, width, height
def __init__(self, debug=0):
self.debug = debug
self.frameCount = 0
self.timePrev = time.time()
#region OPENPOSE
opParams = dict()
opParams['model_folder'] = '/home/aufar/Documents/openpose/models/'
opParams['net_resolution'] = '176x176'
self.opWrapper = op.WrapperPython()
self.opWrapper.configure(opParams)
self.opWrapper.start()
self.datum = op.Datum()
#endregion
self.subscriberImageDetections = rospy.Subscriber(
'yolo_detector/output/compresseddetections',
CompressedImageAndBoundingBoxes,
self.callback,
queue_size=1)
self.publisherDetectionDirections = rospy.Publisher(
'yact/output/detectiondirections',
DetectionAndDirection,
queue_size=1)
def skeleton_from_video(video_path, icam=0, visual=True):
cap = cv2.VideoCapture(video_path)
all_poseKeypoints = []
i = 0
while True:
ret, frame = cap.read()
if not ret:
break
datum = op.Datum()
imageToProcess = copy.copy(frame)
datum.cvInputData = imageToProcess
opWrapper.emplaceAndPop([datum])
if visual:
cv2.imshow("OpenPose 1.4.0 - Tutorial Python API",
datum.cvOutputData)
key = cv2.waitKey(15)
if key == 27:
break
poseKeyPoints = datum.poseKeypoints
if isinstance(poseKeyPoints, np.ndarray):
for k, pose in enumerate(poseKeyPoints):
pose = np.hstack((icam, i, pose))
all_poseKeypoints.append(pose)
i += 1
return np.asarray(all_poseKeypoints)
def get_points_from_image(image_path):
try:
logger.debug('Starting analysis')
# parameters
params = dict()
params["model_folder"] = "./openpose_models/"
params["face"] = True
params["hand"] = True
# params["write_json"] = "./json_outputs/"
# Starting OpenPose
opWrapper = op.WrapperPython()
opWrapper.configure(params)
opWrapper.start()
# Process Image
datum = op.Datum()
imageToProcess = cv2.imread(image_path)
datum.cvInputData = imageToProcess
opWrapper.emplaceAndPop([datum])
logger.debug('Analysis done, raw data: {}'.format(datum.cvOutputData))
return datum.cvOutputData
except Exception as e:
logger.error('An error occurred while analysing an image')
logger.error(e, exc_info=True)
# propagate error forward
raise e
def extractHeatMap(image):
params["model_folder"] = "./openpose/models/"
params["heatmaps_add_parts"] = True
params["heatmaps_add_bkg"] = True
params["heatmaps_add_PAFs"] = True
params["heatmaps_scale"] = 2
opWrapper = op.WrapperPython()
opWrapper.configure(params)
opWrapper.start()
# Process Image
datum = op.Datum()
#imageToProcess = cv2.imread(args[0].image_path)
imageToProcess = image
datum.cvInputData = imageToProcess
opWrapper.emplaceAndPop([datum])
# Process outputs
outputImageF = (datum.inputNetData[0].copy())[0, :, :, :] + 0.5
outputImageF = cv2.merge(
[outputImageF[0, :, :], outputImageF[1, :, :], outputImageF[2, :, :]])
outputImageF = (outputImageF * 255.).astype(dtype='uint8')
heatmaps = datum.poseHeatMaps.copy()
heatmaps = (heatmaps).astype(dtype='uint8')
return heatmaps
def generate_kpts(video_name):
kpt_results = []
cap = cv2.VideoCapture(video_name)
length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
opWrapper = load_model()
for i in tqdm(range(length)):
try:
datum = op.Datum()
_, imageToProcess = cap.read()
datum.cvInputData = imageToProcess
opWrapper.emplaceAndPop([datum])
results = datum.poseKeypoints
#25 to 17
assert len(
results
) == 1, 'videopose3D only support one pserson restruction'
kpts = convert(results[0])
kpt_results.append(kpts)
except Exception as e:
print(e)
# pose processes
result = np.array(kpt_results)
return result
def HandKeypoint_getKeypoints(self, HandImage, box):
#
# implementCODE
#
# keypoints = KeypointType()
arr = np.fromstring(HandImage.image, np.uint8)
frame = np.reshape(
arr, (HandImage.height, HandImage.width, HandImage.depth))
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
print('Input Data Recieved')
box = np.array(box)
## Creating openpose rectangle
hands_rectangles = [[
self.box2oprectangle(box),
op.Rectangle(0., 0., 0., 0.)
]]
# Create new datum
datum = op.Datum()
datum.cvInputData = frame
datum.handRectangles = hands_rectangles
# Process and display image
self.openpose_wrapper.emplaceAndPop([datum])
if datum.handKeypoints[0].shape == ():
# if there were no detections
hand_keypoints = None
else:
hand_keypoints = datum.handKeypoints[0][0]
return hand_keypoints
def __init__(self):
# image array config
self.bridge = CvBridge()
self.threat_boxes_topic = rospy.get_param("~threat_image_topic",
"/threats/potential_images")
self.threat_boxes_sub = rospy.Subscriber(self.threat_boxes_topic,
ImageArray, self.threat_boxes)
self.msg_seq = 0
self.msg_time = 0
self.skeletons = []
# openpose config
self.params = dict()
self.params["model_folder"] = rospy.get_param("~model_folder_path",
"/cfg/models/")
self.opWrapper = op.WrapperPython()
self.opWrapper.configure(self.params)
self.opWrapper.start()
self.datum = op.Datum()
# publish skeleton topics
self.op_image_pub_topic = rospy.get_param("~skeleton_image_topic",
"/threats/skeleton_images")
self.op_image_pub = rospy.Publisher(self.op_image_pub_topic,
Image,
queue_size=10)
self.op_image_seq = 0
# threat model params
self.threat_model_name = rospy.get_param("~threat_model_name",
"default_model")
self.threat_model_path = rospy.get_param("~threat_model_path")
self.threat_model_meta = self.threat_model_path + self.threat_model_name + ".meta"
def processPic(self):
# ============================= 启动openPose ===================================
datum = op.Datum()
datum.cvInputData = cv2.imread(self.picPaths) # 输入
opWrapper.emplaceAndPop(op.VectorDatum([datum])) # 输出
keyPoints = datum.poseKeypoints.tolist()
dstPicPath = "../dataset/marked_pic/p_" + self.picPaths.split('/')[
-1] # 处理后的图片
cv2.imwrite(dstPicPath, datum.cvOutputData)
# ============================= 写骨骼数据文件 ===================================
with open("../dataset/bone_dataSet.data", "a+") as dataSet:
dataSet.writelines(
str(
self.pointDistance(keyPoints[0]) +
self.pointAngle(keyPoints[0]) +
[int(self.lineEdit.text())]))
dataSet.write("\n")
# ============================= 写骨骼图片文件 ===================================
bone_img = datum.cvOutputData
height, width, channel = bone_img.shape
pixmap = QPixmap.fromImage(
QImage(bone_img.data, width, height, 3 * width,
QImage.Format_RGB888).rgbSwapped())
self.label_3.setPixmap(pixmap)
def analyze(self):
rate = rospy.Rate(5)
while self.image_ready == False and not rospy.is_shutdown():
rate.sleep()
final_image = self.image_raw
final_image = self.edit_video(final_image)
###############
# Process openpose
############
# Process image
datum = op.Datum()
datum.cvInputData = final_image
self.opWrapper.emplaceAndPop(op.VectorDatum([datum]))
# Display Image
frame = datum.poseKeypoints
cv2.imshow("Frame", datum.cvOutputData)
############
# Classify current passenger state.
######
prediction = self.safety_check(frame)
return prediction, frame, datum.cvOutputData
def process(input_dir, openpose_model_dir):
params = {}
# Configure openpose params
params['image_dir'] = input_dir
params['model_folder'] = openpose_model_dir
params['face'] = True
op_wrapper = op.WrapperPython()
op_wrapper.configure(params)
op_wrapper.start()
# Process images in input dir
paths = op.get_images_on_directory(input_dir)
joints_2d = []
face_2d = []
for path in paths:
datum = op.Datum()
img = cv2.imread(path)
resolution = img.shape[:2]
datum.cvInputData = img
op_wrapper.emplaceAndPop([datum])
joints_2d.append(format_pose(datum.poseKeypoints, resolution))
face_2d.append(format_face(datum.faceKeypoints, resolution))
return joints_2d, face_2d
def get_sample_heatmaps():
# These parameters are globally set. You need to unset variables set here if you have a new OpenPose object. See *
params = dict()
params["model_folder"] = "/usr/local/src/openpose-1.7.0/models/"
params["heatmaps_add_parts"] = True
params["heatmaps_add_bkg"] = True
params["heatmaps_add_PAFs"] = True
params["heatmaps_scale"] = 3
params["upsampling_ratio"] = 1
params["body"] = 1
# Starting OpenPose
opWrapper = op.WrapperPython()
opWrapper.configure(params)
opWrapper.start()
# Process Image and get heatmap
datum = op.Datum()
imageToProcess = cv2.imread(args[0].image_path)
datum.cvInputData = imageToProcess
opWrapper.emplaceAndPop([datum])
poseHeatMaps = datum.poseHeatMaps.copy()
opWrapper.stop()
return poseHeatMaps
def __init__(self, parent=None):
super(MainWIndow, self).__init__(parent)
self.timer_camera = QtCore.QTimer()
self.width = 720
self.height = 480
self.set_ui()
self.slot_init()
# openpose params
print(params)
# Starting OpenPose
self.opWrapper = opWrapper
self.opWrapper.start()
# Process Image
self.datum = op.Datum()
self.SEQ_LEN = 10
self.isStarted = False
self.UserFrames = {}
self.make_pause = False
self.saved_count = 0
self.backgorund_image = {}
self.users_complete = {}
self.tracker = Sort(20, 3)
self.currentExamination = 0
# initiate the video
self.cap = cv2.VideoCapture("/home/prince/Desktop/destination.mp4")
def __init__(self, pose_type=BODY25B, params=None):
if params is None:
params = {}
if 'model_pose' in params:
logger.warning(
'model_pose param specified by pose_type arg, conflict.')
super().__init__()
self.pose_type = pose_type
self.full_params = {
'model_folder': self.model_path,
'number_people_max': 3,
# 'net_resolution': '-1x368', # it is default value
'logging_level': 3,
'display': 0,
'alpha_pose': 0.79,
# 'face': 1,
# 'hand': 1,
}
self.full_params.update(params)
self.full_params.update({
'model_pose': pose_type.NAME,
})
self.opWrapper = opp.WrapperPython()
self.opWrapper.configure(self.full_params)
self.opWrapper.start()
self.datum: opp.Datum = opp.Datum()
def initialize_openpose(self, args):
# Custom Params (refer to include/openpose/flags.hpp for more parameters)
params = dict()
# Openpose params
# Model path
params["model_folder"] = args[0].openpose_folder
# Face disabled
params["face"] = False
# Hand disabled
params["hand"] = False
# Net Resolution
params["net_resolution"] = args[0].net_size
# Gpu number
params["num_gpu"] = 1 # Set GPU number
# Gpu Id
# Set GPU start id (not considering previous)
params["num_gpu_start"] = 0
# Starting OpenPose
self.opWrapper = op.WrapperPython()
self.opWrapper.configure(params)
self.opWrapper.start()
self.datum = op.Datum()
def detection(pipe_img, pipe_center, pipe_scale, pipe_img_2, pipe_kp):
params = set_params()
opWrapper = op.WrapperPython()
opWrapper.configure(params)
opWrapper.start()
detection_count = 0
detection_time = time.time()
while True:
img = pipe_img.recv()
datum = op.Datum()
datum.cvInputData = img
opWrapper.emplaceAndPop([datum])
bodyKeypoints_img = datum.cvOutputData
cv2.rectangle(bodyKeypoints_img, (330, 620), (630, 720), (0, 0, 255),
3)
#cv2.imwrite('kps.jpg',bodyKeypoints_img)
json_path = glob.glob('/media/ramdisk/output_op/*keypoints.json')
scale, center = op_util.get_bbox(json_path[0])
if scale == -1 and center == -1: continue
if scale >= 10: continue
pipe_img_2.send(img)
pipe_center.send(center)
pipe_scale.send(scale)
pipe_kp.send(bodyKeypoints_img)
os.system("rm /media/ramdisk/output_op/*keypoints.json")
detection_count = detection_count + 1
if detection_count == 100:
print('Detection FPS:',
1.0 / ((time.time() - detection_time) / 100.0))
detection_count = 0
detection_time = time.time()
def return_Ib_Pb(self, imagePath): # [Pb, Ib]をリターン ポーズが取れなかった場合はNoneをリターン
# print(imagePath)
datum = op.Datum()
image = cv2.imread(imagePath)
datum.cvInputData = image
self.opWrapper.emplaceAndPop([datum])
try:
int(datum.poseKeypoints)
return None, None
except:
keypoints_images = self.draw_keypoints(image, datum.poseKeypoints)
# return image, keypoints_images
return_image = cv2.resize(
image, (int(image.shape[0] / 8), int(image.shape[1] / 8)))
return_keypoints_images = []
for keypoints_image in keypoints_images:
resize_keypoints_image = cv2.resize(
keypoints_image, (int(keypoints_image.shape[0] / 8),
int(keypoints_image.shape[1] / 8)))
# height, width = resize_keypoints_image.shape[:2]
# # 取得結果（幅，高さ，チャンネル数，depth）を表示
# print("width: " + str(width))
# print("height: " + str(height))
return_keypoints_images.append(resize_keypoints_image)
return return_image, return_keypoints_images
def generate_kpts(video_name):
kpt_results = []
cap = cv2.VideoCapture(video_name)
length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
opWrapper = load_model()
for i in tqdm(range(length)):
try:
datum = op.Datum()
_, imageToProcess = cap.read()
datum.cvInputData = imageToProcess
opWrapper.emplaceAndPop([datum])
results = datum.poseKeypoints
#25 to 17
assert len(
results
) == 1, 'videopose3D only support one pserson restruction'
kpts = convert(results[0])
kpt_results.append(kpts)
except Exception as e:
print(e)
# pose processes
result = np.array(kpt_results)
# save
name = '/home/xyliu/experiments/VideoPose3D/data/tmp.npz'
kpts = result.astype(np.float32)
print('kpts npz save in ', name)
np.savez_compressed(name, kpts=kpts)
return kpts
return result
def test_video(model, video_name=0):
opWrapper = model
cam = cv2.VideoCapture(video_name)
# warm up
for i in range(5):
datum = op.Datum()
_, imageToProcess = cam.read()
datum.cvInputData = imageToProcess
opWrapper.emplaceAndPop([datum])
for i in tqdm(range(2000)):
datum = op.Datum()
_, imageToProcess = cam.read()
datum.cvInputData = imageToProcess
opWrapper.emplaceAndPop([datum])
def analyze():
params = dict()
params["model_folder"] = "../../../../models/"
opWrapper = op.WrapperPython()
opWrapper.configure(params)
opWrapper.start()
datum = op.Datum()
while True:
yuv_data_raw = dequeue()
while yuv_data_raw == None:
yuv_data_raw = dequeue()
yuv_data = struct.unpack('c'*1620*1920, yuv_data_raw)
yuv_img = np.array(list(map(ord, yuv_data)), dtype=np.uint8).reshape(1620,1920)
print(str(yuv_img.shape))
imageToProcess = cv2.cvtColor(yuv_img, cv2.COLOR_YUV2RGB_I420)
print('cvt to rgb end')
datum.cvInputData = imageToProcess
print('start analyze')
opWrapper.emplaceAndPop([datum])
print('analyze end')
rgba_data = cv2.cvtColor(datum.cvOutputData, cv2.COLOR_BGR2BGRA)
print('cvt to rgba end')
rgba_bin = rgba_data.reshape(1920*1080*4).ctypes.data
print('start enqueue')
while enqueue(rgba_bin) == -1:
pass
def openpose_hand_detect(self, handRectangles, cv_image):
# Create new datum
datum = op.Datum()
datum.cvInputData = cv_image
datum.handRectangles = handRectangles
# Process and display image
self.opWrapper.emplaceAndPop([datum])
# Uncomment to see the output of openpose
# [hand_position_pixel_x, hand_position_pixel_y, probability]
# print("Right hand keypoints: \n" + str(datum.handKeypoints[0]))
# print("Left hand keypoints: \n" + str(datum.handKeypoints[1]))
pCount_left = 0
pCount_right = 0
for i in range(2):
# i=0 right hand
# i=1 left hand
temp_hand = datum.handKeypoints[i]
for point in datum.handKeypoints[i][0]:
if point[2] > 4e-1 and i == 0:
pCount_right += 1
if point[2] > 4e-1 and i == 1:
pCount_left += 1
if pCount_left > 6:
self.pub_result.publish("Left hand detected")
if pCount_right > 6:
self.pub_result.publish("Right hand detected")
if pCount_left < 6 and pCount_right < 6:
self.pub_result.publish("No hand detected")
cv2.imshow("wave detect result", datum.cvOutputData)
cv2.imwrite(
"/home/zmx/catkin_ws/src/kamerider_image/kamerider_image_detection/result/wave_detect_result.png",
datum.cvOutputData)
cv2.waitKey(1)
def main():
with open("openpose_config.yml", 'r') as ymlfile:
if sys.version_info[0] > 2:
cfg = yaml.load(ymlfile, Loader=yaml.FullLoader)
else:
cfg = yaml.load(ymlfile)
# Custom Params (refer to include/openpose/flags.hpp for more parameters)
params = dict()
# params["model_folder"] = "/home/benjamin/CMU/openpose/models/"
params["model_folder"] = cfg['model_folder']
params["model_pose"] = cfg['model_pose']
# Starting OpenPose
opWrapper = op.WrapperPython()
opWrapper.configure(params)
opWrapper.start()
# Process Image
datum = op.Datum()
# walk 'unique' for renamable list
image_list = []
for (dirpath, dirnames, filenames) in walk(cfg['image_folder']):
image_list.extend(filenames)
break
images_processed = 0
for image in image_list:
current_image = cfg['image_folder'] + image
keypoint_file = cfg['keypoint_folder'] + image[:-4]
output_file = cfg['output_folder'] + image
# print("output_file = {}".format(output_file))
# print("current_image = {}".format(current_image))
imageToProcess = cv2.imread(current_image)
datum.cvInputData = imageToProcess
opWrapper.emplaceAndPop([datum])
# Save numpy arrays
if cfg['save_keypoints']:
# print("Body keypoints: \n" + str(datum.poseKeypoints))
# print(type(datum.cvOutputData))
np.save(keypoint_file, datum.poseKeypoints)
# Display Image
if cfg['show_images']:
cv2.imshow(image, datum.cvOutputData)
cv2.waitKey(0)
cv2.destroyWindow(image)
if cfg['save_output_image']:
cv2.imwrite(output_file, datum.cvOutputData)
images_processed += 1
if images_processed % 100 == 0:
print("\n Images to process remaining in {} : {} \n").format(
cfg['image_folder'],
len(image_list) - images_processed)
def __init__(self):
params = dict()
params["model_folder"] = model_folder
self.opWrapper = op.WrapperPython()
self.opWrapper.configure(params)
self.opWrapper.start()
self.datum = op.Datum()
def estimate_pose(self, imageToProcess):
datum = op.Datum()
if not isinstance(imageToProcess, np.ndarray):
return None
datum.cvInputData = imageToProcess
self.opWrapper.emplaceAndPop([datum])
return datum
