vggt

app.py

@@ -25,15 +25,14 @@ def initialize_backend():
         print(f"🔧 Backend API object type: {type(backend_api)}")
         print(f"🔧 Backend API object attributes: {dir(backend_api)}")
         
-        # Check if it's a Blocks object and has fns
-        if hasattr(backend_api, 'fns') and backend_api.fns:
-            print(f"🔧 Available functions in fns: {list(backend_api.fns.keys())}")
+        # Check if it's an Interface object and has fn
+        if hasattr(backend_api, 'fn'):
+            print(f"✅ Backend connection successful!")
+            print("✅ Backend API function is available")
             BACKEND_AVAILABLE = True
-            print("✅ Backend connection successful!")
-            print("✅ Backend API functions are available")
             return True
         else:
-            print("❌ Backend API functions not found")
+            print("❌ Backend API function not found")
             print(f"🔧 Available methods: {[attr for attr in dir(backend_api) if not attr.startswith('_')]}")
             BACKEND_AVAILABLE = False
             return False
@@ -97,14 +96,20 @@ 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:
             # Try to use backend API
             try:
-                # Use the Blocks predict method to call the function
-                if 0 in backend_api.fns:
-                    print("🔧 Calling backend function 0 (main processing function)")
-                    result = backend_api.predict(0, [video, [], 50, 756, 3])
-                    # Parse the result to extract what we need
+                print("🔧 Calling backend API for video upload...")
+                
+                # For gr.Interface, we can call the function directly
+                if hasattr(backend_api, 'fn'):
+                    print("🔧 Using backend Interface function")
+                    result = backend_api.fn(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)
@@ -115,7 +120,7 @@ def handle_video_upload(video):
                         # Fallback to local processing
                         pass
                 else:
-                    print("Backend function 0 not found")
+                    print("Backend function not found")
                     # Fallback to local processing
                     pass
             except Exception as e:
