new feature

app.py

@@ -432,6 +432,215 @@ def apply_grabcut(image, margin_percent, iterations):
     return labeled_img, foreground, info
 
 
+def apply_fourier_filter(image, filter_type, cutoff_freq):
+    """
+    Apply Fourier Transform filtering in frequency domain
+    
+    Fourier Transform decomposes image into frequency components.
+    Low frequencies = smooth regions, High frequencies = edges/details
+    """
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # Convert to grayscale for Fourier
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = image
+    
+    # Apply Fourier Transform
+    f = np.fft.fft2(gray)
+    fshift = np.fft.fftshift(f)  # Shift zero frequency to center
+    
+    # Get magnitude spectrum for visualization
+    magnitude_spectrum = 20 * np.log(np.abs(fshift) + 1)
+    
+    # Create filter mask
+    rows, cols = gray.shape
+    crow, ccol = rows // 2, cols // 2
+    
+    # Create coordinate matrices
+    y, x = np.ogrid[:rows, :cols]
+    distance = np.sqrt((x - ccol)**2 + (y - crow)**2)
+    
+    if filter_type == "Low-Pass (Blur)":
+        # Allow low frequencies, block high frequencies
+        mask = np.zeros((rows, cols), np.uint8)
+        mask[distance <= cutoff_freq] = 1
+        desc = "Removes high frequencies (edges/details), keeps smooth regions"
+        
+    elif filter_type == "High-Pass (Sharpen)":
+        # Block low frequencies, allow high frequencies
+        mask = np.ones((rows, cols), np.uint8)
+        mask[distance <= cutoff_freq] = 0
+        desc = "Removes low frequencies (smooth regions), keeps edges/details"
+        
+    elif filter_type == "Band-Pass":
+        # Allow middle frequencies
+        mask = np.zeros((rows, cols), np.uint8)
+        mask[(distance >= cutoff_freq/2) & (distance <= cutoff_freq)] = 1
+        desc = "Keeps only middle-range frequencies"
+        
+    elif filter_type == "Band-Stop (Notch)":
+        # Block middle frequencies
+        mask = np.ones((rows, cols), np.uint8)
+        mask[(distance >= cutoff_freq/2) & (distance <= cutoff_freq)] = 0
+        desc = "Removes middle-range frequencies, keeps very low and very high"
+    else:
+        mask = np.ones((rows, cols), np.uint8)
+        desc = "No filtering"
+    
+    # Apply mask
+    fshift_filtered = fshift * mask
+    
+    # Inverse Fourier Transform
+    f_ishift = np.fft.ifftshift(fshift_filtered)
+    img_back = np.fft.ifft2(f_ishift)
+    img_back = np.real(img_back)
+    
+    # Normalize to 0-255
+    img_back = np.clip(img_back, 0, 255).astype(np.uint8)
+    
+    # Convert back to RGB
+    result_rgb = cv2.cvtColor(img_back, cv2.COLOR_GRAY2RGB)
+    
+    # Create visualization of spectrum
+    magnitude_vis = np.clip(magnitude_spectrum, 0, 255).astype(np.uint8)
+    magnitude_rgb = cv2.cvtColor(magnitude_vis, cv2.COLOR_GRAY2RGB)
+    
+    info = f"""
+### Fourier Transform Filtering Applied
+- **Filter Type**: {filter_type}
+- **Cutoff Frequency**: {cutoff_freq} pixels
+- **Effect**: {desc}
+- **How it works**: Transforms to frequency domain, filters, transforms back
+- **Use Case**: Periodic noise removal, sharpening, custom filtering
+"""
+    
+    return result_rgb, magnitude_rgb, info
+
+
+def apply_gray_world(image, percentile):
+    """
+    Apply Gray-World color constancy algorithm
+    
+    Assumes the average color of the scene should be gray.
+    Adjusts color channels to achieve this, correcting color casts.
+    """
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    if len(image.shape) != 3:
+        return cv2.cvtColor(image, cv2.COLOR_GRAY2RGB), "Image must be in color for Gray-World"
+    
+    # Convert to float
+    img_float = image.astype(np.float32)
+    
+    # Calculate average or percentile of each channel
+    if percentile == 50:
+        # Standard Gray-World: use mean
+        avg_r = np.mean(img_float[:, :, 0])
+        avg_g = np.mean(img_float[:, :, 1])
+        avg_b = np.mean(img_float[:, :, 2])
+        method = "Mean"
+    else:
+        # Robust Gray-World: use percentile (less sensitive to outliers)
+        avg_r = np.percentile(img_float[:, :, 0], percentile)
+        avg_g = np.percentile(img_float[:, :, 1], percentile)
+        avg_b = np.percentile(img_float[:, :, 2], percentile)
+        method = f"{percentile}th Percentile"
+    
+    # Calculate gray value (average of all channels)
+    gray_value = (avg_r + avg_g + avg_b) / 3
+    
+    # Calculate scaling factors
+    scale_r = gray_value / (avg_r + 1e-6)
+    scale_g = gray_value / (avg_g + 1e-6)
+    scale_b = gray_value / (avg_b + 1e-6)
+    
+    # Apply scaling
+    result = img_float.copy()
+    result[:, :, 0] = np.clip(result[:, :, 0] * scale_r, 0, 255)
+    result[:, :, 1] = np.clip(result[:, :, 1] * scale_g, 0, 255)
+    result[:, :, 2] = np.clip(result[:, :, 2] * scale_b, 0, 255)
+    
+    result = result.astype(np.uint8)
+    
+    info = f"""
+### Gray-World Color Constancy Applied
+- **Method**: {method}
+- **Scaling Factors**: R={scale_r:.3f}, G={scale_g:.3f}, B={scale_b:.3f}
+- **Effect**: Removes color cast by balancing channel averages
+- **Assumption**: Average scene color should be neutral gray
+- **Use Case**: Correct lighting color casts (blue/yellow/green tints)
+
+**Original Averages**: R={avg_r:.1f}, G={avg_g:.1f}, B={avg_b:.1f}
+**Target Gray**: {gray_value:.1f}
+"""
+    
+    return result, info
+
+
+def apply_anisotropic_diffusion(image, iterations, kappa, gamma):
+    """
+    Apply Anisotropic Diffusion (Perona-Malik)
+    
+    Edge-preserving smoothing that reduces noise while maintaining edges.
+    Diffusion is stronger in smooth regions, weaker near edges.
+    """
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # Convert to grayscale
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = image
+    
+    # Convert to float
+    img = gray.astype(np.float32)
+    
+    # Perform anisotropic diffusion
+    for _ in range(iterations):
+        # Calculate gradients in 4 directions
+        gradN = np.roll(img, 1, axis=0) - img  # North
+        gradS = np.roll(img, -1, axis=0) - img  # South
+        gradE = np.roll(img, -1, axis=1) - img  # East
+        gradW = np.roll(img, 1, axis=1) - img  # West
+        
+        # Calculate diffusion coefficients (edge-stopping function)
+        # Option 1: Exponential (preserves wide regions)
+        cN = np.exp(-(gradN / kappa) ** 2)
+        cS = np.exp(-(gradS / kappa) ** 2)
+        cE = np.exp(-(gradE / kappa) ** 2)
+        cW = np.exp(-(gradW / kappa) ** 2)
+        
+        # Update image
+        img = img + gamma * (cN * gradN + cS * gradS + cE * gradE + cW * gradW)
+    
+    # Clip and convert back
+    result = np.clip(img, 0, 255).astype(np.uint8)
+    result_rgb = cv2.cvtColor(result, cv2.COLOR_GRAY2RGB)
+    
+    info = f"""
+### Anisotropic Diffusion Applied
+- **Iterations**: {iterations}
+- **Kappa (Edge threshold)**: {kappa}
+- **Gamma (Step size)**: {gamma}
+- **Algorithm**: Perona-Malik diffusion
+- **Effect**: Smooths noise while preserving edges
+- **How it works**: Diffusion is adaptive - strong in flat regions, weak at edges
+- **Use Case**: Medical imaging, noise reduction with edge preservation
+
+**Parameters Guide**:
+- Kappa: Controls what's considered an edge (10-50 typical)
+- Gamma: Controls diffusion speed (0.1-0.25 typical, must be ≤0.25 for stability)
+- Iterations: More = more smoothing (5-20 typical)
+"""
+    
+    return result_rgb, info
+
+
 def analyze_image_stats(image):
     """Provide detailed statistical analysis"""
     if isinstance(image, Image.Image):
