Update app.py

app.py

@@ -68,143 +68,6 @@ def prepare_image_for_forgery(image):
     ela_image = convert_to_ela_image(image, 90).resize((128, 128))
     return np.array(ela_image).flatten() / 255.0
 
-# Advanced Analysis Functions
-def detect_copy_move_forgery_advanced(image):
-    """Advanced copy-move forgery detection using multiple techniques"""
-    # Convert to grayscale
-    gray = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2GRAY)
-    
-    # Parameters
-    block_size = 16
-    overlap_threshold = 8
-    correlation_threshold = 0.85
-    min_distance = 32  # Minimum distance between blocks to avoid self-matching
-    
-    h, w = gray.shape
-    matches = []
-    
-    # Extract overlapping blocks with their descriptors
-    blocks = []
-    positions = []
-    
-    for i in range(0, h - block_size, overlap_threshold):
-        for j in range(0, w - block_size, overlap_threshold):
-            block = gray[i:i+block_size, j:j+block_size]
-            
-            # Multiple feature descriptors for better matching
-            # 1. Raw block data
-            block_flat = block.flatten()
-            
-            # 2. DCT coefficients (frequency domain)
-            dct_block = cv2.dct(np.float32(block))
-            dct_flat = dct_block.flatten()
-            
-            # 3. LBP (Local Binary Pattern) for texture
-            lbp = feature.local_binary_pattern(block, 8, 1, method='uniform')
-            lbp_hist, _ = np.histogram(lbp.ravel(), bins=10, range=(0, 10))
-            
-            # Combine features
-            descriptor = np.concatenate([
-                block_flat / 255.0,  # Normalized pixel values
-                dct_flat / np.max(np.abs(dct_flat)) if np.max(np.abs(dct_flat)) > 0 else dct_flat,  # Normalized DCT
-                lbp_hist / np.sum(lbp_hist) if np.sum(lbp_hist) > 0 else lbp_hist  # LBP histogram
-            ])
-            
-            blocks.append(descriptor)
-            positions.append((j + block_size//2, i + block_size//2))
-    
-    # Advanced matching using multiple similarity metrics
-    for idx1, (block1, pos1) in enumerate(zip(blocks, positions)):
-        for idx2, (block2, pos2) in enumerate(zip(blocks[idx1+1:], positions[idx1+1:]), idx1+1):
-            # Skip if blocks are too close (likely same region)
-            distance = np.sqrt((pos1[0] - pos2[0])**2 + (pos1[1] - pos2[1])**2)
-            if distance < min_distance:
-                continue
-            
-            # Multiple similarity measures
-            # 1. Normalized Cross Correlation
-            correlation = np.corrcoef(block1[:block_size*block_size], block2[:block_size*block_size])[0, 1]
-            
-            # 2. Structural Similarity (simplified)
-            ssim = 1 - np.mean((block1 - block2)**2) / (np.var(block1) + np.var(block2) + 1e-10)
-            
-            # 3. Cosine similarity
-            cosine_sim = np.dot(block1, block2) / (np.linalg.norm(block1) * np.linalg.norm(block2) + 1e-10)
-            
-            # Combined similarity score
-            combined_score = (correlation + ssim + cosine_sim) / 3
-            
-            if combined_score > correlation_threshold and not np.isnan(combined_score):
-                matches.append((pos1, pos2, combined_score))
-    
-    # Post-processing: Remove duplicate matches and cluster nearby matches
-    filtered_matches = []
-    for match in sorted(matches, key=lambda x: x[2], reverse=True):
-        pos1, pos2, score = match
-        
-        # Check if this match is too similar to existing ones
-        is_duplicate = False
-        for existing_match in filtered_matches:
-            existing_pos1, existing_pos2, _ = existing_match
-            if (abs(pos1[0] - existing_pos1[0]) < 20 and abs(pos1[1] - existing_pos1[1]) < 20 and
-                abs(pos2[0] - existing_pos2[0]) < 20 and abs(pos2[1] - existing_pos2[1]) < 20):
-                is_duplicate = True
-                break
-        
-        if not is_duplicate:
-            filtered_matches.append(match)
-            if len(filtered_matches) >= 20:  # Limit to top 20 matches
-                break
-    
-    return filtered_matches
-
-def detect_splicing_regions(image):
-    """Detect potential splicing/tampering regions using edge inconsistencies"""
-    # Convert to grayscale
-    gray = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2GRAY)
-    
-    # Apply different edge detection methods
-    edges_canny = cv2.Canny(gray, 50, 150)
-    edges_sobel = cv2.Sobel(gray, cv2.CV_64F, 1, 1, ksize=3)
-    edges_sobel = np.uint8(np.absolute(edges_sobel))
-    
-    # Find inconsistent regions
-    diff = cv2.absdiff(edges_canny, edges_sobel)
-    
-    # Threshold and find contours
-    _, thresh = cv2.threshold(diff, 30, 255, cv2.THRESH_BINARY)
-    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    
-    # Filter contours by area
-    suspicious_regions = []
-    for contour in contours:
-        area = cv2.contourArea(contour)
-        if area > 100:  # Minimum area threshold
-            x, y, w, h = cv2.boundingRect(contour)
-            suspicious_regions.append((x, y, w, h))
-    
-    return suspicious_regions
-
-def analyze_noise_patterns(image):
-    """Analyze noise patterns to detect inconsistencies"""
-    # Convert to grayscale
-    gray = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2GRAY)
-    
-    # Apply Gaussian blur and subtract to get noise
-    blurred = cv2.GaussianBlur(gray, (3, 3), 0)
-    noise = cv2.absdiff(gray, blurred)
-    
-    # Divide image into blocks and calculate noise variance
-    block_size = 32
-    h, w = gray.shape
-    noise_map = np.zeros((h//block_size, w//block_size))
-    
-    for i in range(0, h - block_size, block_size):
-        for j in range(0, w - block_size, block_size):
-            block = noise[i:i+block_size, j:j+block_size]
-            noise_map[i//block_size, j//block_size] = np.var(block)
-    
-    return noise_map, noise
 
 # Individual Analysis Functions
 def create_ela_analysis(image):
@@ -232,132 +95,6 @@ def create_ela_analysis(image):
     
     return buffer
 
-def create_copy_move_analysis(image):
-    """Create copy-move detection visualization"""
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))
-    fig.suptitle('Advanced Copy-Move Forgery Detection', fontsize=14, fontweight='bold')
-    
-    # Original image
-    ax1.imshow(image)
-    ax1.set_title('Original Image')
-    ax1.axis('off')
-    
-    # Copy-move detection
-    copy_move_matches = detect_copy_move_forgery_advanced(image)
-    ax2.imshow(image)
-    ax2.set_title(f'Copy-Move Detection ({len(copy_move_matches)} matches found)')
-    
-    # Draw copy-move connections with confidence scores
-    colors = plt.cm.RdYlGn(np.linspace(0.3, 1, len(copy_move_matches)))
-    
-    for i, (match, color) in enumerate(zip(copy_move_matches, colors)):
-        if len(match) == 3:  # Advanced version with score
-            point1, point2, score = match
-            # Red dot for source
-            ax2.plot(point1[0], point1[1], 'o', color='red', markersize=5)
-            # Green dot for destination  
-            ax2.plot(point2[0], point2[1], 'o', color='lime', markersize=5)
-            # Line with color based on confidence
-            ax2.plot([point1[0], point2[0]], [point1[1], point2[1]], 
-                    color=color, linewidth=2, alpha=0.8)
-            # Add confidence score as text
-            mid_x, mid_y = (point1[0] + point2[0]) / 2, (point1[1] + point2[1]) / 2
-            ax2.text(mid_x, mid_y, f'{score:.2f}', fontsize=8, 
-                    bbox=dict(boxstyle="round,pad=0.1", facecolor='white', alpha=0.7))
-        else:  # Simple version
-            point1, point2 = match
-            ax2.plot(point1[0], point1[1], 'ro', markersize=4)
-            ax2.plot(point2[0], point2[1], 'go', markersize=4)
-            ax2.plot([point1[0], point2[0]], [point1[1], point2[1]], 'g-', linewidth=1, alpha=0.7)
-    
-    ax2.axis('off')
-    
-    plt.tight_layout()
-    
-    buffer = io.BytesIO()
-    plt.savefig(buffer, format='png', dpi=150, bbox_inches='tight')
-    buffer.seek(0)
-    plt.close()
-    
-    return buffer
-
-def create_tampering_analysis(image):
-    """Create tampering/splicing detection visualization"""
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))
-    fig.suptitle('Tampering/Splicing Detection', fontsize=14, fontweight='bold')
-    
-    # Original image
-    ax1.imshow(image)
-    ax1.set_title('Original Image')
-    ax1.axis('off')
-    
-    # Tampering detection
-    suspicious_regions = detect_splicing_regions(image)
-    ax2.imshow(image)
-    ax2.set_title(f'Suspicious Regions ({len(suspicious_regions)} found)')
-    
-    # Highlight suspicious regions with different colors
-    colors = ['red', 'orange', 'yellow', 'purple', 'pink']
-    for i, region in enumerate(suspicious_regions):
-        x, y, w, h = region
-        color = colors[i % len(colors)]
-        rect = patches.Rectangle((x, y), w, h, linewidth=2, 
-                               edgecolor=color, facecolor='none', alpha=0.8)
-        ax2.add_patch(rect)
-        # Add region number
-        ax2.text(x, y-5, f'R{i+1}', fontsize=10, color=color, fontweight='bold')
-    
-    ax2.axis('off')
-    
-    plt.tight_layout()
-    
-    buffer = io.BytesIO()
-    plt.savefig(buffer, format='png', dpi=150, bbox_inches='tight')
-    buffer.seek(0)
-    plt.close()
-    
-    return buffer
-
-def create_noise_analysis(image):
-    """Create noise pattern analysis visualization"""
-    fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 10))
-    fig.suptitle('Noise Pattern Analysis', fontsize=14, fontweight='bold')
-    
-    # Original image
-    ax1.imshow(image)
-    ax1.set_title('Original Image')
-    ax1.axis('off')
-    
-    # Noise analysis
-    noise_map, noise = analyze_noise_patterns(image)
-    
-    # Noise map
-    im1 = ax2.imshow(noise_map, cmap='hot', interpolation='nearest')
-    ax2.set_title('Noise Variance Map')
-    ax2.axis('off')
-    plt.colorbar(im1, ax=ax2, shrink=0.8)
-    
-    # Raw noise
-    ax3.imshow(noise, cmap='gray')
-    ax3.set_title('Extracted Noise')
-    ax3.axis('off')
-    
-    # Noise histogram
-    ax4.hist(noise.flatten(), bins=50, alpha=0.7, color='blue')
-    ax4.set_title('Noise Distribution')
-    ax4.set_xlabel('Noise Level')
-    ax4.set_ylabel('Frequency')
-    ax4.grid(True, alpha=0.3)
-    
-    plt.tight_layout()
-    
-    buffer = io.BytesIO()
-    plt.savefig(buffer, format='png', dpi=150, bbox_inches='tight')
-    buffer.seek(0)
-    plt.close()
-    
-    return buffer
-
 
 # Deepfake Image Detection
 def predict_deepfake_image(image_path, model):
