Update app.py

app.py

@@ -170,31 +170,41 @@ def infer(image, width=1024, height=1024, overlap_width=18, num_inference_steps=
 
     yield background, cnet_image
 
-def create_zoom_in_frames(larger_frame, smaller_frame, num_intermediate_frames):
-    """
-    Create intermediate frames for a smooth zoom-in effect from the larger frame to the smaller frame.
-    """
-    larger_frame = np.array(larger_frame)
-    smaller_frame = np.array(smaller_frame)
-    h, w = larger_frame.shape[:2]
-    frames = []
-
-    for i in range(num_intermediate_frames + 2):
-        progress = i / (num_intermediate_frames + 1)
-        # Calculate the size of the frame to crop from the larger image
-        crop_h = int(h * (1 - progress) + smaller_frame.shape[0] * progress)
-        crop_w = int(w * (1 - progress) + smaller_frame.shape[1] * progress)
+def create_zoom_animation(previous_frame, next_frame, steps):
+    
+    # List to store all frames
+    interpolated_frames = []
+    
+    for i in range(steps + 1):
+        t = i / steps  # Normalized time between 0 and 1
+        
+        # Compute zoom factor (from 1 to 2)
+        z = 1 + t  # Zoom factor increases from 1 to 2
+        
+        # Compute crop size
+        crop_size = int(1024 / z)
         
-        # Crop the center of the larger frame
-        start_y = (h - crop_h) // 2
-        start_x = (w - crop_w) // 2
-        cropped = larger_frame[start_y:start_y+crop_h, start_x:start_x+crop_w]
+        # Compute crop coordinates to center the crop
+        x0 = (1024 - crop_size) // 2
+        y0 = (1024 - crop_size) // 2
+        x1 = x0 + crop_size
+        y1 = y0 + crop_size
         
-        # Resize the cropped image to match the smaller frame's size
-        interpolated = Image.fromarray(cropped).resize(smaller_frame.shape[:2][::-1], Image.LANCZOS)
-        frames.append(interpolated)
+        # Crop the previous_frame
+        cropped_prev = previous_frame.crop((x0, y0, x1, y1))
+        # Resize to 512x512
+        resized_prev = cropped_prev.resize((512, 512), Image.LANCZOS)
+        
+        # For the last frame, use the next_frame resized to 512x512
+        if i == steps:
+            resized_frame = next_frame.resize((512, 512), Image.LANCZOS)
+        else:
+            resized_frame = resized_prev
+        
+        # Append the resized frame to the list
+        interpolated_frames.append(resized_frame)
 
-    return frames
+    return interpolated_frames
 
 def create_video_from_images(image_list, fps=4):
     if not image_list:
@@ -216,12 +226,17 @@ def create_video_from_images(image_list, fps=4):
 
 @spaces.GPU(duration=70)
 def loop_outpainting(image, width=1024, height=1024, overlap_width=18, num_inference_steps=8, 
-                     resize_option="custom", custom_resize_size=768, prompt_input=None, 
-                     alignment="Middle", num_iterations=18, fps=6, num_interpolation_frames=5,
+                     resize_option="custom", custom_resize_size=512, prompt_input=None, 
+                     alignment="Middle", num_iterations=18, fps=6, num_interpolation_frames=10,
                      progress=gr.Progress()):
-    image_list = [image]
     current_image = image
-
+    if(current_image.width != 1024 or current_image.height != 1024):
+        for first_result in infer(current_image, 1024, 1024, overlap_width, num_inference_steps, 
+                                 resize_option, 1024, prompt_input, alignment):
+            pass
+        current_image = first_result[1] 
+        
+    image_list = [current_image]
     for _ in progress.tqdm(range(num_iterations), desc="Generating frames"):
         # Generate new image
         for step_result in infer(current_image, width, height, overlap_width, num_inference_steps, 
@@ -242,7 +257,7 @@ def loop_outpainting(image, width=1024, height=1024, overlap_width=18, num_infer
     for i in range(len(reverse_image_list) - 1):
         larger_frame = reverse_image_list[i]
         smaller_frame = reverse_image_list[i + 1]
-        interpolated_frames = create_zoom_in_frames(larger_frame, smaller_frame, num_interpolation_frames)
+        interpolated_frames = create_zoom_animation(larger_frame, smaller_frame, num_interpolation_frames)
         final_frame_list.extend(interpolated_frames)
     
     # Add the last frame
@@ -368,10 +383,10 @@ with gr.Blocks(css=css) as demo:
                                 visible=False
                             )
                         with gr.Row():
-                            num_iterations = gr.Slider(label="Number of iterations", minimum=2, maximum=24, step=1, value=18)
+                            num_iterations = gr.Slider(label="Number of iterations", minimum=2, maximum=24, step=1, value=6)
                             fps = gr.Slider(label="fps", minimum=1, maximum=24, value=8)
                         with gr.Row():
-                            num_interpolation_frames = gr.Slider(label="Interpolation frames", minimum=0, maximum=10, step=1, value=5)
+                            num_interpolation_frames = gr.Slider(label="Interpolation frames", minimum=0, maximum=10, step=1, value=10)
 
             with gr.Column():
                 result = ImageSlider(