Update app.py

app.py

@@ -1,25 +1,53 @@
 import numpy as np
 import gradio as gr
-from skimage import io, color
-from numpy.linalg import norm
+import cv2  # OpenCV for face detection
+from skimage import color
+from sklearn.decomposition import TruncatedSVD
+from concurrent.futures import ThreadPoolExecutor
 from PIL import Image
 
-def svd_compress(image, k):
-    """Compress the image using SVD by keeping only the top k singular values."""
-    U, S, Vt = np.linalg.svd(image, full_matrices=False)
-    compressed_image = np.dot(U[:, :k], np.dot(np.diag(S[:k]), Vt[:k, :]))
+# Detect faces using OpenCV
+def detect_faces(image_np):
+    """Detect faces in the image and return their bounding boxes."""
+    gray_image = cv2.cvtColor(image_np, cv2.COLOR_RGB2GRAY)
+    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+    faces = face_cascade.detectMultiScale(gray_image, scaleFactor=1.1, minNeighbors=5)
+    return faces
+
+# Compress the image using Truncated SVD for faster performance
+def truncated_svd_compress(image, k):
+    """Compress the image using Truncated SVD by keeping only the top k singular values."""
+    svd = TruncatedSVD(n_components=k)
+    U = svd.fit_transform(image)
+    S = svd.singular_values_
+    Vt = svd.components_
+    compressed_image = np.dot(U, np.dot(np.diag(S), Vt))
     return compressed_image
 
+# Process the image asynchronously for smoother user experience
+async def process_image_async(image, k):
+    """Asynchronous image processing to avoid blocking."""
+    return await asyncio.to_thread(process_image, image, k)
+
+# Main image processing function
 def process_image(image, k):
-    """Process the uploaded image, compress it using SVD, and return the result."""
+    """Process the uploaded image, detect faces, and compress it using Truncated SVD."""
     # Convert PIL Image to NumPy array
     image_np = np.array(image)
     
-    # Convert to grayscale
+    # Detect faces in the image
+    faces = detect_faces(image_np)
+    
+    # If faces are detected, highlight the regions (optional)
+    if len(faces) > 0:
+        for (x, y, w, h) in faces:
+            cv2.rectangle(image_np, (x, y), (x+w, y+h), (255, 0, 0), 2)
+    
+    # Convert the image to grayscale
     gray_image = color.rgb2gray(image_np)
     
     # Compress the image
-    compressed_image = svd_compress(gray_image, k)
+    compressed_image = truncated_svd_compress(gray_image, k)
     
     # Convert compressed image back to PIL Image for Gradio output
     compressed_image_pil = Image.fromarray((compressed_image * 255).astype(np.uint8))
@@ -27,10 +55,16 @@ def process_image(image, k):
     return compressed_image_pil
 
 # Gradio interface
-gr_interface = gr.Interface(fn=process_image,
-                            inputs=[gr.Image(type="pil"), gr.Slider(1, 100, step=1, value=50, label="Compression Rank")],
-                            outputs=gr.Image(type="pil"),
-                            title="Interactive Image Compression using SVD",
-                            description="Upload an image and adjust the compression rank to see the compressed version.")
+gr_interface = gr.Interface(
+    fn=process_image,  # Image processing function
+    inputs=[
+        gr.Image(type="pil", label="Upload Image"),
+        gr.Slider(1, 100, step=1, value=50, label="Compression Rank")  # Compression rank slider
+    ],
+    outputs=gr.Image(type="pil", label="Compressed Image"),
+    title="Fast Interactive Image Compression with Face Detection",
+    description="Upload an image and adjust the compression rank. The app detects faces and compresses the image using Truncated SVD for faster processing."
+)
 
+# Launch the Gradio interface
 gr_interface.launch()