Update app.py

app.py

@@ -1,144 +1,160 @@
-import streamlit as st
+import gradio as gr
+import requests
+import json
 import io
 import base64
 from PIL import Image
-import tempfile
-import os
-import json
-
-# Import functions from your backend file
-from backend import (
-    detect_clones,
-    error_level_analysis,
-    extract_exif_metadata,
-    noise_analysis,
-    manipulation_likelihood,
-    get_clone_explanation,
-    pil_to_base64
-)
 
-# Create temp directory
-TEMP_DIR = tempfile.mkdtemp()
+# FastAPI backend URL
+API_URL = "http://localhost:8000"
 
-# Helper functions
-def save_uploaded_image(uploaded_file):
-    """Save a Streamlit uploaded file and return the path"""
-    temp_path = os.path.join(TEMP_DIR, "temp_analyze.jpg")
-    with open(temp_path, "wb") as f:
-        f.write(uploaded_file.getbuffer())
-    return temp_path
+#############################
+# HELPER FUNCTIONS
+#############################
 
-# Streamlit UI
-st.set_page_config(page_title="Image Forensic & Fraud Detection Tool", layout="wide")
+def base64_to_pil(base64_str):
+    """Convert base64 string to PIL image"""
+    img_data = base64.b64decode(base64_str)
+    return Image.open(io.BytesIO(img_data))
 
-st.title("Image Forensic & Fraud Detection Tool")
-st.write("Upload an image to analyze it for potential manipulation using various forensic techniques.")
-
-# Sidebar for uploading and basic controls
-with st.sidebar:
-    uploaded_file = st.file_uploader("Upload Image", type=["jpg", "jpeg", "png"])
+def upload_image(image, endpoint):
+    """Upload an image to the specified API endpoint"""
+    # Save image to bytes
+    img_byte_arr = io.BytesIO()
+    image.save(img_byte_arr, format='JPEG')
+    img_byte_arr = img_byte_arr.getvalue()
     
-    if uploaded_file is not None:
-        analyze_button = st.button("Analyze Image", type="primary")
+    # Send to API
+    files = {'file': ('image.jpg', img_byte_arr, 'image/jpeg')}
+    response = requests.post(f"{API_URL}{endpoint}", files=files)
     
-    # Display probability meter if analysis has been done
-    if "probability" in st.session_state:
-        st.markdown("### Manipulation Probability")
-        st.progress(st.session_state.probability)
-        st.write(f"{st.session_state.probability*100:.1f}%")
+    # Return the JSON response
+    return response.json()
 
