upload

CFA.py

@@ -122,50 +122,53 @@ def analyze_region(original_image: np.ndarray, box_coords: tuple):
     print(f"4. Analysis complete in {time.time() - start_time:.2f} seconds.")
     return fig
 
-# --- Build the Gradio Interface using Blocks ---
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    # State variables store data (like the original image) between user interactions
-    original_image_state = gr.State()
-    box_coords_state = gr.State(value=(0, 0))
-
-    gr.Markdown("# 🖼️ Image Patch Analyzer")
-    gr.Markdown(
-        "**Instructions:**\n"
-        "1. **Upload** an image.\n"
-        "2. **Click** anywhere on the image to move the 128x128 selection box.\n"
-        "3. Press the **Analyze Region** button to start processing."
-    )
-
-    with gr.Row():
-        image_display = gr.Image(type="numpy", label="Selection Canvas")
-        output_plot = gr.Plot(label="Analysis Results")
-
-    analyze_button = gr.Button("Analyze Region", variant="primary")
-
-    # --- Wire up the event listeners ---
-
-    # 1. When a new image is uploaded, call on_upload_image
-    image_display.upload(
-        fn=on_upload_image,
-        inputs=[image_display],
-        outputs=[image_display, original_image_state, box_coords_state]
-    )
-
-    # 2. When the user clicks the image, call move_selection_box
-    image_display.select(
-        fn=move_selection_box,
-        inputs=[original_image_state],
-        outputs=[image_display, box_coords_state]
-    )
-    
-    # 3. When the user clicks the analyze button, call analyze_region
-    analyze_button.click(
-        fn=analyze_region,
-        inputs=[original_image_state, box_coords_state],
-        outputs=[output_plot],
-        # Show a progress bar during analysis
-        show_progress="full" 
-    )
-
-# --- Launch the App ---
-demo.launch()
+def build_demo():
+    # --- Build the Gradio Interface using Blocks ---
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        # State variables store data (like the original image) between user interactions
+        original_image_state = gr.State()
+        box_coords_state = gr.State(value=(0, 0))
+
+        gr.Markdown("# 🖼️ Image Patch Analyzer")
+        gr.Markdown(
+            "**Instructions:**\n"
+            "1. **Upload** an image.\n"
+            "2. **Click** anywhere on the image to move the 128x128 selection box.\n"
+            "3. Press the **Analyze Region** button to start processing."
+        )
+
+        with gr.Row():
+            image_display = gr.Image(type="numpy", label="Selection Canvas")
+            output_plot = gr.Plot(label="Analysis Results")
+
+        analyze_button = gr.Button("Analyze Region", variant="primary")
+
+        # --- Wire up the event listeners ---
+
+        # 1. When a new image is uploaded, call on_upload_image
+        image_display.upload(
+            fn=on_upload_image,
+            inputs=[image_display],
+            outputs=[image_display, original_image_state, box_coords_state]
+        )
+
+        # 2. When the user clicks the image, call move_selection_box
+        image_display.select(
+            fn=move_selection_box,
+            inputs=[original_image_state],
+            outputs=[image_display, box_coords_state]
+        )
+        
+        # 3. When the user clicks the analyze button, call analyze_region
+        analyze_button.click(
+            fn=analyze_region,
+            inputs=[original_image_state, box_coords_state],
+            outputs=[output_plot],
+            # Show a progress bar during analysis
+            show_progress="full" 
+        )
+    return demo
+
+if __name__ == "__main__":
+    app = build_demo()
+    app.launch()

JPEG_Ghost.py

