gradio 5.x compatibility

- clear cache
- fix circular import error
- use original aspect ratio
- gradio 5.x compatibility

app.py

@@ -1,7 +1,9 @@
 from PIL import Image
 import gradio as gr
+import gc
 from FGT_codes.tool.video_inpainting import video_inpainting
-from SiamMask.tools.test import *
+from SiamMask.utils.config_helper import load_config
+from SiamMask.utils.load_helper   import load_pretrain
 from SiamMask.experiments.siammask_sharp.custom import Custom
 from types import SimpleNamespace
 import torch
@@ -139,6 +141,7 @@ def getBoundaries(mask):
 
 
 def track_and_mask(vid, masked_frame, original_list, mask_list, in_fps, dt_string):
+    from SiamMask.tools.test import siamese_init, siamese_track
     x, y, w, h = getBoundaries(masked_frame)
     f = 0
     
@@ -203,29 +206,49 @@ def track_and_mask(vid, masked_frame, original_list, mask_list, in_fps, dt_strin
     return original_list, mask_list, in_fps, outname
 
 
+
 def inpaint_video(original_frame_list, mask_list, in_fps, dt_string):
     outname = (dt_string+"_result.mp4")
     args.out_fps = in_fps
     args.outfilename = outname
-    video_inpainting(args, original_frame_list, mask_list)
+
+    first_frame = original_frame_list[0]
+    args.orig_h, args.orig_w = first_frame.shape[:2]
+    print(f"[INFO] Original video resolution: {args.orig_w}x{args.orig_h}")
+
+    video_inpainting(args, original_frame_list,original_frame_list, mask_list)
     original_frame_list = []
     mask_list = []
-    return outname,original_frame_list, mask_list
 
+    gc.collect()
+    torch.cuda.empty_cache()
 
-def get_first_frame(video):
-    if(video == None):
-        return gr.ImageMask()
-    video_capture = cv2.VideoCapture()
-    if video_capture.open(video):
-        width, height = int(video_capture.get(cv2.CAP_PROP_FRAME_WIDTH)), int(
-            video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    return outname, original_frame_list, mask_list
 
-    if video_capture.isOpened():
-        ret, frame = video_capture.read()
-        RGB_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 
-    return RGB_frame
+def get_first_frame(video):
+    if video is None:
+        # leeres Editor-State
+        return {"background": None, "layers": [], "composite": None}
+
+    cap = cv2.VideoCapture(video)
+    ret, frame = cap.read()
+    cap.release()
+    if not ret:
+        return {"background": None, "layers": [], "composite": None}
+
+    # RGB und RGBA
+    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    h, w, _ = rgb.shape
+    # als RGBA-Hintergrund
+    bg_rgba = np.concatenate([rgb, np.full((h, w, 1), 255, dtype=np.uint8)], axis=-1)
+    # start mit leerer Maske (RGBA all zeros)
+    empty_layer = np.zeros((h, w, 4), dtype=np.uint8)
+    return {
+      "background": bg_rgba,
+      "layers":    [empty_layer],
+      "composite": bg_rgba
+    }
 
 
 def drawRectangle(frame, mask):
@@ -247,6 +270,24 @@ def getStartEndPoints(mask):
 
     return x1, y1, x2, y2
 
+def extract_frame_and_mask(editor_state):
+    bg_rgba = editor_state["background"]
+    layers  = editor_state.get("layers", [])
+
+    # Hintergrund (RGB)
+    frame_rgb = bg_rgba[...,:3] if bg_rgba is not None else None
+
+    # Maske: falls Layer da sind, nimm das Alpha der letzten
+    if layers:
+        alpha = layers[-1][... , 3]         # 0–255
+        # in 3-Kanal (damit gr.Image es akzeptiert)
+        mask = (alpha > 0).astype(np.uint8) * 255
+        mask_rgb = np.stack([mask]*3, axis=-1)
+    else:
+        mask_rgb = None
+
+    return frame_rgb, mask_rgb
+
 def reset_components():
     return gr.update(value=None),gr.update(value=None, interactive=False),gr.update(value=None, interactive=False), [],[],24,datetime.now().strftime("%d_%m_%Y_%H_%M_%S")
 
@@ -271,27 +312,29 @@ with gr.Blocks() as demo:
     with gr.Row():
         with gr.Column(scale=2):
             with gr.Row():
-                in_video = gr.PlayableVideo(label="Input Video", show_progress=True)
+                in_video = gr.PlayableVideo(label="Input Video")
             with gr.Row():
-                first_frame = gr.ImageMask(label="Select Object")
+                first_frame = gr.ImageMask(label="Select Object", type="numpy")
             with gr.Row():
-                approve_mask = gr.Button(value="Run",variant="primary")
+                approve_mask = gr.Button(value="Run", variant="primary")
         with gr.Column(scale=1):
             with gr.Row():
                 original_image = gr.Image(interactive=False)
             with gr.Row():
                 masked_image = gr.Image(interactive=False)
         with gr.Column(scale=2):
-            out_video = gr.Video(label="Segmented Video", show_progress=True)
-            out_video_inpaint = gr.Video(label="Inpainted Video", show_progress=True)
+            out_video = gr.Video(label="Segmented Video")
+            out_video_inpaint = gr.Video(label="Inpainted Video")
             # track_mask = gr.Button(value="Track and Mask")
             # inpaint = gr.Button(value="Inpaint")
 
-    in_video.change(fn=get_first_frame, inputs=[
-                    in_video], outputs=[first_frame])
+    in_video.change(fn=get_first_frame, inputs=[in_video], outputs=[first_frame])
     in_video.clear(fn=reset_components, outputs=[first_frame, original_image, masked_image, original_frame_list, mask_list, in_fps, dt_string])
-    approve_mask.click(lambda x: [x['image'], x['mask']], first_frame, [
-                       original_image, masked_image])
+    approve_mask.click(
+        fn=extract_frame_and_mask,
+        inputs=[first_frame],
+        outputs=[original_image, masked_image]
+    )
     masked_image.change(fn=track_and_mask,inputs=[
                      in_video, masked_image, original_frame_list, mask_list, in_fps, dt_string], outputs=[original_frame_list, mask_list, in_fps, out_video])
     out_video.change(fn=inpaint_video, inputs=[original_frame_list, mask_list, in_fps, dt_string], outputs=[out_video_inpaint, original_frame_list, mask_list])