def analyze_camera(model, framework, resolution, lite):
"""
Live prediction of pose coordinates from camera.
Args:
model: deep learning model
Initialized EfficientPose model to utilize (RT, I, II, III, IV, RT_Lite, I_Lite or II_Lite)
framework: string
Deep learning framework to use (Keras, TensorFlow, TensorFlow Lite or PyTorch)
resolution: int
Input height and width of model to utilize
lite: boolean
Defines if EfficientPose Lite model is used
Returns:
Predicted pose coordinates in all frames of camera session.
"""
# Load video
import cv2
start_time = time.time()
cap = cv2.VideoCapture(0)
_, frame = cap.read()
frame_height, frame_width = frame.shape[:2]
coordinates = []
while (True):
# Read frame
_, frame = cap.read()
# Construct batch
batch = [frame[..., ::-1]]
# Preprocess batch
batch = helpers.preprocess(batch, resolution, lite)
# Perform inference
batch_outputs = infer(batch, model, lite, framework)
# Extract coordinates for frame
frame_coordinates = helpers.extract_coordinates(batch_outputs[0, ...],
frame_height,
frame_width,
real_time=True)
coordinates += [frame_coordinates]
# Draw and display predictions
helpers.display_camera(cv2, frame, frame_coordinates, frame_height,
frame_width)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
# Print total operation time
return coordinates
def analyze_image(file_path, model, framework, resolution, lite):
"""
Predict pose coordinates on supplied image.
Args:
file_path: path
System path of image to analyze
model: deep learning model
Initialized EfficientPose model to utilize (RT, I, II, III, IV, RT_Lite, I_Lite or II_Lite)
framework: string
Deep learning framework to use (Keras, TensorFlow, TensorFlow Lite or PyTorch)
resolution: int
Input height and width of model to utilize
lite: boolean
Defines if EfficientPose Lite model is used
Returns:
Predicted pose coordinates in the supplied image.
"""
# Load image
from PIL import Image
start_time = time.time()
image = np.array(Image.open(file_path))
image_height, image_width = image.shape[:2]
batch = np.expand_dims(image, axis=0)
# Preprocess batch
batch = helpers.preprocess(batch, resolution, lite)
# Perform inference
batch_outputs = infer(batch, model, lite, framework)
# Extract coordinates
coordinates = [
helpers.extract_coordinates(batch_outputs[0, ...], image_height,
image_width)
]
# Print processing time
print(
'\n##########################################################################################################'
)
print('Image processed in {0} seconds'.format('%.3f' %
(time.time() - start_time)))
print(
'##########################################################################################################\n'
)
return coordinates
def analyze_video(file_path, model, framework, resolution, lite):
"""
Predict pose coordinates on supplied video.
Args:
file_path: path
System path of video to analyze
model: deep learning model
Initialized EfficientPose model to utilize (RT, I, II, III, IV, RT_Lite, I_Lite or II_Lite)
framework: string
Deep learning framework to use (Keras, TensorFlow, TensorFlow Lite or PyTorch)
resolution: int
Input height and width of model to utilize
lite: boolean
Defines if EfficientPose Lite model is used
Returns:
Predicted pose coordinates in all frames of the supplied video.
"""
# Define batch size and number of batches in each part
batch_size = 1 if framework in ['tensorflowlite', 'tflite'] else 49
part_size = 490 if framework in ['tensorflowlite', 'tflite'] else 10
# Load video
from skvideo.io import vreader, ffprobe
start_time = time.time()
try:
videogen = vreader(file_path)
video_metadata = ffprobe(file_path)['video']
num_video_frames = int(video_metadata['@nb_frames'])
num_batches = int(np.ceil(num_video_frames / batch_size))
frame_height, frame_width = next(vreader(file_path)).shape[:2]
except:
print(
'\n##########################################################################################################'
)
print(
'Video "{0}" could not be loaded. Please verify that the file is working.'
.format(file_path))
print(
'##########################################################################################################\n'
)
return False
# Operate on batches
coordinates = []
batch_num = 1
part_start_time = time.time()
print(
'\n##########################################################################################################'
)
while True:
# Fetch batch of frames
batch = [next(videogen, None) for _ in range(batch_size)]
if not type(batch[0]) == np.ndarray:
break
elif not type(batch[-1]) == np.ndarray:
batch = [
frame if type(frame) == np.ndarray else np.zeros(
(frame_height, frame_width, 3)) for frame in batch
]
# Preprocess batch
batch = helpers.preprocess(batch, resolution, lite)
# Perform inference
batch_outputs = infer(batch, model, lite, framework)
# Extract coordinates for batch
batch_coordinates = [
helpers.extract_coordinates(batch_outputs[n, ...], frame_height,
frame_width) for n in range(batch_size)
]
coordinates += batch_coordinates
# Print partial processing time
if batch_num % part_size == 0:
print(
'{0} of {1}: Part processed in {2} seconds | Video processed for {3} seconds'
.format(int(batch_num / part_size),
int(np.ceil(num_batches / part_size)),
'%.3f' % (time.time() - part_start_time),
'%.3f' % (time.time() - start_time)))
part_start_time = time.time()
batch_num += 1
# Print total processing time
print('{0} of {0}: Video processed in {1} seconds'.format(
int(np.ceil(num_batches / part_size)),
'%.3f' % (time.time() - start_time)))
print(
'##########################################################################################################\n'
)
return coordinates[:num_video_frames]
def save_note(row, case_number, outdir, has_complication='yes'):
fname = "{}_{}_".format(has_complication, case_number)
fname += "{NOTE_ID}_{SERVICE_DTM}_{PROV_TYPE}_{NOTE_TYPE}.txt".format(**dict(row))
outpath = os.path.join(outdir, fname)
with open(outpath, 'w') as f:
f.write(helpers.preprocess(row.NOTE))