upload

app.py

@@ -1,45 +1,25 @@
-import gradio as gr
-
-def dummy_function(image):
-    return "Analysis complete"
-
-iface = gr.Interface(
-    fn=dummy_function,
-    inputs=gr.Image(type="filepath"),
-    outputs="text",
-    title="Test Interface"
-)
-
-iface.launch()
-
-'''
 import os
 os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
-os.environ["GRADIO_IS_E2E_TEST"] = "True"
-
-# Fix for the JSON schema issue
-import warnings
-warnings.filterwarnings("ignore", category=DeprecationWarning)
 
 import gradio as gr
 
 # Import the UI-creation functions from your tool scripts
 import CFA as CFA_tool
 import JPEG_Ghost as JPEG_Ghost_tool
-#import PRNU as PRNU_tool
+import PRNU as PRNU_tool
 import shadow as shadows_tool
 
 # Create the tabbed interface
 demo = gr.TabbedInterface(
     interface_list=[
-        CFA_tool.create_ui(),
-        JPEG_Ghost_tool.create_ui(),
-        #PRNU_tool.create_ui(),
-        shadows_tool.build_gradio_interface()
+        CFA_tool.demo,  # Use the Blocks object directly
+        JPEG_Ghost_tool.demo,  # Use the Blocks object directly  
+        PRNU_tool.iface,  # Use the Interface object directly
+        shadows_tool.build_gradio_interface()  # Call the function that returns the interface
     ],
     tab_names=[
         "🎨 CFA Analysis",
-        "👻 JPEG Ghost",
+        "👻 JPEG Ghost", 
         "📸 PRNU Analysis",
         "☀️ Shadow Analysis"
     ],
@@ -48,5 +28,4 @@ demo = gr.TabbedInterface(
 
 # Launch the app
 if __name__ == "__main__":
-    demo.launch()
-'''
+    demo.launch()

requirements.txt

@@ -1,53 +1,10 @@
-asttokens==2.4.1
-backcall==0.2.0
-colorama==0.4.6
-comm==0.2.2
-contourpy==1.1.1
-cycler==0.12.1
-debugpy==1.8.8
-decorator==5.1.1
-executing==2.1.0
-fonttools==4.55.0
-imagecodecs==2023.3.16
-imageio==2.35.1
-importlib-metadata==8.5.0
-importlib-resources==6.4.5
-ipykernel==6.29.5
-ipython==8.12.3
-jedi==0.19.2
-jupyter-client==8.6.3
-jupyter-core==5.7.2
-kiwisolver==1.4.7
-lazy-loader==0.4
-matplotlib==3.7.5
-matplotlib-inline==0.1.7
-nest-asyncio==1.6.0
-networkx==3.1
-numpy==1.24.4
-opencv-python==4.10.0.84
-packaging==24.2
-parso==0.8.4
-pickleshare==0.7.5
-pillow==10.4.0
-platformdirs==4.3.6
-prompt-toolkit==3.0.48
-psutil==6.1.0
-pure-eval==0.2.3
-pygments==2.18.0
-pyparsing==3.1.4
-python-dateutil==2.9.0.post0
-PyWavelets==1.4.1
-scikit-image==0.21.0
-scipy==1.10.1
-six==1.16.0
-tornado==6.4.1
-gradio==4.44.1
-huggingface_hub==0.23.4
+gradio==4.32.4
+fastapi==0.104.1
+uvicorn==0.24.0
 numpy==1.24.4
 opencv-python==4.10.0.84
 pillow==10.4.0
 scikit-image==0.21.0
 scipy==1.10.1
 matplotlib==3.7.5
-fastapi==0.104.1
-uvicorn==0.24.0
+imageio==2.35.1

shadow.py

@@ -1,12 +1,11 @@
 """
-Gradio app module for interactive vanishing-point selection.
-This file is intended to be imported by app.py.
+Gradio app for shadow analysis with vanishing-point selection tool
+Updated for Gradio 4.x compatibility
 """
 
-import io
 import math
 import numpy as np
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image, ImageDraw
 import gradio as gr
 from scipy.optimize import minimize
 
@@ -21,13 +20,11 @@ def build_line_from_points(p1, p2):
     c = x1 * y2 - y1 * x2
     return np.array([a, b, c], dtype=float)
 
-
 def distance_point_to_line(pt, line):
     x, y = pt
     a, b, c = line
     return abs(a * x + b * y + c) / math.hypot(a, b)
 
-
 def total_distances(x, lines, noise_lines):
     """Sum of distances from candidate point x to all lines and noise lines."""
     pt = x
@@ -38,7 +35,6 @@ def total_distances(x, lines, noise_lines):
         s += distance_point_to_line(pt, Ln)
     return s
 