@@ -700,6 +909,84 @@ with gr.Blocks(title="Image Preprocessing Analyzer", theme=gr.themes.Soft()) as
                 inputs=[input_image, grabcut_margin, grabcut_iter],
                 outputs=[grabcut_output, grabcut_foreground, grabcut_info]
             )
+        
+        # Fourier Transform Filtering Tab
+        with gr.TabItem("🌊 Fourier Transform Filtering"):
+            gr.Markdown("""
+            **Fourier Transform** decomposes images into frequency components.
+            Filter in frequency domain to remove periodic noise or enhance specific features.
+            """)
+            
+            with gr.Row():
+                fourier_type = gr.Radio(
+                    ["Low-Pass (Blur)", "High-Pass (Sharpen)", "Band-Pass", "Band-Stop (Notch)"],
+                    value="Low-Pass (Blur)",
+                    label="Filter Type"
+                )
+                fourier_cutoff = gr.Slider(10, 200, value=30, step=5, label="Cutoff Frequency (pixels)")
+            
+            fourier_btn = gr.Button("Apply Fourier Filter", variant="primary")
+            
+            with gr.Row():
+                fourier_output = gr.Image(label="Filtered Result")
+                fourier_spectrum = gr.Image(label="Frequency Spectrum")
+            
+            fourier_info = gr.Markdown()
+            
+            fourier_btn.click(
+                fn=apply_fourier_filter,
+                inputs=[input_image, fourier_type, fourier_cutoff],
+                outputs=[fourier_output, fourier_spectrum, fourier_info]
+            )
+        
+        # Gray-World Color Constancy Tab
+        with gr.TabItem("🎨 Color Constancy (Gray-World)"):
+            gr.Markdown("""
+            **Gray-World Algorithm** corrects color casts caused by lighting.
+            Assumes the average color of a scene should be neutral gray.
+            """)
+            
+            with gr.Row():
+                grayworld_percentile = gr.Slider(
+                    40, 60, value=50, step=5,
+                    label="Percentile (50=Mean, 40-45=Robust to highlights)"
+                )
+            
+            grayworld_btn = gr.Button("Apply Gray-World", variant="primary")
+            
+            with gr.Row():
+                grayworld_output = gr.Image(label="Color Corrected")
+                grayworld_info = gr.Markdown()
+            
+            grayworld_btn.click(
+                fn=apply_gray_world,
+                inputs=[input_image, grayworld_percentile],
+                outputs=[grayworld_output, grayworld_info]
+            )
+        
+        # Anisotropic Diffusion Tab
+        with gr.TabItem("🔬 Anisotropic Diffusion"):
+            gr.Markdown("""
+            **Anisotropic Diffusion** (Perona-Malik) performs edge-preserving smoothing.
+            Reduces noise while maintaining sharp edges - ideal for medical imaging.
+            """)
+            
+            with gr.Row():
+                aniso_iter = gr.Slider(1, 30, value=10, step=1, label="Iterations")
+                aniso_kappa = gr.Slider(5, 100, value=20, step=5, label="Kappa (Edge threshold)")
+                aniso_gamma = gr.Slider(0.05, 0.25, value=0.15, step=0.05, label="Gamma (Step size)")
+            
+            aniso_btn = gr.Button("Apply Anisotropic Diffusion", variant="primary")
+            
+            with gr.Row():
+                aniso_output = gr.Image(label="Smoothed Result")
+                aniso_info = gr.Markdown()
+            
+            aniso_btn.click(
+                fn=apply_anisotropic_diffusion,
+                inputs=[input_image, aniso_iter, aniso_kappa, aniso_gamma],
+                outputs=[aniso_output, aniso_info]
+            )
     
     # Documentation
     with gr.Accordion("📚 Filter Documentation", open=False):