@@ -96,54 +96,57 @@ def run_analysis(original_image: np.ndarray, box_coords: tuple, qf1: int, qf2: i
 
     return im_composite, fig
 
-# --- Build the Gradio Interface ---
-
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🕵️ JPEG Double Compression Analyzer")
-    gr.Markdown(
-        "**Instructions:**\n"
-        "1. **Upload** an image.\n"
-        "2. **Click** on the image to move the 256x256 selection box.\n"
-        "3. Press **Analyze Image** to process the selected region."
-    )
-
-    original_image_state = gr.State()
-    box_coords_state = gr.State()
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 1. Inputs")
-            image_display = gr.Image(type="numpy", label="Upload Image & Click to Select")
-            qf1_slider = gr.Slider(minimum=1, maximum=100, value=70, step=1, label="QF1: Background Quality")
-            qf2_slider = gr.Slider(minimum=1, maximum=100, value=85, step=1, label="QF2: Final Composite Quality")
-            gr.Markdown("#### Analysis QF Range")
-            with gr.Row():
-                qf_start_slider = gr.Slider(minimum=50, maximum=100, value=50, step=5, label="Start")
-                qf_end_slider = gr.Slider(minimum=50, maximum=100, value=90, step=5, label="End")
-            analyze_button = gr.Button("Analyze Image", variant="primary")
-
-        with gr.Column(scale=2):
-            gr.Markdown("### 2. Results")
-            composite_image_display = gr.Image(type="numpy", label="Generated Composite Image")
-            difference_plot_display = gr.Plot(label="Difference Maps")
-    
-    # Event Listeners
-    image_display.upload(
-        fn=on_upload_image,
-        inputs=[image_display],
-        outputs=[image_display, original_image_state, box_coords_state]
-    )
-    
-    image_display.select(
-        fn=move_selection_box,
-        inputs=[original_image_state],
-        outputs=[image_display, box_coords_state]
-    )
-    
-    analyze_button.click(
-        fn=run_analysis,
-        inputs=[original_image_state, box_coords_state, qf1_slider, qf2_slider, qf_start_slider, qf_end_slider],
-        outputs=[composite_image_display, difference_plot_display]
-    )
-
-demo.launch(debug=True)
+def build_demo():
+    # --- Build the Gradio Interface ---
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🕵️ JPEG Double Compression Analyzer")
+        gr.Markdown(
+            "**Instructions:**\n"
+            "1. **Upload** an image.\n"
+            "2. **Click** on the image to move the 256x256 selection box.\n"
+            "3. Press **Analyze Image** to process the selected region."
+        )
+
+        original_image_state = gr.State()
+        box_coords_state = gr.State()
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 1. Inputs")
+                image_display = gr.Image(type="numpy", label="Upload Image & Click to Select")
+                qf1_slider = gr.Slider(minimum=1, maximum=100, value=70, step=1, label="QF1: Background Quality")
+                qf2_slider = gr.Slider(minimum=1, maximum=100, value=85, step=1, label="QF2: Final Composite Quality")
+                gr.Markdown("#### Analysis QF Range")
+                with gr.Row():
+                    qf_start_slider = gr.Slider(minimum=50, maximum=100, value=50, step=5, label="Start")
+                    qf_end_slider = gr.Slider(minimum=50, maximum=100, value=90, step=5, label="End")
+                analyze_button = gr.Button("Analyze Image", variant="primary")
+
+            with gr.Column(scale=2):
+                gr.Markdown("### 2. Results")
+                composite_image_display = gr.Image(type="numpy", label="Generated Composite Image")
+                difference_plot_display = gr.Plot(label="Difference Maps")
+        
+        # Event Listeners
+        image_display.upload(
+            fn=on_upload_image,
+            inputs=[image_display],
+            outputs=[image_display, original_image_state, box_coords_state]
+        )
+        
+        image_display.select(
+            fn=move_selection_box,
+            inputs=[original_image_state],
+            outputs=[image_display, box_coords_state]
+        )
+        
+        analyze_button.click(
+            fn=run_analysis,
+            inputs=[original_image_state, box_coords_state, qf1_slider, qf2_slider, qf_start_slider, qf_end_slider],
+            outputs=[composite_image_display, difference_plot_display]
+        )
+    return demo
+
+if __name__ == "__main__":
+    app = build_demo()
+    app.launch(debug=True)

PRNU.py

@@ -114,19 +114,21 @@ def analyze_image_forgery(fingerprint_file, input_image):
     return fig1, fig2
 
 # --- Create and Launch the Gradio Interface ---
-iface = gr.Interface(
-    fn=analyze_image_forgery,
-    inputs=[
-        gr.File(label="Upload Camera Fingerprint (.dat file)"),
-        gr.Image(type="numpy", label="Upload Image to Analyze")
-    ],
-    outputs=[
-        gr.Plot(label="PCE Map"),
-        gr.Plot(label="Analyzed Image")
-    ],
-    title="📸 PRNU-Based Image Forgery Detector",
-    description=description
-)
-
-# Launch the app locally
-iface.launch()
+def build_demo():
+    return gr.Interface(
+        fn=analyze_image_forgery,
+        inputs=[
+            gr.File(label="Upload Camera Fingerprint (.dat file)"),
+            gr.Image(type="numpy", label="Upload Image to Analyze")
+        ],
+        outputs=[
+            gr.Plot(label="PCE Map"),
+            gr.Plot(label="Analyzed Image")
+        ],
+        title="📸 PRNU-Based Image Forgery Detector",
+        description=description
+    )
+
+if __name__ == "__main__":
+    iface = build_demo()
+    iface.launch()

README.md

@@ -1,19 +1,8 @@
----
-title: Digital Image Forensics Toolkit
-emoji: 🕵️‍♂️
-colorFrom: blue
-colorTo: indigo
-sdk: gradio
-sdk_version: "5.49.1"
-app_file: app.py
-pinned: false
----
-
 # Digital Image Forensics Toolkit 🕵️‍♂️
 
-This space provides a collection of fundamental digital forensic algorithms designed to detect "cheap fakes"—image manipulations created with standard editing software.
+This repository provides a collection of fundamental digital forensic algorithms designed to detect "cheap fakes"—image manipulations created with standard editing software like Photoshop or GIMP. The tools are implemented in Python and deployed on a local server using a [Gradio](https://www.gradio.app/) web interface.
 
-These methods are effective for identifying traditional forgeries such as splicing, copy-move, and inconsistent lighting. Select a tool from the tabs above to get started.
+These methods are effective for identifying traditional forgeries such as splicing, copy-move, and inconsistent lighting.
 
 ---
 
@@ -33,5 +22,32 @@ Uses the **Photo Response Non-Uniformity (PRNU)** pattern, a unique noise finger
 ### ☀️ Shadow Consistency Analysis (`shadows.py`)
 A utility for verifying geometric consistency of shadows in an image. By projecting vanishing points, it helps determine if all shadows correspond to a single, coherent light source. This method is based on principles of perspective and can be useful for analyzing both traditional manipulations and AI-generated images.
 
+---
+
+## ⚙️ Getting Started
+
+### Prerequisites
+* Python 3.10+
+* pip
+
+### Installation
+
+    pip install -r requirements.txt
+    
+### Run locally
+
+    python app.py
+
+---
+
+## 🚀 Deploying to Hugging Face Spaces
+
+This repo is ready for a Gradio Space.
+
+- Set the Space SDK to: Gradio
+- Set the entry point to: `app.py`
+- Hardware: CPU is sufficient
+
+The `requirements.txt` already includes all dependencies.
 
-    
+---

app.py

@@ -1,28 +1,38 @@
 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 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()
-    ],
-    tab_names=[
-        "🎨 CFA Analysis",
-        "👻 JPEG Ghost",
-        "📸 PRNU Analysis",
-        "☀️ Shadow Analysis"
-    ],
-    title="Digital Image Forensics Toolkit 🕵️‍♂️"
-)
-
-# Launch the app
+# Import build functions from the tools (they are guarded to not auto-launch)
+import CFA
+import JPEG_Ghost
+import PRNU
+import shadows
+
+
+def build_app():
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🔍 Image Forensics Toolkit")
+        gr.Markdown(
+            "Use the tabs below to run different non-AI image forensics methods."
+        )
+
+        with gr.Tabs():
+            with gr.TabItem("CFA Artifacts"):
+                CFA.build_demo().render()
+
+            with gr.TabItem("JPEG Ghost / Double Compression"):
+                JPEG_Ghost.build_demo().render()
+
+            with gr.TabItem("PRNU (Camera Fingerprint)"):
+                PRNU.build_demo().render()
+
+            with gr.TabItem("Vanishing Points (Shadows/Geometry)"):
+                shadows.build_gradio_interface().render()
+
+    return demo
+
+
 if __name__ == "__main__":