-
 def add_noise_lines_for_line(p1, p2, n=4, sigma=1.0):
     """Create a list of "noise" lines by jittering the endpoints slightly."""
     noise_lines = []
@@ -51,45 +47,19 @@ def add_noise_lines_for_line(p1, p2, n=4, sigma=1.0):
 # ------------------------- Drawing utilities ------------------------------
 
 def draw_overlay(base_pil, yellow_lines, red_lines, yellow_points, red_points, vps=None):
-    """Return a new PIL image with overlays drawn: lines, points and vanishing points.
-
-    - yellow_lines, red_lines: lists of line coefficients
-    - yellow_points, red_points: lists of tuples (p1, p2) for each line
-    - vps: dict with keys 'yellow' and 'red' for vanishing points (x,y)
-    """
-    if isinstance(base_pil, np.ndarray):
-        img = Image.fromarray(base_pil).convert("RGBA")
-    else:
-        img = base_pil.copy().convert("RGBA")
-        
+    """Return a new PIL image with overlays drawn: lines, points and vanishing points."""
+    img = base_pil.copy().convert("RGBA")
     draw = ImageDraw.Draw(img)
 
-    # helpers
     def draw_point(pt, color, r=4):
         x, y = pt
         draw.ellipse((x - r, y - r, x + r, y + r), fill=color, outline=color)
 
-    def draw_line_by_points(p1, p2, color, width=2, dash=False):
-        # we just draw a straight segment connecting endpoints
-        if dash:
-            # dashed line: draw small segments
-            x1, y1 = p1
-            x2, y2 = p2
-            segs = 40
-            for i in range(segs):
-                t0 = i / segs
-                t1 = (i + 0.5) / segs
-                xa = x1 * (1 - t0) + x2 * t0
-                ya = y1 * (1 - t0) + y2 * t0
-                xb = x1 * (1 - t1) + x2 * t1
-                yb = y1 * (1 - t1) + y2 * t1
-                draw.line((xa, ya, xb, yb), fill=color, width=width)
-        else:
-            draw.line((p1[0], p1[1], p2[0], p2[1]), fill=color, width=width)
+    def draw_line_by_points(p1, p2, color, width=2):
+        draw.line((p1[0], p1[1], p2[0], p2[1]), fill=color, width=width)
 
     # Draw yellow lines
     for idx, ((p1, p2), L) in enumerate(zip(yellow_points, yellow_lines)):
-        # draw long extents of line by projecting to image bounds
         draw_line_segment_from_line(L, img.size, color=(255, 215, 0, 200), draw=draw)
         draw_point(p1, (255, 215, 0, 255))
         draw_point(p2, (255, 215, 0, 255))