@@ -759,6 +1046,30 @@ with gr.Blocks(title="Image Preprocessing Analyzer", theme=gr.themes.Soft()) as
         - **Use Case**: Product photography, portrait background removal, object isolation
         - **Algorithm**: Iteratively learns color distributions of foreground/background
         - **Output**: Binary mask and extracted foreground object
+        
+        #### Fourier Transform Filtering
+        - **Purpose**: Filter images in frequency domain
+        - **How it works**: Converts to frequency domain, applies filter, converts back
+        - **Low-Pass**: Removes high frequencies (edges), keeps smooth regions → blur effect
+        - **High-Pass**: Removes low frequencies (smooth regions), keeps edges → sharpen effect
+        - **Band-Pass**: Keeps only middle-range frequencies
+        - **Band-Stop**: Removes middle-range frequencies (notch filter)
+        - **Use Case**: Periodic noise removal, custom filtering, pattern analysis
+        
+        #### Gray-World Color Constancy
+        - **Purpose**: Correct color casts from lighting
+        - **How it works**: Assumes average scene color should be neutral gray
+        - **Method**: Balances RGB channels so their average equals gray
+        - **Percentile**: 50=standard mean, 40-45=robust to bright highlights
+        - **Use Case**: Indoor/outdoor lighting correction, white balance adjustment
+        
+        #### Anisotropic Diffusion
+        - **Purpose**: Edge-preserving noise reduction
+        - **How it works**: Perona-Malik diffusion - smooths flat regions, preserves edges
+        - **Kappa**: Edge threshold (10-50 typical, higher = more edges preserved)
+        - **Gamma**: Diffusion speed (0.1-0.25, must be ≤0.25 for stability)
+        - **Iterations**: More = more smoothing (5-20 typical)
+        - **Use Case**: Medical imaging, noise reduction without edge loss
         """)
 
 if __name__ == "__main__":