@@ -614,103 +351,42 @@ if task == "Image Forgery Detection":
         else:
             st.error(f"Result: Forged Image with {confidence_fake:.2f}% confidence")
         
-        # Add analysis options
+        # Add ELA analysis option
         st.markdown("---")
-        st.subheader("🔍 Detailed Forgery Analysis")
-        
-        # Analysis type selection
-        analysis_type = st.selectbox(
-            "Choose Analysis Type:",
-            ["Error Level Analysis (ELA)", "Copy-Move Detection", "Tampering Detection", "Noise Analysis"],
-            index=0
-        )
+        st.subheader("🔍 Additional Analysis")
         
-        col1, col2 = st.columns([1, 3])
+        # Show ELA option checkbox
+        show_ela = st.checkbox("View Error Level Analysis (ELA)", value=False)
         
-        with col1:
-            analyze_button = st.button("Run Analysis", type="primary", use_container_width=True)
-        
-        with col2:
-            st.markdown("### Analysis Guide:")
-            if analysis_type == "Error Level Analysis (ELA)":
-                st.info("**ELA**: Reveals compression artifacts. Bright areas indicate potential editing or manipulation.")
-            elif analysis_type == "Copy-Move Detection":
-                st.info("**Copy-Move**: Finds duplicated regions. Red dots show source, green dots show destination, lines show confidence.")
-            elif analysis_type == "Tampering Detection":
-                st.info("**Tampering**: Detects edge inconsistencies. Colored rectangles highlight suspicious regions.")
-            elif analysis_type == "Noise Analysis":
-                st.info("**Noise**: Analyzes noise patterns. Hot spots in variance map indicate inconsistent noise.")
-        
-        if analyze_button:
-            with st.spinner(f"Running {analysis_type}..."):
-                try:
-                    if analysis_type == "Error Level Analysis (ELA)":
+        if show_ela:
+            st.markdown("### Error Level Analysis")
+            st.info("**ELA**: Reveals compression artifacts. Bright areas indicate potential editing or manipulation.")
+            
+            col1, col2 = st.columns([1, 3])
+            
+            with col1:
+                analyze_button = st.button("Run ELA Analysis", type="primary", use_container_width=True)
+            
+            if analyze_button:
+                with st.spinner("Running Error Level Analysis..."):
+                    try:
                         analysis_buffer = create_ela_analysis(image)
