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")
def test_kp_options(self):
stabilizer = VidStab(kp_method='FAST', threshold=42, nonmaxSuppression=False)
self.assertFalse(stabilizer.kp_detector.getNonmaxSuppression(), 'FAST kp non-max suppression flag')
self.assertEqual(stabilizer.kp_detector.getThreshold(), 42, 'FAST kp custom threshold')
with self.assertRaises(TypeError) as err:
VidStab(kp_method='FAST', fake='fake')
self.assertTrue(isinstance(err.exception, TypeError), 'reject bad kwargs')
def test_kp_options():
stabilizer = VidStab(kp_method='FAST', threshold=42, nonmaxSuppression=False)
assert not stabilizer.kp_detector.getNonmaxSuppression()
assert stabilizer.kp_detector.getThreshold() == 42
with pytest.raises(TypeError) as err:
VidStab(kp_method='FAST', fake='fake')
assert 'invalid keyword argument' in str(err.value)
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()
def test_trajectory_transform_values(self):
# input_vid = 'https://s3.amazonaws.com/python-vidstab/ostrich.mp4'
input_vid = local_vid
base_url = 'https://s3.amazonaws.com/python-vidstab'
stabilizer = VidStab()
for window in [15, 30, 60]:
stabilizer.gen_transforms(input_path=input_vid,
smoothing_window=window)
transform_file = '{}/ostrich_transforms_{}.pickle'.format(
base_url, window)
trajectory_file = '{}/ostrich_trajectory_{}.pickle'.format(
base_url, window)
smooth_trajectory_file = '{}/ostrich_smooth_trajectory_{}.pickle'.format(
base_url, window)
with urlopen(transform_file) as f:
expected_transforms = pickle.load(f)
with urlopen(trajectory_file) as f:
expected_trajectory = pickle.load(f)
with urlopen(smooth_trajectory_file) as f:
expected_smooth_trajectory = pickle.load(f)
self.assertTrue(
np.allclose(stabilizer.transforms, expected_transforms))
self.assertTrue(
np.allclose(stabilizer.trajectory, expected_trajectory))
self.assertTrue(
np.allclose(stabilizer.smoothed_trajectory,
expected_smooth_trajectory))
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_trajectory_transform_values():
for window in [15, 30, 60]:
stabilizer = VidStab()
stabilizer.gen_transforms(input_path=OSTRICH_VIDEO,
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 __init__(self, camera, camera_rasp, show_image):
self.LAT_LONG = [0.0, 0.0, 0.0, 0.0]
self.LIMIT = 6
self.DISTANCE = 15
self.SIZE = 480
self.CODE, self.READ_CODE = '', ''
self.CAMERA = camera
self.show_image = show_image
self.camera_rasp = camera_rasp
self.stabilizer = VidStab()
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 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 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 __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()
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 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_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 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_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
def test_trajectory_transform_values():
for window in [15, 30, 60]:
stabilizer = VidStab()
stabilizer.gen_transforms(input_path=ostrich_video,
smoothing_window=window)
pickle_test_transforms(stabilizer, 'pickled_transforms')
unpickled_transforms = download_pickled_transforms(
window, cv4=imutils.is_cv4())
assert np.allclose(stabilizer.transforms, unpickled_transforms[0])
assert np.allclose(stabilizer.trajectory, unpickled_transforms[1])
assert np.allclose(stabilizer.smoothed_trajectory,
unpickled_transforms[2])
def test_stabilize_frame():
# Init stabilizer and video reader
stabilizer = VidStab(processing_max_dim=float('inf'))
vidcap = cv2.VideoCapture(OSTRICH_VIDEO)
window_size = 30
while True:
_, frame = vidcap.read()
# Pass frame to stabilizer even if frame is None
stabilized_frame = stabilizer.stabilize_frame(
input_frame=frame, smoothing_window=window_size, border_size=10)
if stabilized_frame is None:
break
check_transforms(stabilizer, is_cv4=imutils.is_cv4())
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_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 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 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 test_resize():
# Init stabilizer and video reader
max_dim = 30
stabilizer = VidStab(processing_max_dim=max_dim)
assert stabilizer.processing_max_dim == max_dim
# noinspection PyProtectedMember
assert stabilizer._processing_resize_kwargs == {}
vidcap = cv2.VideoCapture(OSTRICH_VIDEO)
_, frame = vidcap.read()
_ = stabilizer.stabilize_frame(input_frame=frame, smoothing_window=1)
_, frame = vidcap.read()
stabilized_frame = stabilizer.stabilize_frame(input_frame=frame, smoothing_window=1)
assert stabilized_frame.shape == (446, 876, 3)
assert max(stabilizer.prev_gray.shape) <= max_dim
# noinspection PyProtectedMember
assert stabilizer._processing_resize_kwargs == {'width': max_dim}
def test_stabilize_frame():
# Init stabilizer and video reader
stabilizer = VidStab()
vidcap = cv2.VideoCapture(ostrich_video)
window_size = 30
while True:
grabbed_frame, frame = vidcap.read()
# Pass frame to stabilizer even if frame is None
stabilized_frame = stabilizer.stabilize_frame(
input_frame=frame, smoothing_window=window_size, border_size=10)
if stabilized_frame is None:
break
unpickled_transforms = download_pickled_transforms(window_size,
cv4=imutils.is_cv4())
assert np.allclose(stabilizer.transforms, unpickled_transforms[0])
assert np.allclose(stabilizer.trajectory, unpickled_transforms[1])
assert np.allclose(stabilizer.smoothed_trajectory, unpickled_transforms[2])