@@ -109,36 +79,26 @@ def draw_overlay(base_pil, yellow_lines, red_lines, yellow_points, red_points, v
 
     return img.convert("RGB")
 
-
 def draw_line_segment_from_line(line, image_size, draw=None, color=(255, 255, 0, 255)):
-    """Given line coefficients and image size, draw a segment across the image bounds.
-    This draws directly using ImageDraw if 'draw' is provided.
-    """
+    """Given line coefficients and image size, draw a segment across the image bounds."""
     W, H = image_size
     a, b, c = line
     points = []
-    # intersection with left edge x=0
+    # intersection with edges
     if abs(b) > 1e-9:
-        y = -(a * 0 + c) / b
+        y = -c / b
         points.append((0, y))
-    # right edge x=W
-    if abs(b) > 1e-9:
         y = -(a * W + c) / b
         points.append((W, y))
-    # top edge y=0 --> a x + c = 0
     if abs(a) > 1e-9:
-        x = -(b * 0 + c) / a
+        x = -c / a
         points.append((x, 0))
-    # bottom edge y=H
-    if abs(a) > 1e-9:
         x = -(b * H + c) / a
         points.append((x, H))
 
     # keep only points within the image bounds
     pts_in = [(x, y) for (x, y) in points if -W * 0.1 <= x <= W * 1.1 and -H * 0.1 <= y <= H * 1.1]
     if len(pts_in) >= 2 and draw is not None:
-        # pick two extreme points
-        # sort by x coordinate
         pts_in = sorted(pts_in, key=lambda p: (p[0], p[1]))
         pA = pts_in[0]
         pB = pts_in[-1]
@@ -146,41 +106,22 @@ def draw_line_segment_from_line(line, image_size, draw=None, color=(255, 255, 0,
 
 # ------------------------- Gradio app callbacks ---------------------------
 
-def init_states():
-    return None, [], [], [], [], []
-
-
 def on_mode_change(mode, image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs):
-    """Switch drawing mode between 'yellow', 'red' or None.
-    Returns image (unchanged) and updated states.
-    """
-    # Just update the mode state. Clear any pending single point.
+    """Switch drawing mode between 'yellow', 'red' or None."""
     return (image, mode, [], y_lines, r_lines, y_pairs, r_pairs)
 
-
-def on_image_select(sel: gr.SelectData, image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs):
-    """Called when user clicks on the image. sel.index gives (x, y) in pixels.
-    """
+def on_image_click(evt: gr.SelectData, image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs):
+    """Called when user clicks on the image in Gradio 4.x"""
     if image is None:
-        gr.Warning("Please upload an image first.")
-        return image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
-        
-    if sel is None:
-        return image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
-
-    idx = getattr(sel, "index", None)
-    if idx is None:
-        idx = getattr(sel, "data", None) or getattr(sel, "value", None)
-    if not idx:
         return image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
 
-    x, y = int(idx[0]), int(idx[1])
-
-    # append to current_points
+    x, y = evt.index
+    
+    # Convert to list if needed
     current_points = list(current_points) if current_points is not None else []
     current_points.append((x, y))
 
-    # if we have two points, create a line
+    # If we have two points, create a line
     if len(current_points) >= 2 and current_mode in ("yellow", "red"):
         p1 = current_points[-2]
         p2 = current_points[-1]
@@ -195,38 +136,43 @@ def on_image_select(sel: gr.SelectData, image, current_mode, current_points, y_l
             r_pairs = list(r_pairs) if r_pairs is not None else []
             r_lines.append(L)
             r_pairs.append((p1, p2))
-        
-        # Clear current points after forming a line
+        # Reset current points for next line
         current_points = []
 
-
-    # redraw overlay image
-    base_pil = Image.fromarray(image) if isinstance(image, np.ndarray) else image
+    # Redraw overlay
+    if isinstance(image, np.ndarray):
+        base_pil = Image.fromarray(image)
+    else:
+        base_pil = image
+        
     out = draw_overlay(base_pil, y_lines or [], r_lines or [], y_pairs or [], r_pairs or [], vps=None)
+    out_np = np.array(out)
 
-    return out, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
-
+    return out_np, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
 
 def compute_vanishing_points(image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs):
-    """Compute vanishing points for both color groups, draw them and return annotated image.
-    """
+    """Compute vanishing points for both color groups."""
     if image is None:
-        gr.Warning("Please upload an image and draw lines first.")
         return image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
 
-    img_pil = Image.fromarray(image) if isinstance(image, np.ndarray) else image
+    if isinstance(image, np.ndarray):
+        img_pil = Image.fromarray(image)
+    else:
+        img_pil = image
 
     vps = {"yellow": None, "red": None}
 
-    # process yellow group
+    # Process yellow group
     if y_lines and len(y_lines) > 1:
         lines_arr = np.array(y_lines)
         inters = []
         for i in range(len(lines_arr) - 1):
             for j in range(i + 1, len(lines_arr)):
                 try:
-                    ip = np.linalg.solve(np.array([[lines_arr[i][0], lines_arr[i][1]],[lines_arr[j][0], lines_arr[j][1]]]),
-                                         -np.array([lines_arr[i][2], lines_arr[j][2]]))
+                    ip = np.linalg.solve(
+                        np.array([[lines_arr[i][0], lines_arr[i][1]], [lines_arr[j][0], lines_arr[j][1]]]),
+                        -np.array([lines_arr[i][2], lines_arr[j][2]])
+                    )
                     inters.append(ip)
                 except Exception:
                     pass
@@ -242,15 +188,17 @@ def compute_vanishing_points(image, current_mode, current_points, y_lines, r_lin
         res = minimize(lambda x: total_distances(x, lines_arr, noise), p0, method='Powell')
         vps['yellow'] = (float(res.x[0]), float(res.x[1]))
 
-    # process red group
+    # Process red group
     if r_lines and len(r_lines) > 1:
         lines_arr = np.array(r_lines)
         inters = []
         for i in range(len(lines_arr) - 1):
             for j in range(i + 1, len(lines_arr)):
                 try:
-                    ip = np.linalg.solve(np.array([[lines_arr[i][0], lines_arr[i][1]],[lines_arr[j][0], lines_arr[j][1]]]),
-                                         -np.array([lines_arr[i][2], lines_arr[j][2]]))
+                    ip = np.linalg.solve(
+                        np.array([[lines_arr[i][0], lines_arr[i][1]], [lines_arr[j][0], lines_arr[j][1]]]),
+                        -np.array([lines_arr[i][2], lines_arr[j][2]])
+                    )
                     inters.append(ip)
                 except Exception:
                     pass
@@ -267,73 +215,96 @@ def compute_vanishing_points(image, current_mode, current_points, y_lines, r_lin
         vps['red'] = (float(res.x[0]), float(res.x[1]))
 
     out = draw_overlay(img_pil, y_lines or [], r_lines or [], y_pairs or [], r_pairs or [], vps=vps)
-    # Return state, clearing current_points
-    return out, current_mode, [], y_lines, r_lines, y_pairs, r_pairs
+    out_np = np.array(out)
 
+    return out_np, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
 
-def on_upload(image):
-    # When a new image is uploaded, reset all states
+def reset_all(image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs):
+    """Reset all states."""
+    if image is not None:
+        if isinstance(image, np.ndarray):
+            return image, None, [], [], [], [], []
+        else:
+            return np.array(image), None, [], [], [], [], []
     return image, None, [], [], [], [], []
 
 # ------------------------------ Build Blocks ------------------------------
 
 def build_gradio_interface():
-    with gr.Blocks(theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# ☀️ Shadow Vanishing-Point Picker")
+    with gr.Blocks() as demo:
+        gr.Markdown("# Shadow Analysis - Vanishing Point Detection")
+        
         with gr.Row():
-            img_in = gr.Image(label="Upload image and then click to add points", type="numpy", interactive=True, height=600)
-            with gr.Column(scale=1):
-                start_y = gr.Button("Start Yellow Line")
-                start_r = gr.Button("Start Red Line")
+            img_in = gr.Image(
+                label="Upload image and click to add points", 
+                type="numpy", 
+                interactive=True, 
+                height=600
+            )
+            with gr.Column():
+                start_y = gr.Button("Start Yellow Lines")
+                start_r = gr.Button("Start Red Lines") 
                 none_btn = gr.Button("Stop Drawing")
-                compute_btn = gr.Button("Compute Vanishing Points", variant="primary")
+                compute_btn = gr.Button("Compute Vanishing Points")
                 reset_btn = gr.Button("Reset All")
-                gr.Markdown("Click the image to add points. Two points make one line. Add at least 2 lines per color group to compute a vanishing point.")
-
-        # states
+                
+                gr.Markdown("""
+                **Instructions:**
+                1. Upload an image
+                2. Click 'Start Yellow' or 'Start Red' to choose line color
+                3. Click on the image to add points (2 points = 1 line)
+                4. Add at least 2 lines per color group
+                5. Click 'Compute Vanishing Points' to analyze
+                """)
+
+        # State variables
         current_mode = gr.State(None)
         current_points = gr.State([])
         y_lines = gr.State([])
         r_lines = gr.State([])
         y_pairs = gr.State([])
         r_pairs = gr.State([])
+
+        # Event handlers
+        start_y.click(
+            fn=on_mode_change,
+            inputs=[gr.State("yellow"), img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
+            outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs]
+        )
         
-        # Original image state to allow reseting
-        original_image = gr.State()
-
-        # link buttons to mode change
-        start_y.click(on_mode_change, inputs=[gr.State("yellow"), img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
-                      outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs])
-        start_r.click(on_mode_change, inputs=[gr.State("red"), img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
-                      outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs])
-        none_btn.click(on_mode_change, inputs=[gr.State(None), img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
-                      outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs])
-
-        # image select event
-        img_in.select(on_image_select, inputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
-                      outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs])
-
-        compute_btn.click(compute_vanishing_points, inputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
-                          outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs])
-
-        # Store original image on upload
-        img_in.upload(
-            lambda img: (img, img, None, [], [], [], [], []),  # Reset all states on new upload
-            inputs=[img_in],
-            outputs=[img_in, original_image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs]
+        start_r.click(
+            fn=on_mode_change, 
+            inputs=[gr.State("red"), img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
+            outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs]
         )
         
-        # Reset button restores the original image and clears states
+        none_btn.click(
+            fn=on_mode_change,
+            inputs=[gr.State(None), img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
+            outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs]
+        )
+
+        # Image click event - updated for Gradio 4.x
+        img_in.select(
+            fn=on_image_click,
+            inputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
+            outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs]
+        )
+
+        compute_btn.click(
+            fn=compute_vanishing_points,
+            inputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
+            outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs]
+        )
+
         reset_btn.click(
-            lambda img: (img, None, [], [], [], [], []), # Reset all states
-            inputs=[original_image],
+            fn=reset_all,
+            inputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
             outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs]
         )
 
     return demo
 
-# --- Remove the launch() call ---
-# if __name__ == '__main__':
-#     demo = build_gradio_interface()
-#     demo.queue()
-#     demo.launch()
+if __name__ == '__main__':
+    demo = build_gradio_interface()
+    demo.launch()