-    demo.launch()
+    app = build_app()
+    app.queue()
+    app.launch()
+
+

requirements.txt

@@ -1,47 +1,9 @@
-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
+gradio==5.49.1
 numpy==1.24.4
-opencv-python==4.10.0.84
-packaging==24.2
-parso==0.8.4
-pickleshare==0.7.5
+scipy==1.10.1
 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
+matplotlib==3.7.5
+imageio==2.35.1
 scikit-image==0.21.0
-scipy==1.10.1
-six==1.16.0
-tornado==6.4.1
-gradio==5.49.1
-huggingface_hub
-fastapi
-uvicorn
+opencv-python==4.10.0.84
+PyWavelets==1.4.1

shadow.py

@@ -1,11 +1,36 @@
 """
-Gradio app for shadow analysis with vanishing-point selection tool
-Updated for Gradio 4.x compatibility
+Gradio app to replicate the interactive vanishing-point selection tool
+from the supplied matplotlib script, implemented for gradio==3.50.2.
+
+How it works (UI):
+- Upload an image.
+- Click "Start Yellow" or "Start Red" to enter a drawing mode for that line group.
+- Click on the image to add points. Two consecutive clicks make a line.
+- You can add as many lines as you want for each color.
+- Press "Compute vanishing points" to run optimization (scipy.minimize) for
+  each color group and display the vanishing points and overlayed lines.
+- Reset clears all state.
+
+Requirements:
+- gradio==3.50.2
+- numpy
+- scipy
+- pillow
+
+Run:
+    pip install gradio==3.50.2 numpy scipy pillow
+    python grad_io_gradio_app.py
+
+Note: This implementation uses the Image.select event which behaves correctly
+in gradio 3.50.2 (it provides pixel coordinates of the clicked point). If you
+use a newer Gradio version, the event behavior might differ.
+
 """
 
