Update app.py

app.py

@@ -24,21 +24,15 @@
 # SOFTWARE.
 
 
-import click
-from PIL import Image
 import os
 import shutil
 from hashlib import md5
-from multiprocessing import cpu_count
-from joblib import Parallel, delayed
-from tqdm import trange
-from math import log, ceil, pow, sin, cos, pi
-from moviepy.video.io.ImageSequenceClip import ImageSequenceClip
-from moviepy.editor import VideoFileClip, AudioFileClip
-from concurrent.futures import ThreadPoolExecutor
-import concurrent
-from tqdm import tqdm
+from math import ceil, pow, sin, cos, pi
 
+import gradio as gr
+from PIL import Image
+from moviepy.editor import AudioFileClip
+from moviepy.video.io.ImageSequenceClip import ImageSequenceClip
 
 EASING_FUNCTIONS = {
     "linear": lambda x: x,
@@ -108,203 +102,61 @@ def get_px_or_fraction(value, reference_value):
     return int(value)
 
 
-@click.command()
-@click.argument(
-    "image_paths",
-    nargs=-1,
-    type=click.Path(exists=True),
-    required=True,
-)
-@click.option(
-    "-a",
-    "--audio_path",
-    type=click.Path(exists=True, dir_okay=False),
-    default=None,
-    help="Audio file path that will be added to the video.",
-)
-@click.option(
-    "-z",
-    "--zoom",
-    type=float,
-    default=2.0,
-    help="Zoom factor/ratio between images.",
-    show_default=True,
-)
-@click.option(
-    "-d",
-    "--duration",
-    type=float,
-    default=10.0,
-    help="Duration of the video in seconds.",
-    show_default=True,
-)
-@click.option(
-    "-e",
-    "--easing",
-    type=click.Choice(list(EASING_FUNCTIONS.keys())),
-    default=DEFAULT_EASING_KEY,
-    help="Easing function.",
-    show_default=True,
-)
-@click.option(
-    "-r",
-    "--direction",
-    type=click.Choice(["in", "out", "inout", "outin"]),
-    default="out",
-    help="Zoom direction. Inout and outin combine both directions.",
-    show_default=True,
-)
-@click.option(
-    "-o",
-    "--output",
-    type=click.Path(),
-    default="output.mp4",
-    help="Output video file.",
-    show_default=True,
-)
-@click.option(
-    "-t",
-    "--threads",
-    type=int,
-    default=-1,
-    help="Number of threads to use to generate frames. Use values <= 0 for number of available threads on your machine minus the provided absolute value.",
-    show_default=True,
-)
-@click.option(
-    "--tmp-dir",
-    type=click.Path(),
-    default="tmp",
-    help="Temporary directory to store frames.",
-    show_default=True,
-)
-@click.option(
-    "-f",
-    "--fps",
-    type=int,
-    default=30,
-    help="Frames per second of the output video.",
-    show_default=True,
-)
-@click.option(
-    "-w",
-    "--width",
-    type=float,
-    default=1,
-    help="Width of the output video. Values > 1 are interpreted as specific sizes in pixels. Values <= 1 are interpreted as a fraction of the width of the first image.",
-    show_default=True,
-)
-@click.option(
-    "-h",
-    "--height",
-    type=float,
-    default=1,
-    help="Height of the output video. Values > 1 are interpreted as specific sizes in pixels. Values <= 1 are interpreted as a fraction of the height of the first image.",
-    show_default=True,
-)
-@click.option(
-    "-s",
-    "--resampling",
-    type=click.Choice(list(RESAMPLING_FUNCTIONS.keys())),
-    default=DEFAULT_RESAMPLING_KEY,
-    help="Resampling techique to use when resizing images.",
-    show_default=True,
-)
-@click.option(
-    "-m",
-    "--margin",
-    type=float,
-    default=0.05,
-    help="Size of the margin to cut from the edges of each image for better blending with the next/previous image. Values > 1 are interpreted as specific sizes in pixels. Values <= 1 are interpreted as a fraction of the smaller size of the first image.",
-    show_default=True,
-)
-@click.option(
-    "--keep-frames",
-    is_flag=True,
-    default=False,
-    help="Keep frames in the temporary directory. Otherwise, it will be deleted after the video is generated.",
-    show_default=True,
-)
-@click.option(
-    "--skip-video-generation",
-    is_flag=True,
-    default=False,
-    help="Skip video generation. Useful if you only want to generate the frames. This option will keep the temporary directory similar to --keep-frames flag.",
-    show_default=True,
-)
-@click.option(
-    "--reverse-images",
-    is_flag=True,
-    default=False,
-    help="Reverse the order of the images.",
-    show_default=True,
-)
 def zoom_video_composer(
-    image_paths,
-    audio_path=None,
-    zoom=2.0,
-    duration=10.0,
-    easing=DEFAULT_EASING_KEY,
-    direction="out",
-    output="output.mp4",
-    threads=-1,
-    tmp_dir="tmp",
-    fps=30,
-    width=1,
-    height=1,
-    resampling=DEFAULT_RESAMPLING_KEY,
-    margin=0.05,
-    keep_frames=False,
-    skip_video_generation=False,
-    reverse_images=False,
+        image_paths,
+        audio_path,
+        zoom,
+        duration,
+        easing,
+        direction,
+        fps,
+        resampling,
+        reverse_images,
+        progress=gr.Progress()
 ):
     """Compose a zoom video from multiple provided images."""
+    output = "output.mp4"
+    threads = -1
+    tmp_dir = "tmp"
+    width = 1
+    height = 1
+    margin = 0.05
+    keep_frames = False
+    skip_video_generation = False
 
-    # Read images
-    _image_paths = []
-    for image_path in image_paths:
-        if os.path.isfile(image_path):
-            _image_paths.append(image_path)
-        elif os.path.isdir(image_path):
-            for subimage_path in sorted(os.listdir(image_path)):
-                _image_paths.append(os.path.join(image_path, subimage_path))
-    image_paths = _image_paths
-
-    images = []
-    click.echo(f"Reading {len(image_paths)} image files ...")
-    for image_path in image_paths:
-        if not image_path.lower().endswith((".png", ".jpg", ".jpeg", ".webp")):
-            click.echo(f"Unsupported file type: {image_path}, skipping")
-            continue
-
-        image = Image.open(image_path)
-        images.append(image)
+    # Read images from image_paths
+
+    images = list(Image.open(image_path.name) for image_path in image_paths)
 
     if len(images) < 2:
-        raise ValueError("At least two images are required to create a zoom video")
+        raise gr.Error("At least two images are required to create a zoom video")
+        # raise ValueError("At least two images are required to create a zoom video")
+
+    # gr.Info("Images loaded")
+    progress(0, desc="Images loaded")
 
     # Setup some additional variables
     easing_func = EASING_FUNCTIONS.get(easing, None)
     if easing_func is None:
-        raise ValueError(f"Unsupported easing function: {easing}")
+        raise gr.Error(f"Unsupported easing function: {easing}")
+        # raise ValueError(f"Unsupported easing function: {easing}")
 
     resampling_func = RESAMPLING_FUNCTIONS.get(resampling, None)
     if resampling_func is None:
-        raise ValueError(f"Unsupported resampling function: {resampling}")
+        raise gr.Error(f"Unsupported resampling function: {resampling}")
+        # raise ValueError(f"Unsupported resampling function: {resampling}")
 
     num_images = len(images) - 1
     num_frames = int(duration * fps)
     num_frames_half = int(num_frames / 2)
-    tmp_dir_hash = os.path.join(
-        tmp_dir, md5("".join(image_paths).encode("utf-8")).hexdigest()
-    )
-
+    tmp_dir_hash = os.path.join(tmp_dir, md5(output.encode("utf-8")).hexdigest())
     width = get_px_or_fraction(width, images[0].width)
     height = get_px_or_fraction(height, images[0].height)
     margin = get_px_or_fraction(margin, min(images[0].width, images[0].height))
 
     # Create tmp dir
     if not os.path.exists(tmp_dir_hash):
-        click.echo(f"Creating temporary directory for frames: {tmp_dir} ...")
+        progress(0, desc="Creating temporary directory for frames")
         os.makedirs(tmp_dir_hash, exist_ok=True)
 
     if direction in ["out", "outin"]:
@@ -314,38 +166,24 @@ def zoom_video_composer(
         images.reverse()
 
     # Blend images (take care of margins)
-    click.echo(f"Blending {len(images)} images ...")
-    for i in trange(1, num_images + 1):
+    progress(0, desc=f"Blending {len(images)} images")
+    for i in progress.tqdm(range(1, num_images + 1), desc="Blending images"):
         inner_image = images[i]
         outer_image = images[i - 1]
         inner_image = inner_image.crop(
             (margin, margin, inner_image.width - margin, inner_image.height - margin)
         )
 
-        # Some coloring for debugging purposes
-        # debug_colors = ['red', 'green', 'blue', 'yellow', 'cyan', 'magenta']
-        # layer = Image.new('RGB', inner_image.size, debug_colors[i % 6])
-        # inner_image = Image.blend(inner_image, layer, 0.25)
-
         image = zoom_crop(outer_image, zoom, resampling_func)
         image.paste(inner_image, (margin, margin))
         images[i] = image
 
-        # Save image for debugging purposes
-        # image_path = os.path.join(tmp_dir_hash, f"_blending_step_1_{i:06d}.png")
-        # image.save(image_path)
-
     images_resized = [resize_scale(i, zoom, resampling_func) for i in images]
-    for i in trange(num_images, 0, -1):
+    for i in progress.tqdm(range(num_images, 0, -1), desc="Resizing images"):
         inner_image = images_resized[i]
         image = images_resized[i - 1]
         inner_image = resize_scale(inner_image, 1.0 / zoom, resampling_func)
 
-        # Some coloring for debugging purposes
-        # debug_colors = ['red', 'green', 'blue', 'yellow', 'cyan', 'magenta']
-        # layer = Image.new('RGB', inner_image.size, debug_colors[i % 6])
-        # inner_image = Image.blend(inner_image, layer, 0.25)
-
         image.paste(
             inner_image,
             (
@@ -355,10 +193,6 @@ def zoom_video_composer(
         )
         images_resized[i] = image
 
-        # Save image for debugging purposes
-        # image_path = os.path.join(tmp_dir_hash, f"_blending_step_2_{i:06d}.png")
-        # image.save(image_path)
-
     images = images_resized
 
     # Create frames
@@ -401,16 +235,12 @@ def zoom_video_composer(
         frame_path = os.path.join(tmp_dir_hash, f"{i:06d}.png")
         frame.save(frame_path)
 
-    n_jobs = threads if threads > 0 else cpu_count() - threads
-    click.echo(f"Creating frames in {n_jobs} threads ...")
-
-    with ThreadPoolExecutor(max_workers=n_jobs) as executor:
-        futures = [executor.submit(process_frame, i) for i in range(num_frames)]
-        for _ in tqdm(concurrent.futures.as_completed(futures), total=num_frames):
-            pass
+    progress(0, desc=f"Creating {num_frames} frames")
+    for i in progress.tqdm(range(num_frames), desc="Creating frames"):
+        process_frame(i)
 
     # Write video
-    click.echo(f"Writing video to: {output} ...")
+    progress(0, desc=f"Writing video to: {output}")
     image_files = [
         os.path.join(tmp_dir_hash, f"{i:06d}.png") for i in range(num_frames)
     ]
@@ -419,8 +249,9 @@ def zoom_video_composer(
 
     # Add audio
     if audio_path:
-        click.echo(f"Adding audio from: {audio_path} ...")
-        audio_clip = AudioFileClip(audio_path)
+        # audio file name
+        progress(0, desc=f"Adding audio from: {os.path.basename(audio_path.name)}")
+        audio_clip = AudioFileClip(audio_path.name)
         audio_clip = audio_clip.subclip(0, video_clip.end)
         video_clip = video_clip.set_audio(audio_clip)
         video_write_kwargs["audio_codec"] = "aac"
@@ -431,11 +262,37 @@ def zoom_video_composer(
     if not keep_frames and not skip_video_generation:
         shutil.rmtree(tmp_dir_hash, ignore_errors=False, onerror=None)
         if not os.listdir(tmp_dir):
-            click.echo(f"Removing empty temporary directory for frames: {tmp_dir} ...")
+            progress(0, desc=f"Removing empty temporary directory for frames: {tmp_dir} ...")
             os.rmdir(tmp_dir)
-
-    click.echo("Done!")
-
-
-if __name__ == "__main__":
-    zoom_video_composer()
+    return output
+
+
+grInputs = [
+    gr.File(file_count="multiple", label="Upload images as folder", file_types=["image"]),
+    gr.File(file_count="single", label="Upload audio", file_types=["audio"]),
+    gr.inputs.Slider(label="Zoom factor/ratio between images", minimum=1.0, maximum=5.0, step=0.1, default=2.0),
+    gr.inputs.Slider(label="Duration of the video in seconds", minimum=1.0, maximum=60.0, step=1.0, default=10.0),
+    gr.inputs.Dropdown(label="Easing function used for zooming",
+                       choices=["linear", "easeInSine", "easeOutSine", "easeInOutSine", "easeInQuad", "easeOutQuad",
+                                "easeInOutQuad", "easeInCubic", "easeOutCubic", "easeInOutCubic"],
+                       default="easeInOutSine"),
+    gr.inputs.Dropdown(label="Zoom direction. Inout and outin combine both directions",
+                       choices=["in", "out", "inout", "outin"], default="out"),
+    gr.inputs.Slider(label="Frames per second of the output video", minimum=1, maximum=60, step=1, default=30),
+    gr.inputs.Dropdown(label="Resampling technique used for resizing images",
+                       choices=["nearest", "box", "bilinear", "hamming", "bicubic", "lanczos"], default="lanczos"),
+    gr.inputs.Checkbox(label="Reverse images", default=False)
+]
+
+iface = gr.Interface(
+    fn=zoom_video_composer,
+    inputs=grInputs,
+    outputs=[gr.outputs.Video(label="Video")],
+    title="Zoom Video Composer",
+    description="Compose a zoom video from multiple provided images.",
+    allow_flagging=False,
+    allow_screenshot=True,
+    allow_embedding=True,
+    allow_download=True)
+
+iface.queue(concurrency_count=10).launch()