Apply black

app.py

@@ -19,10 +19,8 @@ import warnings
 
 from gradio_demo.utils_drag import *
 from models_diffusers.controlnet_svd import ControlNetSVDModel
-from models_diffusers.unet_spatio_temporal_condition import \
-    UNetSpatioTemporalConditionModel
-from pipelines.pipeline_stable_video_diffusion_interp_control import \
-    StableVideoDiffusionInterpControlPipeline
+from models_diffusers.unet_spatio_temporal_condition import UNetSpatioTemporalConditionModel
+from pipelines.pipeline_stable_video_diffusion_interp_control import StableVideoDiffusionInterpControlPipeline
 
 print("gr file", gr.__file__)
 
@@ -43,6 +41,7 @@ snapshot_download(
 
 def get_args():
     import argparse
+
     parser = argparse.ArgumentParser()
 
     parser.add_argument("--min_guidance_scale", type=float, default=1.0)
@@ -55,11 +54,12 @@ def get_args():
     parser.add_argument(
         "--dataset",
         type=str,
-        default='videoswap',
+        default="videoswap",
     )
 
     parser.add_argument(
-        "--model", type=str,
+        "--model",
+        type=str,
         default="checkpoints/framer_512x320",
         help="Path to model.",
     )
@@ -112,27 +112,34 @@ def interpolate_trajectory(points, n_points):
 
 def gen_gaussian_heatmap(imgSize=200):
     circle_img = np.zeros((imgSize, imgSize), np.float32)
-    circle_mask = cv2.circle(circle_img, (imgSize//2, imgSize//2), imgSize//2, 1, -1)
+    circle_mask = cv2.circle(circle_img, (imgSize // 2, imgSize // 2), imgSize // 2, 1, -1)
 
     isotropicGrayscaleImage = np.zeros((imgSize, imgSize), np.float32)
 
     for i in range(imgSize):
         for j in range(imgSize):
-            isotropicGrayscaleImage[i, j] = 1 / 2 / np.pi / (40 ** 2) * np.exp(
-                -1 / 2 * ((i - imgSize / 2) ** 2 / (40 ** 2) + (j - imgSize / 2) ** 2 / (40 ** 2)))
+            isotropicGrayscaleImage[i, j] = (
+                1
+                / 2
+                / np.pi
+                / (40**2)
+                * np.exp(-1 / 2 * ((i - imgSize / 2) ** 2 / (40**2) + (j - imgSize / 2) ** 2 / (40**2)))
+            )
 
     isotropicGrayscaleImage = isotropicGrayscaleImage * circle_mask
     isotropicGrayscaleImage = (isotropicGrayscaleImage / np.max(isotropicGrayscaleImage)).astype(np.float32)
-    isotropicGrayscaleImage = (isotropicGrayscaleImage / np.max(isotropicGrayscaleImage)*255).astype(np.uint8)
+    isotropicGrayscaleImage = (isotropicGrayscaleImage / np.max(isotropicGrayscaleImage) * 255).astype(np.uint8)
 
     return isotropicGrayscaleImage
 
 
 def get_vis_image(
-        target_size=(512 , 512), points=None,  side=20,
-        num_frames=14,
-        # original_size=(512 , 512), args="", first_frame=None, is_mask = False, model_id=None,
-    ):
+    target_size=(512, 512),
+    points=None,
+    side=20,
+    num_frames=14,
+    # original_size=(512 , 512), args="", first_frame=None, is_mask = False, model_id=None,
+):
 
     # images = []
     vis_images = []
@@ -140,13 +147,13 @@ def get_vis_image(
 
     trajectory_list = []
     radius_list = []
-    
+
     for index, point in enumerate(points):
         trajectories = [[int(i[0]), int(i[1])] for i in point]
         trajectory_list.append(trajectories)
 
         radius = 20
-        radius_list.append(radius)  
+        radius_list.append(radius)
 
     if len(trajectory_list) == 0:
         vis_images = [Image.fromarray(np.zeros(target_size, np.uint8)) for _ in range(num_frames)]
@@ -156,33 +163,39 @@ def get_vis_image(
         new_img = np.zeros(target_size, np.uint8)
         vis_img = new_img.copy()
         # ids_embedding = torch.zeros((target_size[0], target_size[1], 320))
-        
+
         if idxx >= args.num_frames:
             break
 
         # for cc, (mask, trajectory, radius) in enumerate(zip(mask_list, trajectory_list, radius_list)):
         for cc, (trajectory, radius) in enumerate(zip(trajectory_list, radius_list)):
-            
+
             center_coordinate = trajectory[idxx]
             trajectory_ = trajectory[:idxx]
             side = min(radius, 50)
- 
-            y1 = max(center_coordinate[1] - side,0)
+
+            y1 = max(center_coordinate[1] - side, 0)
             y2 = min(center_coordinate[1] + side, target_size[0] - 1)
             x1 = max(center_coordinate[0] - side, 0)
             x2 = min(center_coordinate[0] + side, target_size[1] - 1)
-            
-            if x2-x1>3 and y2-y1>3:
-                need_map = cv2.resize(heatmap, (x2-x1, y2-y1))
+
+            if x2 - x1 > 3 and y2 - y1 > 3:
+                need_map = cv2.resize(heatmap, (x2 - x1, y2 - y1))
                 new_img[y1:y2, x1:x2] = need_map.copy()
-                
+
                 if cc >= 0:
-                    vis_img[y1:y2,x1:x2] = need_map.copy()
+                    vis_img[y1:y2, x1:x2] = need_map.copy()
                     if len(trajectory_) == 1:
                         vis_img[trajectory_[0][1], trajectory_[0][0]] = 255
                     else:
-                        for itt in range(len(trajectory_)-1):
-                            cv2.line(vis_img, (trajectory_[itt][0], trajectory_[itt][1]), (trajectory_[itt+1][0], trajectory_[itt+1][1]), (255, 255, 255), 3)
+                        for itt in range(len(trajectory_) - 1):
+                            cv2.line(
+                                vis_img,
+                                (trajectory_[itt][0], trajectory_[itt][1]),
+                                (trajectory_[itt + 1][0], trajectory_[itt + 1][1]),
+                                (255, 255, 255),
+                                3,
+                            )
 
         img = new_img
 
@@ -193,7 +206,7 @@ def get_vis_image(
         elif len(img.shape) == 3 and img.shape[2] == 3:  # Color image in BGR format
             img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
             vis_img = cv2.cvtColor(vis_img, cv2.COLOR_BGR2RGB)
-            
+
         # Convert the numpy array to a PIL image
         # pil_img = Image.fromarray(img)
         # images.append(pil_img)
@@ -214,7 +227,7 @@ def frames_to_video(frames_folder, output_video_path, fps=7):
         video.append(frame)
 
     video = torch.stack(video)
-    video = rearrange(video, 'T C H W -> T H W C')
+    video = rearrange(video, "T C H W -> T H W C")
     torchvision.io.write_video(output_video_path, video, fps=fps)
 
 
@@ -222,11 +235,12 @@ def save_gifs_side_by_side(
     batch_output,
     validation_control_images,
     output_folder,
-    target_size=(512 , 512),
+    target_size=(512, 512),
     duration=200,
     point_tracks=None,
 ):
     flattened_batch_output = batch_output
+
     def create_gif(image_list, gif_path, duration=100):
         pil_images = [validate_and_convert_image(img, target_size=target_size) for img in image_list]
         pil_images = [img for img in pil_images if img is not None]
@@ -242,7 +256,7 @@ def save_gifs_side_by_side(
             tmp_frame_path = os.path.join(tmp_folder, f"{idx}.png")
             pil_image.save(tmp_frame_path)
             tmp_frame_list.append(tmp_frame_path)
-        
+
         # also save as mp4
         output_video_path = gif_path.replace(".gif", ".mp4")
         frames_to_video(tmp_folder, output_video_path, fps=7)
@@ -285,25 +299,25 @@ def save_gifs_side_by_side(
         if output_path.endswith(".mp4"):
             video = [torchvision.transforms.functional.pil_to_tensor(frame) for frame in frames]
             video = torch.stack(video)
-            video = rearrange(video, 'T C H W -> T H W C')
+            video = rearrange(video, "T C H W -> T H W C")
             torchvision.io.write_video(output_path, video, fps=7)
             print(f"Saved video to {output_path}")
         else:
             frames[0].save(output_path, save_all=True, append_images=frames[1:], loop=0, duration=duration)
-        
+
     # Helper function to concatenate images horizontally
     def get_concat_h(im1, im2, gap=10):
         # # img first, heatmap second
         # im1, im2 = im2, im1
 
-        dst = Image.new('RGB', (im1.width + im2.width + gap, max(im1.height, im2.height)), (255, 255, 255))
+        dst = Image.new("RGB", (im1.width + im2.width + gap, max(im1.height, im2.height)), (255, 255, 255))
         dst.paste(im1, (0, 0))
         dst.paste(im2, (im1.width + gap, 0))
         return dst
 
     # Helper function to concatenate images vertically
     def get_concat_v(im1, im2):
-        dst = Image.new('RGB', (max(im1.width, im2.width), im1.height + im2.height))
+        dst = Image.new("RGB", (max(im1.width, im2.width), im1.height + im2.height))
         dst.paste(im1, (0, 0))
         dst.paste(im2, (0, im1.height))
         return dst
@@ -324,7 +338,7 @@ def save_gifs_side_by_side(
 
 
 # Define functions
-def validate_and_convert_image(image, target_size=(512 , 512)):
+def validate_and_convert_image(image, target_size=(512, 512)):
     if image is None:
         print("Encountered a None image")
         return None
@@ -345,7 +359,7 @@ def validate_and_convert_image(image, target_size=(512 , 512)):
     else:
         print("Image is not a PIL Image or a PyTorch tensor")
         return None
-    
+
     return image
 
 
@@ -371,19 +385,21 @@ class Drag:
 
         if is_xformers_available():
             import xformers
+
             xformers_version = version.parse(xformers.__version__)
             unet.enable_xformers_memory_efficient_attention()
             # controlnet.enable_xformers_memory_efficient_attention()
         else:
-            raise ValueError(
-                "xformers is not available. Make sure it is installed correctly")
+            raise ValueError("xformers is not available. Make sure it is installed correctly")
 
         pipe = StableVideoDiffusionInterpControlPipeline.from_pretrained(
             "checkpoints/stable-video-diffusion-img2vid-xt",
             unet=unet,
             controlnet=controlnet,
             low_cpu_mem_usage=False,
-            torch_dtype=torch.float16, variant="fp16", local_files_only=True,
+            torch_dtype=torch.float16,
+            variant="fp16",
+            local_files_only=True,
         )
         pipe.to(device)
 
@@ -397,18 +413,18 @@ class Drag:
         self.use_sift = use_sift
 
     @spaces.GPU
-    def run(self, first_frame_path, last_frame_path, tracking_points, controlnet_cond_scale, motion_bucket_id):        
+    def run(self, first_frame_path, last_frame_path, tracking_points, controlnet_cond_scale, motion_bucket_id):
         original_width, original_height = 512, 320  # TODO
 
         # load_image
-        image = Image.open(first_frame_path).convert('RGB')
+        image = Image.open(first_frame_path).convert("RGB")
         width, height = image.size
         image = image.resize((self.width, self.height))
 
-        image_end = Image.open(last_frame_path).convert('RGB')
+        image_end = Image.open(last_frame_path).convert("RGB")
         image_end = image_end.resize((self.width, self.height))
 
-        input_all_points = tracking_points.constructor_args['value']
+        input_all_points = tracking_points.constructor_args["value"]
 
         sift_track_update = False
         anchor_points_flag = None
@@ -417,11 +433,10 @@ class Drag:
             sift_track_update = True
             controlnet_cond_scale = 0.5
 
-            from models_diffusers.sift_match import \
-                interpolate_trajectory as sift_interpolate_trajectory
+            from models_diffusers.sift_match import interpolate_trajectory as sift_interpolate_trajectory
             from models_diffusers.sift_match import sift_match
 
-            output_file_sift = os.path.join(args.output_dir,  "sift.png")
+            output_file_sift = os.path.join(args.output_dir, "sift.png")
 
             # (f, topk, 2), f=2 (before interpolation)
             pred_tracks = sift_match(
@@ -446,9 +461,12 @@ class Drag:
         else:
 
             resized_all_points = [
-                tuple([
-                    tuple([int(e1[0] * self.width / original_width), int(e1[1] * self.height / original_height)]) 
-                    for e1 in e]) 
+                tuple(
+                    [
+                        tuple([int(e1[0] * self.width / original_width), int(e1[1] * self.height / original_height)])
+                        for e1 in e
+                    ]
+                )
                 for e in input_all_points
             ]
 
@@ -460,12 +478,12 @@ class Drag:
                     warnings.warn("running without point trajectory control")
                     continue
 
-                if len(splited_track) == 1: # stationary point
+                if len(splited_track) == 1:  # stationary point
                     displacement_point = tuple([splited_track[0][0] + 1, splited_track[0][1] + 1])
                     splited_track = tuple([splited_track[0], displacement_point])
                 # interpolate the track
                 splited_track = interpolate_trajectory(splited_track, self.model_length)
-                splited_track = splited_track[:self.model_length]
+                splited_track = splited_track[: self.model_length]
                 resized_all_points[idx] = splited_track
 
             pred_tracks = torch.tensor(resized_all_points)  # (num_points, num_frames, 2)
@@ -498,7 +516,7 @@ class Drag:
             num_frames=14,
             width=width,
             height=height,
-            # decode_chunk_size=8, 
+            # decode_chunk_size=8,
             # generator=generator,
             motion_bucket_id=motion_bucket_id,
             fps=7,
@@ -511,12 +529,12 @@ class Drag:
         vis_images = [cv2.applyColorMap(np.array(img).astype(np.uint8), cv2.COLORMAP_JET) for img in vis_images]
         vis_images = [cv2.cvtColor(np.array(img).astype(np.uint8), cv2.COLOR_BGR2RGB) for img in vis_images]
         vis_images = [Image.fromarray(img) for img in vis_images]
-    
+
         # video_frames = [img for sublist in video_frames for img in sublist]
         val_save_dir = os.path.join(args.output_dir, "vis_gif.gif")
         save_gifs_side_by_side(
-            video_frames, 
-            vis_images[:self.model_length],
+            video_frames,
+            vis_images[: self.model_length],
             val_save_dir,
             target_size=(self.width, self.height),
             duration=110,
@@ -545,7 +563,7 @@ def preprocess_image(image):
     image_pil = image_pil.resize((512, 320), Image.BILINEAR)
 
     first_frame_path = os.path.join(args.output_dir, f"first_frame_{str(uuid.uuid4())[:4]}.png")
-    
+
     image_pil.save(first_frame_path)
 
     return first_frame_path, first_frame_path, gr.State([])
@@ -569,29 +587,42 @@ def preprocess_image_end(image_end):
 
 
 def add_drag(tracking_points):
-    tracking_points.constructor_args['value'].append([])
+    tracking_points.constructor_args["value"].append([])
     return tracking_points
 
 
 def delete_last_drag(tracking_points, first_frame_path, last_frame_path):
-    tracking_points.constructor_args['value'].pop()
-    transparent_background = Image.open(first_frame_path).convert('RGBA')
-    transparent_background_end = Image.open(last_frame_path).convert('RGBA')
+    tracking_points.constructor_args["value"].pop()
+    transparent_background = Image.open(first_frame_path).convert("RGBA")
+    transparent_background_end = Image.open(last_frame_path).convert("RGBA")
     w, h = transparent_background.size
     transparent_layer = np.zeros((h, w, 4))
 
-    for track in tracking_points.constructor_args['value']:
+    for track in tracking_points.constructor_args["value"]:
         if len(track) > 1:
-            for i in range(len(track)-1):
+            for i in range(len(track) - 1):
                 start_point = track[i]
-                end_point = track[i+1]
+                end_point = track[i + 1]
                 vx = end_point[0] - start_point[0]
                 vy = end_point[1] - start_point[1]
                 arrow_length = np.sqrt(vx**2 + vy**2)
-                if i == len(track)-2:
-                    cv2.arrowedLine(transparent_layer, tuple(start_point), tuple(end_point), (255, 0, 0, 255), 2, tipLength=8 / arrow_length)
+                if i == len(track) - 2:
+                    cv2.arrowedLine(
+                        transparent_layer,
+                        tuple(start_point),
+                        tuple(end_point),
+                        (255, 0, 0, 255),
+                        2,
+                        tipLength=8 / arrow_length,
+                    )
                 else:
-                    cv2.line(transparent_layer, tuple(start_point), tuple(end_point), (255, 0, 0, 255), 2,)
+                    cv2.line(
+                        transparent_layer,
+                        tuple(start_point),
+                        tuple(end_point),
+                        (255, 0, 0, 255),
+                        2,
+                    )
         else:
             cv2.circle(transparent_layer, tuple(track[0]), 5, (255, 0, 0, 255), -1)
 
@@ -603,24 +634,37 @@ def delete_last_drag(tracking_points, first_frame_path, last_frame_path):
 
 
 def delete_last_step(tracking_points, first_frame_path, last_frame_path):
-    tracking_points.constructor_args['value'][-1].pop()
-    transparent_background = Image.open(first_frame_path).convert('RGBA')
-    transparent_background_end = Image.open(last_frame_path).convert('RGBA')
+    tracking_points.constructor_args["value"][-1].pop()
+    transparent_background = Image.open(first_frame_path).convert("RGBA")
+    transparent_background_end = Image.open(last_frame_path).convert("RGBA")
     w, h = transparent_background.size
     transparent_layer = np.zeros((h, w, 4))
 
-    for track in tracking_points.constructor_args['value']:
+    for track in tracking_points.constructor_args["value"]:
         if len(track) > 1:
-            for i in range(len(track)-1):
+            for i in range(len(track) - 1):
                 start_point = track[i]
-                end_point = track[i+1]
+                end_point = track[i + 1]
                 vx = end_point[0] - start_point[0]
                 vy = end_point[1] - start_point[1]
                 arrow_length = np.sqrt(vx**2 + vy**2)
-                if i == len(track)-2:
-                    cv2.arrowedLine(transparent_layer, tuple(start_point), tuple(end_point), (255, 0, 0, 255), 2, tipLength=8 / arrow_length)
+                if i == len(track) - 2:
+                    cv2.arrowedLine(
+                        transparent_layer,
+                        tuple(start_point),
+                        tuple(end_point),
+                        (255, 0, 0, 255),
+                        2,
+                        tipLength=8 / arrow_length,
+                    )
                 else:
-                    cv2.line(transparent_layer, tuple(start_point), tuple(end_point), (255, 0, 0, 255), 2,)
+                    cv2.line(
+                        transparent_layer,
+                        tuple(start_point),
+                        tuple(end_point),
+                        (255, 0, 0, 255),
+                        2,
+                    )
         else:
             cv2.circle(transparent_layer, tuple(track[0]), 5, (255, 0, 0, 255), -1)
 
@@ -631,34 +675,49 @@ def delete_last_step(tracking_points, first_frame_path, last_frame_path):
     return tracking_points, trajectory_map, trajectory_map_end
 
 
-def add_tracking_points(tracking_points, first_frame_path, last_frame_path, evt: gr.SelectData):  # SelectData is a subclass of EventData
+def add_tracking_points(
+    tracking_points, first_frame_path, last_frame_path, evt: gr.SelectData
+):  # SelectData is a subclass of EventData
     print(f"You selected {evt.value} at {evt.index} from {evt.target}")
-    tracking_points.constructor_args['value'][-1].append(evt.index)
+    tracking_points.constructor_args["value"][-1].append(evt.index)
 
-    transparent_background = Image.open(first_frame_path).convert('RGBA')
-    transparent_background_end = Image.open(last_frame_path).convert('RGBA')
+    transparent_background = Image.open(first_frame_path).convert("RGBA")
+    transparent_background_end = Image.open(last_frame_path).convert("RGBA")
 
     w, h = transparent_background.size
     transparent_layer = 0
-    for idx, track in enumerate(tracking_points.constructor_args['value']):
+    for idx, track in enumerate(tracking_points.constructor_args["value"]):
         # mask = cv2.imread(
         #     os.path.join(args.output_dir, f"mask_{idx+1}.jpg")
         # )
         mask = np.zeros((320, 512, 3))
-        color = color_list[idx+1]
+        color = color_list[idx + 1]
         transparent_layer = mask[:, :, 0].reshape(h, w, 1) * color.reshape(1, 1, -1) + transparent_layer
 
         if len(track) > 1:
-            for i in range(len(track)-1):
+            for i in range(len(track) - 1):
                 start_point = track[i]
-                end_point = track[i+1]
+                end_point = track[i + 1]
                 vx = end_point[0] - start_point[0]
                 vy = end_point[1] - start_point[1]
                 arrow_length = np.sqrt(vx**2 + vy**2)
-                if i == len(track)-2:
-                    cv2.arrowedLine(transparent_layer, tuple(start_point), tuple(end_point), (255, 0, 0, 255), 2, tipLength=8 / arrow_length)
+                if i == len(track) - 2:
+                    cv2.arrowedLine(
+                        transparent_layer,
+                        tuple(start_point),
+                        tuple(end_point),
+                        (255, 0, 0, 255),
+                        2,
+                        tipLength=8 / arrow_length,
+                    )
                 else:
-                    cv2.line(transparent_layer, tuple(start_point), tuple(end_point), (255, 0, 0, 255), 2,)
+                    cv2.line(
+                        transparent_layer,
+                        tuple(start_point),
+                        tuple(end_point),
+                        (255, 0, 0, 255),
+                        2,
+                    )
         else:
             cv2.circle(transparent_layer, tuple(track[0]), 5, (255, 0, 0, 255), -1)
 
@@ -678,22 +737,25 @@ if __name__ == "__main__":
 
     args = get_args()
     ensure_dirname(args.output_dir)
-    
+
     color_list = []
     for i in range(20):
-        color = np.concatenate([np.random.random(4)*255], axis=0)
+        color = np.concatenate([np.random.random(4) * 255], axis=0)
         color_list.append(color)
 
     with gr.Blocks() as demo:
         gr.Markdown("""<h1 align="center">Framer: Interactive Frame Interpolation</h1><br>""")
-    
-        gr.Markdown("""Gradio Demo for <a href='https://arxiv.org/abs/2410.18978'><b>Framer: Interactive Frame Interpolation</b></a>.<br>
+
+        gr.Markdown(
+            """Gradio Demo for <a href='https://arxiv.org/abs/2410.18978'><b>Framer: Interactive Frame Interpolation</b></a>.<br>
                     Github Repo can be found at https://github.com/aim-uofa/Framer<br>
-                    The template is inspired by DragAnything.""")
-    
+                    The template is inspired by DragAnything."""
+        )
+
         gr.Image(label="Framer: Interactive Frame Interpolation", value="assets/demos.gif", height=432, width=768)
-    
-        gr.Markdown("""## Usage: <br>
+
+        gr.Markdown(
+            """## Usage: <br>
                     1. Upload images<br>
                     &ensp;  1.1  Upload the start image via the "Upload Start Image" button.<br>
                     &ensp;  1.2. Upload the end image via the "Upload End Image" button.<br>
@@ -702,14 +764,15 @@ if __name__ == "__main__":
                     &ensp;  2.2. You can click several points on either start or end image to forms a path.<br>
                     &ensp;  2.3. Click "Delete last drag" to delete the whole lastest path.<br>
                     &ensp;  2.4. Click "Delete last step" to delete the lastest clicked control point.<br>
-                    3. Interpolate the images (according the path) with a click on "Run" button. <br>""")
-        
+                    3. Interpolate the images (according the path) with a click on "Run" button. <br>"""
+        )
+
         # device, args, height, width, model_length
         Framer = Drag("cuda", args, 320, 512, 14)
         first_frame_path = gr.State()
         last_frame_path = gr.State()
         tracking_points = gr.State([])
-    
+
         with gr.Row():
             with gr.Column(scale=1):
                 image_upload_button = gr.UploadButton(label="Upload Start Image", file_types=["image"])
@@ -720,7 +783,7 @@ if __name__ == "__main__":
                 run_button = gr.Button(value="Run")
                 delete_last_drag_button = gr.Button(value="Delete last drag")
                 delete_last_step_button = gr.Button(value="Delete last step")
-    
+
             with gr.Column(scale=7):
                 with gr.Row():
                     with gr.Column(scale=6):
@@ -731,7 +794,7 @@ if __name__ == "__main__":
                             width=512,
                             sources=[],
                         )
-    
+
                     with gr.Column(scale=6):
                         input_image_end = gr.Image(
                             label="end frame",
@@ -740,36 +803,36 @@ if __name__ == "__main__":
                             width=512,
                             sources=[],
                         )
-    
+
         with gr.Row():
             with gr.Column(scale=1):
-    
+
                 controlnet_cond_scale = gr.Slider(
-                    label='Control Scale', 
-                    minimum=0.0, 
-                    maximum=10, 
-                    step=0.1, 
+                    label="Control Scale",
+                    minimum=0.0,
+                    maximum=10,
+                    step=0.1,
                     value=1.0,
                 )
-    
+
                 motion_bucket_id = gr.Slider(
-                    label='Motion Bucket', 
-                    minimum=1, 
-                    maximum=180, 
-                    step=1, 
+                    label="Motion Bucket",
+                    minimum=1,
+                    maximum=180,
+                    step=1,
                     value=100,
                 )
-    
+
             with gr.Column(scale=5):
                 output_video = gr.Image(
                     label="Output Video",
                     height=320,
                     width=1152,
                 )
-    
-    
+
         with gr.Row():
-            gr.Markdown("""
+            gr.Markdown(
+                """
                 ## Citation
                 ```bibtex
                 @article{wang2024framer,
@@ -779,24 +842,59 @@ if __name__ == "__main__":
                   year={2024}
                 }
                 ```
-                """)
-    
-        image_upload_button.upload(preprocess_image, image_upload_button, [input_image, first_frame_path, tracking_points])
-    
-        image_end_upload_button.upload(preprocess_image_end, image_end_upload_button, [input_image_end, last_frame_path, tracking_points])
-    
-        add_drag_button.click(add_drag, tracking_points, [tracking_points, ])
-    
-        delete_last_drag_button.click(delete_last_drag, [tracking_points, first_frame_path, last_frame_path], [tracking_points, input_image, input_image_end])
-    
-        delete_last_step_button.click(delete_last_step, [tracking_points, first_frame_path, last_frame_path], [tracking_points, input_image, input_image_end])
-    
-        reset_button.click(reset_states, [first_frame_path, last_frame_path, tracking_points], [first_frame_path, last_frame_path, tracking_points])
-    
-        input_image.select(add_tracking_points, [tracking_points, first_frame_path, last_frame_path], [tracking_points, input_image, input_image_end])
-    
-        input_image_end.select(add_tracking_points, [tracking_points, first_frame_path, last_frame_path], [tracking_points, input_image, input_image_end])
-    
-        run_button.click(Framer.run, [first_frame_path, last_frame_path, tracking_points, controlnet_cond_scale, motion_bucket_id], output_video)
-    
+                """
+            )
+
+        image_upload_button.upload(
+            preprocess_image, image_upload_button, [input_image, first_frame_path, tracking_points]
+        )
+
+        image_end_upload_button.upload(
+            preprocess_image_end, image_end_upload_button, [input_image_end, last_frame_path, tracking_points]
+        )
+
+        add_drag_button.click(
+            add_drag,
+            tracking_points,
+            [
+                tracking_points,
+            ],
+        )
+
+        delete_last_drag_button.click(
+            delete_last_drag,
+            [tracking_points, first_frame_path, last_frame_path],
+            [tracking_points, input_image, input_image_end],
+        )
+
+        delete_last_step_button.click(
+            delete_last_step,
+            [tracking_points, first_frame_path, last_frame_path],
+            [tracking_points, input_image, input_image_end],
+        )
+
+        reset_button.click(
+            reset_states,
+            [first_frame_path, last_frame_path, tracking_points],
+            [first_frame_path, last_frame_path, tracking_points],
+        )
+
+        input_image.select(
+            add_tracking_points,
+            [tracking_points, first_frame_path, last_frame_path],
+            [tracking_points, input_image, input_image_end],
+        )
+
+        input_image_end.select(
+            add_tracking_points,
+            [tracking_points, first_frame_path, last_frame_path],
+            [tracking_points, input_image, input_image_end],
+        )
+
+        run_button.click(
+            Framer.run,
+            [first_frame_path, last_frame_path, tracking_points, controlnet_cond_scale, motion_bucket_id],
+            output_video,
+        )
+
     demo.launch()