+import io
 import math
 import numpy as np
-from PIL import Image, ImageDraw
+from PIL import Image, ImageDraw, ImageFont
 import gradio as gr
 from scipy.optimize import minimize
 
@@ -20,11 +45,13 @@ 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
@@ -35,6 +62,7 @@ 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 = []
@@ -47,19 +75,41 @@ 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."""
+    """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)
+    """
     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):
-        draw.line((p1[0], p1[1], p2[0], p2[1]), fill=color, width=width)
+    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)
 
     # 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))
@@ -79,26 +129,36 @@ 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."""
+    """Given line coefficients and image size, draw a segment across the image bounds.
+    This draws directly using ImageDraw if 'draw' is provided.
+    """
     W, H = image_size
     a, b, c = line
     points = []
-    # intersection with edges
+    # intersection with left edge x=0
     if abs(b) > 1e-9:
-        y = -c / b
+        y = -(a * 0 + 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 = -c / a
+        x = -(b * 0 + 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]
@@ -106,22 +166,52 @@ def draw_line_segment_from_line(line, image_size, draw=None, color=(255, 255, 0,
 
 # ------------------------- Gradio app callbacks ---------------------------
 
+# We'll store states in gr.State objects:
+# - current_mode: None | 'yellow' | 'red'
+# - current_points: list of pending points (len 0 or 1 waiting for second click)
+# - yellow_lines: list of (A,B,C)
+# - red_lines: list of (A,B,C)
+# - yellow_points_pairs: list of ((p1,p2))
+# - red_points_pairs: list of ((p1,p2))
+
+
+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."""
+    """Switch drawing mode between 'yellow', 'red' or None.
+    Returns image (unchanged) and updated states.
+    """
+    # Just update the mode state. Clear any pending single point.
     return (image, mode, [], y_lines, r_lines, y_pairs, r_pairs)
 
-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:
+
+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.
+
+    We append the point, and when there are 2 points we form a line and add to the
+    corresponding color list. We then redraw overlays and return the updated image and states.
+    """
+    # sel may contain relative coords depending on gradio version; here we expect .index
+    if sel is None:
+        return image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
+
+    idx = getattr(sel, "index", None)
+    # Some versions wrap coordinates as [x, y], some as (x, y)
+    if idx is None:
+        # fallback: try .data or .value
+        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 = evt.index
-    
-    # Convert to list if needed
+    x, y = int(idx[0]), int(idx[1])
+
+    # append to current_points
     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]
@@ -136,51 +226,44 @@ def on_image_click(evt: gr.SelectData, image, current_mode, current_points, y_li
             r_pairs = list(r_pairs) if r_pairs is not None else []
             r_lines.append(L)
             r_pairs.append((p1, p2))
-        # Reset current points for next line
-        current_points = []
-
-    # Redraw overlay
-    if isinstance(image, np.ndarray):
-        base_pil = Image.fromarray(image)
-    else:
-        base_pil = image
-        
+
+    # redraw overlay image
+    base_pil = Image.fromarray(image) if not isinstance(image, Image.Image) else 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_np, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
+    return out, 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."""
-    if image is None:
-        return 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.
 
-    if isinstance(image, np.ndarray):
-        img_pil = Image.fromarray(image)
-    else:
-        img_pil = image
+    For each group: if there are >1 lines, compute intersections and use mean intersection
+    as initial guess; then minimize sum of distances to lines + noise-lines.
+    """
+    img_pil = Image.fromarray(image) if not isinstance(image, Image.Image) else 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)
+        # intersections
         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
         if inters:
             p0 = np.mean(inters, axis=0)
         else:
+            # fallback: center of image
             p0 = np.array([img_pil.width / 2, img_pil.height / 2])
 
+        # noise lines
         noise = []
         for (p1, p2) in y_pairs:
             noise += add_noise_lines_for_line(p1, p2, n=4, sigma=2.0)
@@ -188,17 +271,15 @@ 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
@@ -215,49 +296,29 @@ 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)
-    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 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, [], [], [], [], []
+    base_pil = Image.fromarray(image) if not isinstance(image, Image.Image) else image
+    return base_pil, None, [], [], [], [], []
 
 # ------------------------------ Build Blocks ------------------------------
 
 def build_gradio_interface():
     with gr.Blocks() as demo:
-        gr.Markdown("# Shadow Analysis - Vanishing Point Detection")
-        
+        gr.Markdown("# grad.io — Vanishing-point picker (Gradio 3.50.2 sample)")
         with gr.Row():
-            img_in = gr.Image(
-                label="Upload image and click to add points", 
-                type="numpy", 
-                interactive=True, 
-                height=600
-            )
+            img_in = gr.Image(label="Upload image and then click to add points", type="numpy", interactive=True, height=800)
             with gr.Column():
-                start_y = gr.Button("Start Yellow Lines")
-                start_r = gr.Button("Start Red Lines") 
+                start_y = gr.Button("Start Yellow")
+                start_r = gr.Button("Start Red")
                 none_btn = gr.Button("Stop Drawing")
-                compute_btn = gr.Button("Compute Vanishing Points")
-                reset_btn = gr.Button("Reset All")
-                
-                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
+                compute_btn = gr.Button("Compute vanishing points")
+                reset_btn = gr.Button("Reset")
+                gr.Markdown("\nClick the image to add points. Two points => one line. Add at least 2 lines per group to compute a vanishing point.")
+
+        # states
         current_mode = gr.State(None)
         current_points = gr.State([])
         y_lines = gr.State([])
@@ -265,46 +326,28 @@ def build_gradio_interface():
         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]
