class VideoStabiliser: """ Class used to stabilise the recorded video for more optimal matching. """ def __init__(self, directory, file_name): """ Initialise variables and call the function to stabilise the specified video. :param directory: the directory where the video file to stabilise is located :param file_name: the mp4 video file's name """ self.directory = directory self.file = file_name self.new_file = file_name[:-4] self.stabiliser = VidStab() self.stabilise_video() @make_spin(Box1, "Stabilising video...") def stabilise_video(self): """ Stabilises a mp4 video and outputs the result as an avi file in the same directory. :return: """ self.stabiliser.stabilize( input_path="{}{}".format(self.directory, self.file), output_path="{}/stable-{}.avi".format(self.directory, self.new_file), border_type="reflect") print("\nVideo stabilised!")
def test_video_dep_funcs_run(self): # just tests to check functions run # input_vid = 'https://s3.amazonaws.com/python-vidstab/trunc_video.avi' input_vid = local_trunc_vid stabilizer = VidStab() stabilizer.gen_transforms(input_vid, smoothing_window=1, show_progress=True) self.assertEqual(stabilizer.smoothed_trajectory.shape, stabilizer.trajectory.shape, 'trajectory/transform obj shapes') self.assertEqual(stabilizer.transforms.shape, stabilizer.trajectory.shape, 'trajectory/transform obj shapes') with tempfile.TemporaryDirectory() as tmpdir: output_vid = '{}/test_output.avi'.format(tmpdir) try: stabilizer.apply_transforms(input_vid, output_vid) except Exception as e: self.fail("stabilizer.apply_transforms ran into {}".format(e)) try: stabilizer.stabilize(input_vid, output_vid, smoothing_window=1) except Exception as e: self.fail("stabilizer.stabilize ran into {}".format(e))
def test_trajectory_transform_values(): for window in [15, 30, 60]: stabilizer = VidStab(processing_max_dim=float('inf')) stabilizer.stabilize(input_path=OSTRICH_VIDEO, output_path='stable.avi', smoothing_window=window) pickle_test_transforms(stabilizer, 'pickled_transforms') check_transforms(stabilizer, is_cv4=imutils.is_cv4())
def test_writer_reset(): path_1 = 'stable_1.avi' path_2 = 'stable_2.avi' stabilizer = VidStab() stabilizer.stabilize(OSTRICH_VIDEO, path_1, max_frames=16, smoothing_window=1) stabilizer.stabilize(OSTRICH_VIDEO, path_2, max_frames=16, smoothing_window=1) assert os.path.exists(path_1) assert os.path.exists(path_2)
def video_stabilizer(input_video_filepath, output_video_filepath): # input_video_filepath = glob.glob('/home/afarahani/Projects/output/*') # output_video_filepath = '/home/afarahani/Projects/stab_output/' for video_path in input_video_filepath: head, tail = os.path.split(video_path) stabilizer = VidStab() # black borders stabilizer.stabilize(input_path=video_path, output_path=output_video_filepath+tail, border_type='black')
def main(original_video_file, stabilized_video_file): stabilizer = VidStab() stabilizer.stabilize(input_path=original_video_file, output_path=stabilized_video_file) stabilizer.plot_trajectory() plt.show() stabilizer.plot_transforms() plt.show()
def stabilize_video(): stabilizer = VidStab() stabilizer.stabilize(input_path='static/Uploads/file.mp4', output_path='static/Output/stable_video.avi') stabilizer.plot_trajectory() plt.savefig('static/img/plot_trajectory.png') stabilizer.plot_transforms() plt.savefig('static/img/plot_transforms.png') return ('________________Completed convertion_____________')
def test_video_dep_funcs_run(): # just tests to check functions run stabilizer = VidStab() stabilizer.gen_transforms(TRUNCATED_OSTRICH_VIDEO, smoothing_window=2, show_progress=True) assert stabilizer.smoothed_trajectory.shape == stabilizer.trajectory.shape assert stabilizer.transforms.shape == stabilizer.trajectory.shape with tempfile.TemporaryDirectory() as tmpdir: output_vid = '{}/test_output.avi'.format(tmpdir) stabilizer.apply_transforms(TRUNCATED_OSTRICH_VIDEO, output_vid) stabilizer.stabilize(TRUNCATED_OSTRICH_VIDEO, output_vid, smoothing_window=2)
def run(self): for vid in self.vids: out_vid = os.path.join(self.output_path, os.path.basename(vid)) if os.path.isfile(out_vid): continue try: stabilizer = VidStab() stabilizer.stabilize(input_path=vid, output_path=out_vid) except: print ("error in ", vid) shutil.copy(vid, out_vid)
def test_max_frames(): max_frames = 16 with tempfile.TemporaryDirectory() as tmpdir: output_path = '{}/stable_1.avi'.format(tmpdir) stabilizer = VidStab() stabilizer.stabilize(OSTRICH_VIDEO, output_path, max_frames=max_frames, smoothing_window=1) output_frame_count = imutils.video.count_frames(output_path) assert max_frames == output_frame_count
def test_invalid_input_path(): stabilizer = VidStab(kp_method='FAST', threshold=42, nonmaxSuppression=False) with pytest.raises(FileNotFoundError) as err: stabilizer.gen_transforms("fake_input_path.mp4") assert "fake_input_path.mp4 does not exist" in str(err.value) with pytest.raises(FileNotFoundError) as err: stabilizer.stabilize("fake_input_path.mp4", "output.avi") assert "fake_input_path.mp4 does not exist" in str(err.value)
def stabilize_video(source, video, destination_folder): input_video_path = source + '/' + video output_file_path = destination_folder + "/" + \ os.path.basename(video).split('.')[-2] + "_stabilized.mp4" print("Video to be stabilized:" + input_video_path) stabilizer = VidStab(kp_method='FAST') stabilizer.stabilize(input_path=input_video_path, output_path=output_file_path, border_type='black') print("Output file is ready: " + output_file_path)
def test_output_fps(): force_fps = 10 with tempfile.TemporaryDirectory() as tmpdir: output_vid = '{}/test_output.avi'.format(tmpdir) stabilizer = VidStab() stabilizer.stabilize(OSTRICH_VIDEO, output_vid, max_frames=16, smoothing_window=1, output_fps=force_fps) output_fps = cv2.VideoCapture(output_vid).get(cv2.CAP_PROP_FPS) assert force_fps == output_fps
class VideoStabiliser: def __init__(self, directory, file_name): """Initialise variables and start stabilising""" self.directory = directory self.file = file_name self.new_file = file_name[:-4] self.stabiliser = VidStab() self.stabilise_video() @make_spin(Box1, "Stabilising video...") def stabilise_video(self): self.stabiliser.stabilize( input_path="{}{}".format(self.directory, self.file), output_path="{}/stable-{}.avi".format(self.directory, self.new_file), border_type="reflect") print("\nVideo stabilised!")
def test_invalid_input_path(): stabilizer = VidStab(kp_method='FAST', threshold=42, nonmaxSuppression=False) with pytest.raises(FileNotFoundError) as err: stabilizer.gen_transforms('fake_input_path.mp4') assert 'fake_input_path.mp4 does not exist' in str(err.value) with pytest.raises(FileNotFoundError) as err: stabilizer.stabilize('fake_input_path.mp4', 'output.avi') assert 'fake_input_path.mp4 does not exist' in str(err.value) with pytest.raises(ValueError) as err: tmp_file = tempfile.NamedTemporaryFile(suffix='.mp4') with pytest.warns(UserWarning, match='No progress bar will be shown'): stabilizer.stabilize(tmp_file.name, 'output.avi') assert 'First frame is None' in str(err.value)
def lambda_handler(event, context): bucket = event['Records'][0]['s3']['bucket']['name'] key = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'], encoding='utf-8') if VIDSTAB_ERROR is not None: raise VIDSTAB_ERROR try: in_path = download_file(bucket, key) out_path = "/tmp/out_{}".format(key) head_response = s3.head_object(Bucket=bucket, Key=key) size = head_response['ContentLength'] content_type = head_response['ContentType'] if size <= MAX_SIZE: # Do the stabilization if content_type[0:5] == "video": stabilizer = VidStab(kp_method=KP_METHOD) if BORDER_TYPE == "black": stabilizer.stabilize(input_path=in_path, output_path=out_path, border_type=BORDER_TYPE, border_size=BORDER_SIZE) else: stabilizer.stabilize(input_path=in_path, output_path=out_path, border_type=BORDER_TYPE) return upload_file(OUTPUT_BUCKET, key, out_path) else: raise IOError("Object {} from bucket {} ".format(key, bucket) + "is not a video.") else: raise IOError("Object {} from bucket {} ".format(key, bucket) + "exceeds max allowable size for stabilization.") except IOError as e: logger.exception("IOError occurred during lambda handling") raise e except Exception as e: logger.exception( "Error processing object {} from bucket {}. ".format(key, bucket) + "Make sure your object and bucket exist and your bucket is in the same region as this function." ) raise e
def test_video_dep_funcs_run(): # just tests to check functions run stabilizer = VidStab() stabilizer.gen_transforms(local_trunc_vid, smoothing_window=2, show_progress=True) assert stabilizer.smoothed_trajectory.shape == stabilizer.trajectory.shape assert stabilizer.transforms.shape == stabilizer.trajectory.shape with tempfile.TemporaryDirectory() as tmpdir: output_vid = '{}/test_output.avi'.format(tmpdir) try: stabilizer.apply_transforms(local_trunc_vid, output_vid) except Exception as e: pytest.fail("stabilizer.apply_transforms ran into {}".format(e)) try: stabilizer.stabilize(local_trunc_vid, output_vid, smoothing_window=2) except Exception as e: pytest.fail("stabilizer.stabilize ran into {}".format(e))
def test_invalid_input_path(): stabilizer = VidStab(kp_method='FAST', threshold=42, nonmaxSuppression=False) with pytest.raises(FileNotFoundError) as err: stabilizer.gen_transforms("fake_input_path.mp4") assert "fake_input_path.mp4 does not exist" in str(err.value) with pytest.raises(FileNotFoundError) as err: stabilizer.stabilize("fake_input_path.mp4", "output.avi") assert "fake_input_path.mp4 does not exist" in str(err.value) with pytest.raises(ValueError) as err: tmp_file = tempfile.NamedTemporaryFile(suffix=".mp4") stabilizer.stabilize(tmp_file.name, "output.avi") assert "First frame is None" in str(err.value)
def test_writer_reset(): with tempfile.TemporaryDirectory() as tmpdir: path_1 = '{}/stable_1.avi'.format(tmpdir) path_2 = '{}/stable_2.avi'.format(tmpdir) stabilizer = VidStab() stabilizer.stabilize(OSTRICH_VIDEO, path_1, max_frames=16, smoothing_window=1) stabilizer.stabilize(OSTRICH_VIDEO, path_2, max_frames=16, smoothing_window=1) assert os.path.exists(path_1) assert os.path.exists(path_2) imutils.video.count_frames(path_1)
def vidstab(input_path, output_path, kp_method='GFTT', smoothing_window=30, border_type='black', border_size=0): # stabilizer = VidStab(kp_method='FAST', threshold=42, nonmaxSuppression=False) # Using different parameters stabilizer = VidStab(kp_method=kp_method) # Default stabilizer.stabilize(input_path=input_path, output_path=output_path, smoothing_window=smoothing_window, border_type=border_type, border_size=border_size) stabilizer.plot_trajectory() plt.show() stabilizer.plot_transforms() plt.show() return
def adam_spanbaauer(video_pth: str, debug: bool = False): if os.path.exists('../.cache/default_stable_video.avi'): print("Cached Video") out = cv2.VideoCapture('../.cache/default_stable_video.avi') else: # Using defaults stabilizer = VidStab() stabilizer.stabilize(input_path=video_pth, output_path='../.cache/default_stable_video.avi') # Using a specific keypoint detector stabilizer = VidStab(kp_method='ORB') stabilizer.stabilize(input_path=video_pth, output_path='../.cache/ORB_stable_video.avi') # Using a specific keypoint detector and customizing keypoint parameters stabilizer = VidStab(kp_method='FAST', threshold=42, nonmaxSuppression=False) stabilizer.stabilize(input_path=video_pth, output_path='../.cache/FAST_stable_video.avi') out = cv2.VideoCapture('../.cache/default_stable_video.avi') if debug: stabilizer.plot_trajectory() plt.show() stabilizer.plot_transforms() plt.show() generate_frames(out, "adam")
# remote_ostrich_vid = 'https://s3.amazonaws.com/python-vidstab/ostrich.mp4' # local_ostrich_vid = '{}/ostrich.mp4'.format(tmp_dir.name) # urlretrieve(remote_ostrich_vid, local_ostrich_vid) # local_vid = local_ostrich_vid remote_skateline_vid = 'https://s3.amazonaws.com/python-vidstab/thrasher.mp4' local_skateline_vid = '{}/skateline.mp4'.format(tmp_dir.name) urlretrieve(remote_skateline_vid, local_skateline_vid) local_vid = local_skateline_vid # set params for test stabilization input_path = local_vid border_type = 'black' border_size = 'auto' layer_func = layer_overlay playback = True stabilizer = VidStab() stabilizer.stabilize(input_path, '{}/stable.avi'.format(tmp_dir.name), border_type=border_type, border_size=border_size, layer_func=layer_func, playback=playback) stabilizer.plot_transforms() plt.show() stabilizer.plot_transforms(radians=True) plt.show()
import cv2 import numpy as np from vidstab import VidStab stabilizer = VidStab() stabilizer.stabilize(input_path="Mouth.mp4", output_path="Stablize head.mp4", output_fourcc="mp4v", smoothing_window=100) print("Video is stabilized")
from vidstab import VidStab import matplotlib.pyplot as plt import os import cv2 stabilizer = VidStab() stabilizer.stabilize(input_path='video_seq_1.avi', output_path='stable_video.avi') # Image Feature Extractionn using Key Point Detection ############################################## stabilizer = VidStab(kp_method='ORB') stabilizer.stabilize(input_path='video_seq_1.avi', output_path='stable_video.avi', border_type='black') stabilizer = VidStab(kp_method='FAST', threshold=42, nonmaxSuppression=False) stabilizer.stabilize(input_path='video_seq_1.avi', output_path='stable_video.avi', border_type='black', border_size=100) ############################################## #Plotting frame to frame transformations stabilizer.plot_trajectory() plt.show() stabilizer.plot_transforms() plt.show() ##############################################
# stabilizer.stabilize(input_path=input_vid, # output_path='rep_stable_video.avi', # border_type='replicate', # border_size=100) # # # reflected border # stabilizer.stabilize(input_path=input_vid, # output_path='ref_stable_video.avi', # border_type='reflect', # border_size=100) # USING LAYERING FUNCTIONS # trail of frames stabilizer.stabilize(input_path=input_vid, output_path='trail_stable_video.avi', border_type='black', border_size=100, layer_func=layer_overlay) def layer_custom(foreground, background): return layer_blend(foreground, background, foreground_alpha=.8) stabilizer.stabilize(input_path=input_vid, output_path='blend_stable_video.avi', border_type='black', border_size=100, layer_func=layer_custom)
# border_size='auto', # playback=True) ################################################################## # TEST TYPICAL STABILIZATION PROCESS ################################################################## download_to_path = f'{tmp_dir.name}/test_video.mp4' dl.download_ostrich_video(download_to_path) # dl.download_skateline_video(download_to_path) stabilizer = VidStab() stabilizer.stabilize(download_to_path, 'stable.avi', # max_frames=30, border_type='black', border_size='auto', layer_func=layer_overlay, playback=True) ################################################################## # TEST PLOT OUTPUT ################################################################## # import matplotlib.pyplot as plt # # download_to_path = f'{tmp_dir.name}/test_video.mp4' # dl.download_ostrich_video(download_to_path) # stabilizer = VidStab() # stabilizer.gen_transforms(download_to_path) # # stabilizer.plot_transforms()
"""Playback tests for visual inspection of output """ import tempfile from vidstab import VidStab import matplotlib.pyplot as plt input_path = 'readme/ostrich.mp4' border_type = 'reflect' border_size = 'auto' layer_func = None playback = False tmp_dir = tempfile.TemporaryDirectory() output_path = '{}/stable.avi'.format(tmp_dir.name) stabilizer = VidStab() stabilizer.stabilize(input_path, output_path, border_type=border_type, border_size=border_size, layer_func=layer_func, playback=playback) stabilizer.plot_transforms() plt.show() stabilizer.plot_transforms(radians=True) plt.show()
# local_vid = '/home/som/data/OCT/videostab_results/shaky_car_MATLAB/original_vid.avi' # local_vid = '/home/som/Downloads/Bscan/video_orig.avi' # local_vid = '/home/som/Downloads/Bscan/video_Bscan46_bilateral_19_19.avi' # stab_local_trunc_vid = '{}/stab_trunc_vid.avi'.format(tmp_dir) # stab_local_vid = '{}/stab_vid.avi'.format(tmp_dir) # stab_local_vid = '/home/som/Downloads/SequenceOfBscanForSom/SequenceOfBscan_Niksa_20181109/video_stab_orig_2.avi' # stab_local_vid = '/home/som/data/OCT/videostab_results/shaky_car_MATLAB/stab_vid_vidstab_2.avi' # stab_local_vid = '/home/som/Downloads/Bscan/stab_video_orig.avi' # stab_local_vid = '/home/som/Downloads/Bscan/stab_video_Bscan46_bilateral_19_19.avi' # urlretrieve(remote_trunc_vid, local_trunc_vid) # urlretrieve(remote_vid, local_vid) stabilizer = VidStab(kp_method='ORB',stab_algo=args.stab_algo,scale=args.scale) print("stab_algo:",stabilizer.stab_algo) stabilizer.stabilize(input_path=local_vid, output_path=stab_local_vid,smoothing_window=args.smoothing_window,playback=True,border_type='replicate',max_frames=args.max_frames) sys.path.append('/home/som/code/Video-Stabilization/src/functs/') from stabFuncts import * # ITF ITF_crop_flag = False if args.live: local_vid = stab_local_vid[:-4]+'_input.avi' print("ITF of input video", getITF(local_vid,crop=ITF_crop_flag)) print("ITF of stabilized video", getITF(stab_local_vid,crop=ITF_crop_flag)) os.system("python Movie2Frame.py --in-file-name {} --max-frames 10 --write-gray".format(local_vid.split('/')[-1])) frame_filename=local_vid[:-4]+'/frame8_'+local_vid[:-4].split('/')[-1]+'.jpg' print("filename of frame of input video:",frame_filename)