-# Main content area with tabs
-if uploaded_file is not None:
-    # Display the original image
-    image = Image.open(uploaded_file)
-    
-    # Create tabs for different analyses
-    tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs([
-        "Analysis Results", 
-        "Original Image", 
-        "Error Level Analysis", 
-        "Noise Analysis",
-        "Clone Detection",
-        "AI Detection Heatmap"
-    ])
-    
-    with tab2:
-        st.image(image, caption="Original Image")
-    
-    # Run analysis when button is clicked
-    if analyze_button:
-        # Save the image
-        temp_path = save_uploaded_image(uploaded_file)
-        
-        with st.spinner("Analyzing image..."):
-            try:
-                # Run all analyses
-                exif_result = extract_exif_metadata(temp_path)
-                manipulation_result = manipulation_likelihood(temp_path)
-                clone_result, clone_count = detect_clones(temp_path)
-                ela_image = error_level_analysis(temp_path)
-                noise_image = noise_analysis(temp_path)
-                
-                # Store probability in session state
-                st.session_state.probability = manipulation_result["probability"]
-                
-                # Display results in each tab
-                with tab1:
-                    st.markdown(f"""
-                    ## Manipulation Analysis Results
+#############################
+# API INTERFACE FUNCTIONS
+#############################
 
-                    **Overall Assessment: {manipulation_result['probability']*100:.1f}% likelihood of manipulation**
+def analyze_image(image):
+    """Main function that sends the image to the API for analysis"""
+    if image is None:
+        return {
+            original_image: None,
+            ela_image: None,
+            noise_image: None,
+            heatmap_image: None,
+            clone_image: None,
+            exif_data: "{}",
+            analysis_results: "Please upload an image first.",
+            probability_slider: 0
+        }
+        
+    # Send to API for full analysis
+    try:
+        response = upload_image(image, "/api/analyze_image")
+        
+        # Process results
+        return {
+            original_image: image,
+            ela_image: base64_to_pil(response["ela_image"]),
+            noise_image: base64_to_pil(response["noise_image"]),
+            heatmap_image: base64_to_pil(response["heatmap_image"]),
+            clone_image: base64_to_pil(response["clone_image"]),
+            exif_data: json.dumps(response["exif_data"], indent=2),
+            analysis_results: response["analysis_text"],
+            probability_slider: response["manipulation_probability"]
+        }
+    except Exception as e:
+        return {
+            original_image: image,
+            ela_image: None,
+            noise_image: None,
+            heatmap_image: None,
+            clone_image: None,
+            exif_data: f"Error: {str(e)}",
+            analysis_results: f"Error occurred during analysis: {str(e)}",
+            probability_slider: 0
+        }
 
-                    {manipulation_result['explanation']}
 
-                    ### Clone Detection Analysis:
-                    Found {clone_count} potential cloned regions in the image.
-                    {get_clone_explanation(clone_count)}
+#############################
+# GRADIO INTERFACE
+#############################
 
-                    ### EXIF Metadata Analysis:
-                    {exif_result['summary']}
+with gr.Blocks(title="Image Forensic & Fraud Detection Tool - MVP Demo") as demo:
+    gr.Markdown("""
+    # Image Forensic & Fraud Detection Tool
 
-                    Indicators found: {len(exif_result['indicators'])}
-                    """)
-                    
-                    if exif_result['indicators']:
-                        st.markdown("### Detailed indicators:")
-                        for indicator in exif_result['indicators']:
-                            st.markdown(f"- {indicator}")
-                    
-                    # Display EXIF data as expandable JSON
-                    with st.expander("View EXIF Metadata"):
-                        st.json(exif_result["metadata"])
+    
+    Upload an image to analyze it for potential manipulation using various forensic techniques.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_image = gr.Image(type="pil", label="Upload Image for Analysis")
+            analyze_button = gr.Button("Analyze Image", variant="primary")
+            
+            gr.Markdown("### Manipulation Probability")
+            probability_slider = gr.Slider(
+                minimum=0, maximum=1, value=0, 
+                label="Manipulation Probability", 
+                interactive=False
+            )
+            
+            gr.Markdown("### EXIF Metadata")
+            exif_data = gr.Code(language="json", label="EXIF Data", lines=10)
+            
+        with gr.Column(scale=2):
+            with gr.Tab("Analysis Results"):
+                analysis_results = gr.Markdown()
                 
-                with tab3:
-                    st.markdown("""
-                    Error Level Analysis reveals differences in compression levels. Areas with different compression levels 
-                    often indicate modifications. Brighter regions in the visualization suggest potential manipulations.
-                    """)
-                    st.image(ela_image, caption="Error Level Analysis Result")
+            with gr.Tab("Original Image"):
+                original_image = gr.Image(type="pil", label="Original Image")
                 
-                with tab4:
-                    st.markdown("""
-                    Noise Analysis examines the noise patterns in the image. Inconsistent noise patterns often indicate 
-                    areas that have been manipulated or added from different sources.
-                    """)
-                    st.image(noise_image, caption="Noise Pattern Analysis")
+            with gr.Tab("Error Level Analysis (ELA)"):
+                gr.Markdown("""
+                Error Level Analysis reveals differences in compression levels. Areas with different compression levels 
+                often indicate modifications. Brighter regions in the visualization suggest potential manipulations.
+                """)
+                ela_image = gr.Image(type="pil", label="ELA Result")
                 
-                with tab5:
-                    st.markdown("""
-                    Clone Detection identifies duplicated areas within the image. Red and blue rectangles highlight 
-                    matching regions that may indicate copy-paste manipulation.
-                    """)
-                    st.image(clone_result, caption="Clone Detection Result")
+            with gr.Tab("Noise Analysis"):
+                gr.Markdown("""
+                Noise Analysis examines the noise patterns in the image. Inconsistent noise patterns often indicate 
+                areas that have been manipulated or added from different sources.
+                """)
+                noise_image = gr.Image(type="pil", label="Noise Pattern Analysis")
                 
-                with tab6:
-                    st.markdown("""
-                    This heatmap highlights regions identified by our AI model as potentially manipulated.
-                    Red areas indicate suspicious regions with a higher likelihood of manipulation.
-                    """)
-                    st.image(manipulation_result["heatmap_image"], caption="AI-Detected Suspicious Regions")
-            
-            except Exception as e:
-                st.error(f"Error during analysis: {str(e)}")
-else:
-    st.info("Please upload an image to begin analysis.")
+            with gr.Tab("Clone Detection"):
+                gr.Markdown("""
+                Clone Detection identifies duplicated areas within the image. Red and blue rectangles highlight 
+                matching regions that may indicate copy-paste manipulation.
+                """)
+                clone_image = gr.Image(type="pil", label="Clone Detection Result")
+                
+            with gr.Tab("AI Detection Heatmap"):
+                gr.Markdown("""
+                This heatmap highlights regions identified by our AI model as potentially manipulated.
+                Red areas indicate suspicious regions with a higher likelihood of manipulation.
+                """)
+                heatmap_image = gr.Image(type="pil", label="AI-Detected Suspicious Regions")
+    
+    # Set up event handlers
+    analyze_button.click(
+        fn=analyze_image,
+        inputs=[input_image],
+        outputs=[
+            original_image, 
+            ela_image, 
+            noise_image, 
+            heatmap_image, 
+            clone_image,
+            exif_data, 
+            analysis_results,
+            probability_slider
+        ]
+    )
+    
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()