-                        filename = "ela_analysis.png"
                         
-                    elif analysis_type == "Copy-Move Detection":
-                        analysis_buffer = create_copy_move_analysis(image)
-                        filename = "copy_move_analysis.png"
+                        # Fixed size for analysis results
+                        st.image(analysis_buffer, caption="ELA Analysis Results", width=500)
                         
-                    elif analysis_type == "Tampering Detection":
-                        analysis_buffer = create_tampering_analysis(image)
-                        filename = "tampering_analysis.png"
+                        # Download button
+                        st.download_button(
+                            label="Download ELA Results",
+                            data=analysis_buffer.getvalue(),
+                            file_name="ela_analysis.png",
+                            mime="image/png",
+                            use_container_width=True
+                        )
                         
-                    elif analysis_type == "Noise Analysis":
-                        analysis_buffer = create_noise_analysis(image)
-                        filename = "noise_analysis.png"
-                    
-                    # Fixed size for analysis results
-                    st.image(analysis_buffer, caption=f"{analysis_type} Results", width=500)
-                    
-                    # Detailed results based on analysis type
-                    if analysis_type == "Copy-Move Detection":
-                        matches = detect_copy_move_forgery_advanced(image)
-                        if matches:
-                            st.success(f"Found {len(matches)} potential copy-move regions")
-                            with st.expander("Detailed Match Information"):
-                                for i, match in enumerate(matches[:5]):  # Show top 5
-                                    if len(match) == 3:
-                                        pos1, pos2, score = match
-                                        st.write(f"**Match {i+1}**: Confidence {score:.3f}")
-                                        st.write(f"  Source: ({pos1[0]}, {pos1[1]}) → Destination: ({pos2[0]}, {pos2[1]})")
-                        else:
-                            st.success("No copy-move forgery detected")
-                    
-                    elif analysis_type == "Tampering Detection":
-                        regions = detect_splicing_regions(image)
-                        if regions:
-                            st.warning(f"Found {len(regions)} suspicious regions")
-                            with st.expander("Region Details"):
-                                for i, (x, y, w, h) in enumerate(regions):
-                                    st.write(f"**Region {i+1}**: Position ({x}, {y}), Size {w}×{h}")
-                        else:
-                            st.success("No suspicious tampering regions detected")
-                    
-                    elif analysis_type == "Noise Analysis":
-                        noise_map, _ = analyze_noise_patterns(image)
-                        avg_noise = np.mean(noise_map)
-                        std_noise = np.std(noise_map)
-                        st.info(f"Average noise variance: {avg_noise:.3f}")
-                        st.info(f"Noise variance std: {std_noise:.3f}")
-                        if std_noise > avg_noise * 0.5:
-                            st.warning("High noise variance detected - possible inconsistent editing")
-                        else:
-                            st.success("Noise patterns appear consistent")
-                    
-                    # Download button
-                    st.download_button(
-                        label=f"Download {analysis_type} Results",
-                        data=analysis_buffer.getvalue(),
-                        file_name=filename,
-                        mime="image/png",
-                        use_container_width=True
-                    )
-                    
-                except Exception as e:
-                    st.error(f"Error during {analysis_type}: {str(e)}")
-                    st.info("Some analysis methods may not work with all image types. Try with a different image if needed.")
-
+                    except Exception as e:
+                        st.error(f"Error during ELA analysis: {str(e)}")
+                        st.info("ELA analysis may not work with all image types. Try with a different image if needed.")
                     
 elif task == "Deepfake Image Detection":
     uploaded_file = st.file_uploader("Upload an image", type=['jpg', 'jpeg', 'png'])