vggt

app.py

@@ -112,32 +112,27 @@ def handle_video_upload(video):
         return None, None, [], 50, 756, 3
     
     try:
-        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'fns'):
+        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'predict'):
             # Try to use backend API
             try:
                 print("🔧 Calling backend API for video upload...")
                 
-                # Use call_function method - function 0 is the main processing function
-                if 0 in backend_api.fns:
-                    print("🔧 Using backend call_function method (main processing)")
-                    # Call the main processing function with video and empty points
-                    result = backend_api.call_function(0, [video, [], 50, 756, 3])
-                    
-                    print(f"✅ Backend video upload API call successful!")
-                    print(f"🔧 Result type: {type(result)}")
-                    
-                    # Parse the result - expect a dict with success status
-                    if isinstance(result, dict) and result.get("success"):
-                        # For now, just extract the first frame locally
-                        display_image = extract_first_frame(video)
-                        original_image_state = json.dumps({"video_path": video, "frame": "backend_processing"})
-                        return original_image_state, display_image, [], 50, 756, 3
-                    else:
-                        print("Backend processing failed, using local fallback")
-                        # Fallback to local processing
-                        pass
+                # Call process_video_with_points with empty points to get initial state
+                # The function expects: (video_path, points, grid_size, vo_points, fps)
+                result = backend_api.predict(video, [], 50, 756, 3)
+                
+                print(f"✅ Backend video upload API call successful!")
+                print(f"🔧 Result type: {type(result)}")
+                print(f"🔧 Result: {result}")
+                
+                # Parse the result - expect a dict with success status
+                if isinstance(result, dict) and result.get("success"):
+                    # Extract first frame locally for display
+                    display_image = extract_first_frame(video)
+                    original_image_state = json.dumps({"video_path": video, "frame": "backend_processing"})
+                    return original_image_state, display_image, [], 50, 756, 3
                 else:
-                    print("Backend function 0 not found")
+                    print("Backend processing failed, using local fallback")
                     # Fallback to local processing
                     pass
             except Exception as e:
@@ -170,21 +165,27 @@ def select_point(original_img: str, sel_pix: list, point_type: str, evt: gr.Sele
         return None, []
     
     try:
-        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'fns'):
+        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'predict'):
             # Try to use backend API
             try:
                 print(f"🔧 Calling backend select point API: x={evt.index[0]}, y={evt.index[1]}, type={point_type}")
                 
-                # Use call_function method - function 0 is the main processing function
-                if 0 in backend_api.fns:
-                    print("🔧 Using backend call_function method (main processing for point selection)")
+                # Parse original image state to get video path
+                try:
+                    state_data = json.loads(original_img)
+                    video_path = state_data.get("video_path")
+                except:
+                    video_path = None
+                
+                if video_path:
                     # Create points list with the new point
                     points = [(evt.index[0], evt.index[1], point_type)]
-                    # Call the main processing function with video and points
-                    result = backend_api.call_function(0, [None, points, 50, 756, 3])
+                    # Call process_video_with_points with the new point
+                    result = backend_api.predict(video_path, points, 50, 756, 3)
                     
                     print(f"✅ Backend select point API call successful!")
                     print(f"🔧 Result type: {type(result)}")
+                    print(f"🔧 Result: {result}")
                     
                     # Parse the result - expect a dict with success status
                     if isinstance(result, dict) and result.get("success"):
@@ -196,7 +197,7 @@ def select_point(original_img: str, sel_pix: list, point_type: str, evt: gr.Sele
                         # Fallback to local processing
                         pass
                 else:
-                    print("Backend function 0 not found")
+                    print("No video path found in state, using local fallback")
                     # Fallback to local processing
                     pass
             except Exception as e:
@@ -259,19 +260,25 @@ def reset_points(original_img: str, sel_pix):
         return None, []
     
     try:
-        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'fns'):
+        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'predict'):
             # Try to use backend API
             try:
                 print("🔧 Calling backend reset points API")
                 
-                # Use call_function method - function 0 is the main processing function
-                if 0 in backend_api.fns:
-                    print("🔧 Using backend call_function method (main processing for reset)")
-                    # Call the main processing function with video and empty points
-                    result = backend_api.call_function(0, [None, [], 50, 756, 3])
+                # Parse original image state to get video path
+                try:
+                    state_data = json.loads(original_img)
+                    video_path = state_data.get("video_path")
+                except:
+                    video_path = None
+                
+                if video_path:
+                    # Call process_video_with_points with empty points to reset
+                    result = backend_api.predict(video_path, [], 50, 756, 3)
                     
                     print(f"✅ Backend reset points API call successful!")
                     print(f"🔧 Result type: {type(result)}")
+                    print(f"🔧 Result: {result}")
                     
                     # Parse the result - expect a dict with success status
                     if isinstance(result, dict) and result.get("success"):
@@ -283,7 +290,7 @@ def reset_points(original_img: str, sel_pix):
                         # Fallback to local processing
                         pass
                 else:
-                    print("Backend function 0 not found")
+                    print("No video path found in state, using local fallback")
                     # Fallback to local processing
                     pass
             except Exception as e:
@@ -318,18 +325,25 @@ def launch_viz(grid_size, vo_points, fps, original_image_state):
         return None, None
     
     try:
-        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'fns'):
+        if BACKEND_AVAILABLE and backend_api and hasattr(backend_api, 'predict'):
             # Try to use backend API
             try:
                 print(f"🔧 Calling backend API with parameters: grid_size={grid_size}, vo_points={vo_points}, fps={fps}")
                 print(f"🔧 Original image state type: {type(original_image_state)}")
                 print(f"🔧 Original image state preview: {str(original_image_state)[:100]}...")
                 
-                # Use call_function method - function 0 is the main processing function
-                if 0 in backend_api.fns:
-                    print("🔧 Using backend call_function method (main processing)")
-                    # Call the main processing function with video and empty points
-                    result = backend_api.call_function(0, [None, [], grid_size, vo_points, fps])
+                # Parse original image state to get video path
+                try:
+                    state_data = json.loads(original_image_state)
+                    video_path = state_data.get("video_path")
+                except:
+                    video_path = None
+                
+                if video_path:
+                    # Call process_video_with_points with current points and parameters
+                    # We need to get the current points from the state
+                    current_points = []  # For now, use empty points
+                    result = backend_api.predict(video_path, current_points, grid_size, vo_points, fps)
                     
                     print(f"✅ Backend API call successful!")
                     print(f"🔧 Result type: {type(result)}")
@@ -345,7 +359,7 @@ def launch_viz(grid_size, vo_points, fps, original_image_state):
                         # Fallback to error message
                         pass
                 else:
-                    print("Backend function 0 not found")
+                    print("No video path found in state, showing error message")
                     # Fallback to error message
                     pass
             except Exception as e: