upload

CFA.py

@@ -122,54 +122,50 @@ 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 in a function ---
-def create_ui():
-    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 (CFA)")
-        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
-
-# --- Remove the launch() call ---
-# if __name__ == "__main__":
-#     demo = create_ui()
-#     demo.launch()
+# --- 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()

JPEG_Ghost.py

@@ -96,59 +96,54 @@ def run_analysis(original_image: np.ndarray, box_coords: tuple, qf1: int, qf2: i
 
     return im_composite, fig
 
-# --- Build the Gradio Interface in a function ---
-
-def create_ui():
-    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
-
-# --- Remove the launch() call ---
-# if __name__ == "__main__":
-#     demo = create_ui()
-#     demo.launch(debug=True)
+# --- 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)

PRNU.py

@@ -1,31 +1,19 @@
 import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
-import imageio.v2 as imageio
+import imageio
 import tempfile
 import os
 
 # --- Import your custom source files ---
-# This assumes a 'utils' directory is in the root of the HF Space
-try:
-    import utils.src.Functions as Fu
-    import utils.src.Filter as Ft
-    import utils.src.maindir as md
-except ImportError:
-    print("Warning: Could not import 'utils.src' modules.")
-    print("Please ensure the 'utils' directory is present in your repository.")
-    # Define dummy functions so the app can at least load
-    class DummyModule:
-        def __getattr__(self, name):
-            def dummy_func(*args, **kwargs):
-                raise ImportError(f"Module 'utils.src' not loaded. '{name}' is unavailable.")
-            return dummy_func
-    Fu = DummyModule()
-    Ft = DummyModule()
-    md = DummyModule()
-
+# Make sure the 'src' folder is in the same directory as this notebook
+import utils.src.Functions as Fu
+import utils.src.Filter as Ft
+import utils.src.maindir as md
 
 # --- App Description ---
+# A detailed description using Markdown. It explains what the tool does and how to use it.
+# You can add images from the web using standard markdown syntax.
 description = """
 # 📸 PRNU-Based Image Forgery Detector
 
@@ -46,108 +34,99 @@ This tool analyzes an image to detect potential manipulations using Photo-Respon
 """
 
 # --- Main Analysis Function ---
+# This function contains all the logic from your script.
+# It takes a fingerprint file and an image array as input, and returns two plots.
 def analyze_image_forgery(fingerprint_file, input_image):
     """
     Processes an image against a camera fingerprint to generate a PCE map.
-    """
-    if fingerprint_file is None:
-        raise gr.Error("Please upload a camera fingerprint (.dat file).")
-    if input_image is None:
-        raise gr.Error("Please upload an image to analyze.")
-        
-    try:
-        # --- 1. Load Camera Fingerprint ---
-        print("Loading camera fingerprint...")
-        Fingerprint = np.genfromtxt(fingerprint_file.name)
-        print(f"Fingerprint loaded. Shape: {Fingerprint.shape}")
-
-        # --- 2. Save uploaded image to a temporary file ---
-        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as temp_img_file:
-            temp_img_path = temp_img_file.name
-            imageio.imwrite(temp_img_path, input_image)
-
-        # --- 3. Extract and filter PRNU noise from the image ---
-        print("Extracting noise from image...")
-        Noisex = Ft.NoiseExtractFromImage(temp_img_path, sigma=2.)
-        Noisex = Fu.WienerInDFT(Noisex, np.std(Noisex))
-        print(f"Noise extracted. Shape: {Noisex.shape}")
-
-        # Clean up the temporary image file
-        os.remove(temp_img_path)
-
-        # --- 4. Align Fingerprint and PRNU sizes by padding if necessary ---
-        if Noisex.shape != Fingerprint.shape:
-            print("Shapes do not match. Padding PRNU noise to match fingerprint size.")
-            Noisex_padded = np.zeros_like(Fingerprint)
-            h = min(Noisex.shape[0], Fingerprint.shape[0])
-            w = min(Noisex.shape[1], Fingerprint.shape[1])
-            Noisex_padded[:h, :w] = Noisex[:h, :w]
-            Noisex = Noisex_padded
+    
+    Args:
+        fingerprint_file (gradio.File): The uploaded camera fingerprint .dat file.
+        input_image (np.array): The uploaded image as a NumPy array.
         
-        # --- 5. Compute PCE Map in blocks ---
-        print("Computing PCE map...")
-        block_size = 64
-        blocks_x = np.arange(0, Noisex.shape[0], block_size)
-        blocks_y = np.arange(0, Noisex.shape[1], block_size)
-        PCE_map = np.zeros((len(blocks_x), len(blocks_y)))
-
-        for y_idx, y_start in enumerate(blocks_y):
-            for x_idx, x_start in enumerate(blocks_x):
-                block_Noisex = Noisex[x_start:x_start+block_size, y_start:y_start+block_size]
-                block_Fingerprint = Fingerprint[x_start:x_start+block_size, y_start:y_start+block_size]
-                
-                # Skip if blocks are not of the expected size (can happen at edges)
-                if block_Noisex.shape != (block_size, block_size):
-                    continue
-
-                C = Fu.crosscorr(block_Noisex, block_Fingerprint)
-                det, _ = md.PCE(C)
-                PCE_map[x_idx, y_idx] = det.get('PCE', 0) # Use .get for safety
-
-        print("PCE map computed successfully.")
-
-        # --- 6. Generate Output Plots ---
-        # Plot 1: PCE Map
-        fig1, ax1 = plt.subplots(figsize=(8, 6))
-        im = ax1.imshow(PCE_map, cmap='viridis')
-        ax1.set_title('Detection PCE-map')
-        fig1.colorbar(im, ax=ax1, label='PCE Value')
-        
-        # Plot 2: Original Image
-        fig2, ax2 = plt.subplots(figsize=(8, 6))
-        ax2.imshow(input_image)
-        ax2.set_title('Analyzed Image')
-        ax2.axis('off')
-
-        return fig1, fig2
-
-    except ImportError as e:
-        print(f"ImportError: {e}")
-        raise gr.Error("Missing 'utils' module. Please ensure the 'utils' directory is in the repository.")
-    except Exception as e:
-        print(f"An error occurred: {e}")
-        raise gr.Error(f"An error occurred during analysis: {e}")
-
-
-# --- Create the Gradio Interface in a function ---
-def create_ui():
-    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,
-        theme=gr.themes.Soft()
-    )
-    return iface
-
-# --- Remove the launch() call ---
-# if __name__ == "__main__":
-#     iface = create_ui()
-#     iface.launch()
+    Returns:
+        (matplotlib.figure, matplotlib.figure): A tuple containing the two output plots.
+    """
+    # --- 1. Load Camera Fingerprint ---
+    print("Loading camera fingerprint...")
+    Fingerprint = np.genfromtxt(fingerprint_file.name)
+    print(f"Fingerprint loaded. Shape: {Fingerprint.shape}")
+
+    # --- 2. Save uploaded image to a temporary file ---
+    # The NoiseExtractFromImage function expects a file path, so we create one.
+    with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as temp_img_file:
+        temp_img_path = temp_img_file.name
+        imageio.imwrite(temp_img_path, input_image)
+
+    # --- 3. Extract and filter PRNU noise from the image ---
+    print("Extracting noise from image...")
+    Noisex = Ft.NoiseExtractFromImage(temp_img_path, sigma=2.)
+    Noisex = Fu.WienerInDFT(Noisex, np.std(Noisex))
+    print(f"Noise extracted. Shape: {Noisex.shape}")
+
+    # Clean up the temporary image file
+    os.remove(temp_img_path)
+
+    # --- 4. Align Fingerprint and PRNU sizes by padding if necessary ---
+    if Noisex.shape != Fingerprint.shape:
+        print("Shapes do not match. Padding PRNU noise to match fingerprint size.")
+        Noisex_padded = np.zeros_like(Fingerprint)
+        h = min(Noisex.shape[0], Fingerprint.shape[0])
+        w = min(Noisex.shape[1], Fingerprint.shape[1])
+        Noisex_padded[:h, :w] = Noisex[:h, :w]
+        Noisex = Noisex_padded
+    
+    # --- 5. Compute PCE Map in blocks ---
+    print("Computing PCE map...")
+    block_size = 64
+    blocks_x = np.arange(0, Noisex.shape[0], block_size)
+    blocks_y = np.arange(0, Noisex.shape[1], block_size)
+    PCE_map = np.zeros((len(blocks_x), len(blocks_y)))
+
+    for y_idx, y_start in enumerate(blocks_y):
+        for x_idx, x_start in enumerate(blocks_x):
+            block_Noisex = Noisex[x_start:x_start+block_size, y_start:y_start+block_size]
+            block_Fingerprint = Fingerprint[x_start:x_start+block_size, y_start:y_start+block_size]
+            
+            # Skip if blocks are not of the expected size (can happen at edges)
+            if block_Noisex.shape != (block_size, block_size):
+                continue
+
+            C = Fu.crosscorr(block_Noisex, block_Fingerprint)
+            det, _ = md.PCE(C)
+            PCE_map[x_idx, y_idx] = det.get('PCE', 0) # Use .get for safety
+
+    print("PCE map computed successfully.")
+
+    # --- 6. Generate Output Plots ---
+    # Plot 1: PCE Map
+    fig1, ax1 = plt.subplots(figsize=(8, 6))
+    im = ax1.imshow(PCE_map, cmap='viridis')
+    ax1.set_title('Detection PCE-map')
+    fig1.colorbar(im, ax=ax1, label='PCE Value')
+    
+    # Plot 2: Original Image
+    fig2, ax2 = plt.subplots(figsize=(8, 6))
+    ax2.imshow(input_image)
+    ax2.set_title('Analyzed Image')
+    ax2.axis('off')
+
+    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()

README.md

@@ -4,7 +4,7 @@ emoji: 🕵️‍♂️
 colorFrom: blue
 colorTo: indigo
 sdk: gradio
-sdk_version: "4.32.4"
+sdk_version: "4.0.0"
 app_file: app.py
 pinned: false
 ---

app.py

@@ -1,31 +1,205 @@
+import gradio as gr
+import numpy as np
+from PIL import Image
+import tempfile
 import os
-os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
 
-import gradio as gr
+# Import all the tool modules
+from CFA import analyze_region, on_upload_image as cfa_upload, move_selection_box as cfa_move_box
+from JPEG_Ghost import run_analysis, on_upload_image as jpeg_upload, move_selection_box as jpeg_move_box
+from PRNU import analyze_image_forgery
+from shadows import build_gradio_interface
+
+# Configuration
+BOX_SIZE_CFA = 128
+BOX_SIZE_JPEG = 256
+
+# Store state for each tool
+class ToolState:
+    def __init__(self):
+        self.cfa_original_image = None
+        self.cfa_box_coords = (0, 0)
+        self.jpeg_original_image = None  
+        self.jpeg_box_coords = (0, 0)
+
+state = ToolState()
+
+# CFA Analysis Functions
+def cfa_interface():
+    with gr.Blocks() as interface:
+        gr.Markdown("# 🎨 Color Filter Array Analysis")
+        gr.Markdown("Analyzes artifacts introduced during the camera's raw image processing to detect spliced or copy-pasted regions.")
+        
+        with gr.Row():
+            cfa_image_display = gr.Image(type="numpy", label="Upload Image & Click to Select 128x128 Region")
+            cfa_output_plot = gr.Plot(label="Analysis Results")
+
+        cfa_analyze_button = gr.Button("Analyze Region", variant="primary")
+        
+        # Event handlers for CFA
+        def on_cfa_upload(image):
+            result = cfa_upload(image)
+            state.cfa_original_image = result[1]
+            state.cfa_box_coords = result[2]
+            return result[0]
+            
+        def on_cfa_click(evt: gr.SelectData):
+            if state.cfa_original_image is not None:
+                result = cfa_move_box(state.cfa_original_image, evt)
+                state.cfa_box_coords = result[1]
+                return result[0]
+            return state.cfa_original_image
+            
+        def on_cfa_analyze():
+            if state.cfa_original_image is not None:
+                return analyze_region(state.cfa_original_image, state.cfa_box_coords)
+            return None
+
+        cfa_image_display.upload(on_cfa_upload, inputs=[cfa_image_display], outputs=[cfa_image_display])
+        cfa_image_display.select(on_cfa_click, inputs=[], outputs=[cfa_image_display])
+        cfa_analyze_button.click(on_cfa_analyze, inputs=[], outputs=[cfa_output_plot])
+        
+    return interface
+
+# JPEG Ghost Analysis Functions  
+def jpeg_interface():
+    with gr.Blocks() as interface:
+        gr.Markdown("# 👻 JPEG Ghost Detection")
+        gr.Markdown("Detects forgeries by identifying regions with different JPEG compression levels using recompression analysis.")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                jpeg_image_display = gr.Image(type="numpy", label="Upload Image & Click to Select 256x256 Region")
+                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")
+                jpeg_analyze_button = gr.Button("Analyze Image", variant="primary")
+
+            with gr.Column(scale=2):
+                jpeg_composite_display = gr.Image(type="numpy", label="Generated Composite Image")
+                jpeg_difference_plot = gr.Plot(label="Difference Maps")
+        
+        # Event handlers for JPEG Ghost
+        def on_jpeg_upload(image):
+            result = jpeg_upload(image)
+            state.jpeg_original_image = result[1]
+            state.jpeg_box_coords = result[2]
+            return result[0]
+            
+        def on_jpeg_click(evt: gr.SelectData):
+            if state.jpeg_original_image is not None:
+                result = jpeg_move_box(state.jpeg_original_image, evt)
+                state.jpeg_box_coords = result[1]
+                return result[0]
+            return state.jpeg_original_image
+            
+        def on_jpeg_analyze(qf1, qf2, qf_start, qf_end):
+            if state.jpeg_original_image is not None:
+                result = run_analysis(state.jpeg_original_image, state.jpeg_box_coords, qf1, qf2, qf_start, qf_end)
+                return result
+            return None, None
+
+        jpeg_image_display.upload(on_jpeg_upload, inputs=[jpeg_image_display], outputs=[jpeg_image_display])
+        jpeg_image_display.select(on_jpeg_click, inputs=[], outputs=[jpeg_image_display])
+        jpeg_analyze_button.click(
+            on_jpeg_analyze, 
+            inputs=[qf1_slider, qf2_slider, qf_start_slider, qf_end_slider],
+            outputs=[jpeg_composite_display, jpeg_difference_plot]
+        )
+        
+    return interface
+
+# PRNU Analysis Functions
+def prnu_interface():
+    with gr.Blocks() as interface:
+        gr.Markdown("# 📸 PRNU-Based Image Forgery Detector")
+        gr.Markdown("""
+        Uses Photo-Response Non-Uniformity (PRNU) pattern to detect tampered regions.
+        **Requirements:** You need a camera fingerprint file (.dat format) for analysis.
+        """)
+        
+        with gr.Row():
+            prnu_fingerprint = gr.File(label="Upload Camera Fingerprint (.dat file)")
+            prnu_image = gr.Image(type="numpy", label="Upload Image to Analyze")
+            
+        prnu_analyze_button = gr.Button("Analyze Image", variant="primary")
+        
+        with gr.Row():
+            prnu_pce_plot = gr.Plot(label="PCE Map")
+            prnu_image_plot = gr.Plot(label="Analyzed Image")
+        
+        def on_prnu_analyze(fingerprint, image):
+            if fingerprint is None:
+                raise gr.Error("Please upload a camera fingerprint file!")
+            if image is None:
+                raise gr.Error("Please upload an image to analyze!")
+            return analyze_image_forgery(fingerprint, image)
+            
+        prnu_analyze_button.click(
+            on_prnu_analyze,
+            inputs=[prnu_fingerprint, prnu_image],
+            outputs=[prnu_pce_plot, prnu_image_plot]
+        )
+        
+    return interface
+
+# Shadow Analysis Functions
+def shadow_interface():
+    return build_gradio_interface()
+
+# Main App
+with gr.Blocks(theme=gr.themes.Soft(), title="Digital Image Forensics Toolkit") as demo:
+    gr.Markdown("""
+    # 🕵️‍♂️ Digital Image Forensics Toolkit
+    
+    This toolkit provides multiple forensic algorithms to detect image manipulations and forgeries.
+    Select a tool from the dropdown below to begin analysis.
+    """)
+    
+    with gr.Row():
+        tool_selector = gr.Dropdown(
+            choices=[
+                "🎨 Color Filter Array (CFA) Analysis",
+                "👻 JPEG Ghost Detection", 
+                "📸 PRNU Analysis",
+                "☀️ Shadow Consistency Analysis"
+            ],
+            label="Select Forensic Tool",
+            value="🎨 Color Filter Array (CFA) Analysis"
+        )
+    
+    tool_output = gr.Tabs()
+    
+    # Create all interfaces but only show the selected one
+    with tool_output:
+        with gr.TabItem("CFA Analysis") as cfa_tab:
+            cfa_interface()
+        with gr.TabItem("JPEG Ghost") as jpeg_tab:
+            jpeg_interface()  
+        with gr.TabItem("PRNU Analysis") as prnu_tab:
+            prnu_interface()
+        with gr.TabItem("Shadow Analysis") as shadow_tab:
+            shadow_interface()
+    
+    # Map tool selection to tabs
+    tool_map = {
+        "🎨 Color Filter Array (CFA) Analysis": 0,
+        "👻 JPEG Ghost Detection": 1,
+        "📸 PRNU Analysis": 2, 
+        "☀️ Shadow Consistency Analysis": 3
+    }
+    
+    def select_tool(tool_name):
+        return gr.Tabs(selected=tool_map.get(tool_name, 0))
+    
+    tool_selector.change(
+        select_tool,
+        inputs=[tool_selector],
+        outputs=[tool_output]
+    )
 
-# 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.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", 
-        "📸 PRNU Analysis",
-        "☀️ Shadow Analysis"
-    ],
-    title="Digital Image Forensics Toolkit 🕵️‍♂️"
-)
-
-# Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(share=True)

requirements.txt

@@ -1,53 +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
-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.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
-imageio==2.35.1
+gradio>=4.0.0
+numpy
+pillow
+matplotlib
+scipy
+imageio
+opencv-python
+PyWavelets
+scikit-image

shadows.py

@@ -0,0 +1,353 @@
+"""
+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()