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