@@ -151,18 +156,25 @@ def select_point(original_img: str, sel_pix: list, point_type: str, evt: gr.Sele
         if BACKEND_AVAILABLE and backend_api:
             # Try to use backend API
             try:
-                display_image_b64, new_sel_pix = backend_api.select_point_api(
-                    original_img, sel_pix, point_type, evt.index[0], evt.index[1]
-                )
-                display_image = base64_to_image(display_image_b64)
-                return display_image, new_sel_pix
+                print(f"🔧 Calling backend select point API: x={evt.index[0]}, y={evt.index[1]}, type={point_type}")
+                
+                # For gr.Interface, we can call the function directly
+                if hasattr(backend_api, 'fn'):
+                    print("🔧 Using backend Interface function for point selection")
+                    # Note: This might not work as expected since the interface expects different inputs
+                    # For now, fallback to local processing
+                    pass
+                else:
+                    print("Backend function not found")
+                    # Fallback to local processing
+                    pass
             except Exception as e:
                 print(f"Backend API call failed: {e}")
                 # Fallback to local processing
                 pass
         
-        # Fallback: local processing
-        print("Using local point selection...")
+        # Fallback: local processing with improved visualization
+        print("Using local point selection with enhanced visualization...")
         
         # Parse original image state
         try:
@@ -172,16 +184,36 @@ def select_point(original_img: str, sel_pix: list, point_type: str, evt: gr.Sele
             video_path = None
         
         if video_path:
-            # Re-extract frame and add point
+            # Re-extract frame and add point with mask visualization
             display_image = extract_first_frame(video_path)
             if display_image is not None:
-                # Add point to the image (simple visualization)
+                # Add point to the image with enhanced visualization
                 x, y = evt.index[0], evt.index[1]
                 color = (0, 255, 0) if point_type == 'positive_point' else (255, 0, 0)
-                cv2.circle(display_image, (x, y), 5, color, -1)
+                
+                # Draw a more visible point
+                cv2.circle(display_image, (x, y), 8, color, -1)
+                cv2.circle(display_image, (x, y), 10, (255, 255, 255), 2)
+                
+                # Add a simple mask-like visualization (circle around the point)
+                mask_radius = 30
+                mask_color = (0, 255, 0, 50) if point_type == 'positive_point' else (255, 0, 0, 50)
+                
+                # Create a simple mask visualization
+                mask_overlay = display_image.copy()
+                cv2.circle(mask_overlay, (x, y), mask_radius, color, -1)
+                
+                # Blend the mask with the original image
+                alpha = 0.3
+                display_image = cv2.addWeighted(display_image, 1-alpha, mask_overlay, alpha, 0)
                 
                 # Update selected points
                 new_sel_pix = sel_pix + [(x, y, point_type)]
+                
+                # Add text label
+                label = "Positive" if point_type == 'positive_point' else "Negative"
+                cv2.putText(display_image, label, (x+15, y-15), cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
+                
                 return display_image, new_sel_pix
         
         return None, sel_pix
@@ -199,9 +231,18 @@ def reset_points(original_img: str, sel_pix):
         if BACKEND_AVAILABLE and backend_api:
             # Try to use backend API
             try:
-                display_image_b64, new_sel_pix = backend_api.reset_points_api(original_img, sel_pix)
-                display_image = base64_to_image(display_image_b64)
-                return display_image, new_sel_pix
+                print("🔧 Calling backend reset points API")
+                
+                # For gr.Interface, we can call the function directly
+                if hasattr(backend_api, 'fn'):
+                    print("🔧 Using backend Interface function for reset")
+                    # Note: This might not work as expected since the interface expects different inputs
+                    # For now, fallback to local processing
+                    pass
+                else:
+                    print("Backend function not found")
+                    # Fallback to local processing
+                    pass
             except Exception as e:
                 print(f"Backend API call failed: {e}")
                 # Fallback to local processing
@@ -234,18 +275,18 @@ 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:
             # 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 the Blocks predict method to call the function
-                if 0 in backend_api.fns:
-                    print("🔧 Calling backend function 0 (main processing function)")
+                # For gr.Interface, we can call the function directly
+                if hasattr(backend_api, 'fn'):
+                    print("🔧 Using backend Interface function")
                     # For now, we'll use empty points since we're in local mode
-                    result = backend_api.predict(0, [None, [], grid_size, vo_points, fps])
+                    result = backend_api.fn(None, [], grid_size, vo_points, fps)
                     
                     print(f"✅ Backend API call successful!")
                     print(f"🔧 Result type: {type(result)}")
@@ -261,7 +302,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("Backend function not found")
                     # Fallback to error message
                     pass
             except Exception as e:
@@ -289,7 +330,7 @@ def launch_viz(grid_size, vo_points, fps, original_image_state):
                 <p style='color: #666; font-size: 12px; margin: 0;'>Backend Available: {BACKEND_AVAILABLE}</p>
                 <p style='color: #666; font-size: 12px; margin: 0;'>Backend API Object: {backend_api is not None}</p>
                 <p style='color: #666; font-size: 12px; margin: 0;'>Backend URL: {BACKEND_SPACE_URL}</p>
-                <p style='color: #666; font-size: 12px; margin: 0;'>Available Functions: {list(backend_api.fns.keys()) if backend_api and hasattr(backend_api, 'fns') else 'None'}</p>
+                <p style='color: #666; font-size: 12px; margin: 0;'>Backend Type: {type(backend_api) if backend_api else 'None'}</p>
             </div>
             <p style='color: #2d3436; font-weight: bold; margin-top: 15px;'>
                 Current Status: Backend unavailable - Running in limited mode
@@ -329,13 +370,12 @@ def test_backend_connection():
     try:
         # Try a simple API call to test connection
         print("Testing backend connection with a simple call...")
-        # Check if we have fns available
-        if hasattr(backend_api, 'fns') and backend_api.fns:
-            print("✅ Backend API functions are available")
-            print(f"🔧 Available function indices: {list(backend_api.fns.keys())}")
+        # Check if we have fn available
+        if hasattr(backend_api, 'fn'):
+            print("✅ Backend API function is available")
             return True
         else:
-            print("❌ Backend API functions not found")
+            print("❌ Backend API function not found")
             BACKEND_AVAILABLE = False
             return False
     except Exception as e:
@@ -352,13 +392,12 @@ def test_backend_api():
     try:
         print("🧪 Testing backend API functions...")
         
-        # Test if fns exist and show available indices
-        if hasattr(backend_api, 'fns') and backend_api.fns:
-            print(f"✅ Backend has {len(backend_api.fns)} functions available")
-            for idx in backend_api.fns.keys():
-                print(f"✅ Function {idx} is available")
+        # Test if fn exists
+        if hasattr(backend_api, 'fn'):
+            print("✅ Backend has function available")
+            print(f"✅ Function type: {type(backend_api.fn)}")
         else:
-            print("❌ No functions available in backend")
+            print("❌ No function available in backend")
         
         return True
     except Exception as e:
@@ -449,6 +488,18 @@ with gr.Blocks(css="""
             <li>⚡ Click 'Run Tracker and Visualize' when done</li>
             <li>🔍 Iterative 3D result will be shown in the visualization</li>
         </ol>
+        
+        <div style='background-color: #fff3cd; border: 2px solid #ffc107; border-radius: 8px; padding: 15px; margin-top: 15px;'>
+            <p style='font-size: 18px; color: #856404; margin: 0 0 10px 0; font-weight: bold;'>
+                ⭐ If you like our work, please give us a star on GitHub!
+            </p>
+            <p style='font-size: 16px; color: #856404; margin: 0;'>
+                <a href="https://github.com/henry123-boy/SpaTrackerV2" target="_blank" style="color: #0066cc; text-decoration: none; font-weight: bold;">
+                    🌟 https://github.com/henry123-boy/SpaTrackerV2
+                </a>
+            </p>
+        </div>
+        
         <div style='background-color: {status_color}20; border: 2px solid {status_color}; border-radius: 8px; padding: 10px; margin-top: 15px;'>
             <p style='font-size: 18px; color: {status_color}; margin: 0;'>
                 {status_icon} Backend Status: {status_text}