-        )
-        
-        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]
-        )
-        
-        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(
-            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]
-        )
+        # 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])
+
+        reset_btn.click(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
 
+
 if __name__ == '__main__':
     demo = build_gradio_interface()
-    demo.launch()
+    demo.queue()
+    demo.launch()

shadows.py

@@ -1,353 +0,0 @@
-"""
-Gradio app to replicate the interactive vanishing-point selection tool
-from the supplied matplotlib script, implemented for gradio==3.50.2.
-
-How it works (UI):
-- Upload an image.
-- Click "Start Yellow" or "Start Red" to enter a drawing mode for that line group.
-- Click on the image to add points. Two consecutive clicks make a line.
-- You can add as many lines as you want for each color.
-- Press "Compute vanishing points" to run optimization (scipy.minimize) for
-  each color group and display the vanishing points and overlayed lines.
-- Reset clears all state.
-
-Requirements:
-- gradio==3.50.2
-- numpy
-- scipy
-- pillow
-
-Run:
-    pip install gradio==3.50.2 numpy scipy pillow
-    python grad_io_gradio_app.py
-
-Note: This implementation uses the Image.select event which behaves correctly
-in gradio 3.50.2 (it provides pixel coordinates of the clicked point). If you
-use a newer Gradio version, the event behavior might differ.
-
-"""
-
-import io
-import math
-import numpy as np
-from PIL import Image, ImageDraw, ImageFont
-import gradio as gr
-from scipy.optimize import minimize
-
-# ------------------------ Helper math functions ---------------------------
-
-def build_line_from_points(p1, p2):
-    """Return line coefficients (A, B, C) for Ax + By + C = 0 given two points."""
-    x1, y1 = p1
-    x2, y2 = p2
-    a = y1 - y2
-    b = x2 - x1
-    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
-    s = 0.0
-    for L in lines:
-        s += distance_point_to_line(pt, L)
-    for Ln in 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 = []
-    for _ in range(n):
-        p1n = (p1[0] + np.random.normal(0, sigma), p1[1] + np.random.normal(0, sigma))
-        p2n = (p2[0] + np.random.normal(0, sigma), p2[1] + np.random.normal(0, sigma))
-        noise_lines.append(build_line_from_points(p1n, p2n))
-    return noise_lines
-
-# ------------------------- 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)
-    """
-    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)
-
-    # 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))
-
-    # Draw red lines
-    for idx, ((p1, p2), L) in enumerate(zip(red_points, red_lines)):
-        draw_line_segment_from_line(L, img.size, color=(255, 64, 64, 200), draw=draw)
-        draw_point(p1, (255, 64, 64, 255))
-        draw_point(p2, (255, 64, 64, 255))
-
-    # Draw vanishing points if present
-    if vps is not None:
-        if "yellow" in vps and vps["yellow"] is not None:
-            draw_point(vps["yellow"], (255, 215, 0, 255), r=6)
-        if "red" in vps and vps["red"] is not None:
-            draw_point(vps["red"], (255, 64, 64, 255), r=6)
-
-    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.
-    """
-    W, H = image_size
-    a, b, c = line
-    points = []
-    # intersection with left edge x=0
-    if abs(b) > 1e-9:
-        y = -(a * 0 + 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
-        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]
-        draw.line((pA[0], pA[1], pB[0], pB[1]), fill=color, width=2)
-
-# ------------------------- Gradio app callbacks ---------------------------
-
-# We'll store states in gr.State objects:
-# - current_mode: None | 'yellow' | 'red'
-# - current_points: list of pending points (len 0 or 1 waiting for second click)
-# - yellow_lines: list of (A,B,C)
-# - red_lines: list of (A,B,C)
-# - yellow_points_pairs: list of ((p1,p2))
-# - red_points_pairs: list of ((p1,p2))
-
-
-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.
-    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.
-
-    We append the point, and when there are 2 points we form a line and add to the
-    corresponding color list. We then redraw overlays and return the updated image and states.
-    """
-    # sel may contain relative coords depending on gradio version; here we expect .index
-    if sel is None:
-        return image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
-
-    idx = getattr(sel, "index", None)
-    # Some versions wrap coordinates as [x, y], some as (x, y)
-    if idx is None:
-        # fallback: try .data or .value
-        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
-    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 len(current_points) >= 2 and current_mode in ("yellow", "red"):
-        p1 = current_points[-2]
-        p2 = current_points[-1]
-        L = build_line_from_points(p1, p2)
-        if current_mode == "yellow":
-            y_lines = list(y_lines) if y_lines is not None else []
-            y_pairs = list(y_pairs) if y_pairs is not None else []
-            y_lines.append(L)
-            y_pairs.append((p1, p2))
-        else:
-            r_lines = list(r_lines) if r_lines is not None else []
-            r_pairs = list(r_pairs) if r_pairs is not None else []
-            r_lines.append(L)
-            r_pairs.append((p1, p2))
-
-    # redraw overlay image
-    base_pil = Image.fromarray(image) if not isinstance(image, Image.Image) else image
-    out = draw_overlay(base_pil, y_lines or [], r_lines or [], y_pairs or [], r_pairs or [], vps=None)
-
-    return out, 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.
-
-    For each group: if there are >1 lines, compute intersections and use mean intersection
-    as initial guess; then minimize sum of distances to lines + noise-lines.
-    """
-    img_pil = Image.fromarray(image) if not isinstance(image, Image.Image) else image
-
-    vps = {"yellow": None, "red": None}
-
-    # process yellow group
-    if y_lines and len(y_lines) > 1:
-        lines_arr = np.array(y_lines)
-        # intersections
-        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]]))
-                    inters.append(ip)
-                except Exception:
-                    pass
-        if inters:
-            p0 = np.mean(inters, axis=0)
-        else:
-            # fallback: center of image
-            p0 = np.array([img_pil.width / 2, img_pil.height / 2])
-
-        # noise lines
-        noise = []
-        for (p1, p2) in y_pairs:
-            noise += add_noise_lines_for_line(p1, p2, n=4, sigma=2.0)
-
-        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
-    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]]))
-                    inters.append(ip)
-                except Exception:
-                    pass
-        if inters:
-            p0 = np.mean(inters, axis=0)
-        else:
-            p0 = np.array([img_pil.width / 2, img_pil.height / 2])
-
-        noise = []
-        for (p1, p2) in r_pairs:
-            noise += add_noise_lines_for_line(p1, p2, n=4, sigma=2.0)
-
-        res = minimize(lambda x: total_distances(x, lines_arr, noise), p0, method='Powell')
-        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 out, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
-
-
-def reset_all(image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs):
-    base_pil = Image.fromarray(image) if not isinstance(image, Image.Image) else image
-    return base_pil, None, [], [], [], [], []
-
-# ------------------------------ Build Blocks ------------------------------
-
-def build_gradio_interface():
-    with gr.Blocks() as demo:
-        gr.Markdown("# grad.io — Vanishing-point picker (Gradio 3.50.2 sample)")
-        with gr.Row():
-            img_in = gr.Image(label="Upload image and then click to add points", type="numpy", interactive=True, height=800)
-            with gr.Column():
-                start_y = gr.Button("Start Yellow")
-                start_r = gr.Button("Start Red")
-                none_btn = gr.Button("Stop Drawing")
-                compute_btn = gr.Button("Compute vanishing points")
-                reset_btn = gr.Button("Reset")
-                gr.Markdown("\nClick the image to add points. Two points => one line. Add at least 2 lines per group to compute a vanishing point.")
-
-        # states
-        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([])
-
-        # 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])
-
-        reset_btn.click(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
-
-
-if __name__ == '__main__':
-    demo = build_gradio_interface()
-    demo.queue()
-    demo.launch()