upload

app.py

@@ -1,205 +1,36 @@
-import gradio as gr
-import numpy as np
-from PIL import Image
-import tempfile
 import os
+os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
+os.environ["GRADIO_IS_E2E_TEST"] = "True"
 
-# 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
+# Fix for the JSON schema issue
+import warnings
+warnings.filterwarnings("ignore", category=DeprecationWarning)
 
-# 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 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
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch()