Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,200 @@
-import altair as alt
+import cv2
 import numpy as np
-import pandas as pd
 import streamlit as st
+from PIL import Image
+import io
 
-"""
-# Welcome to Streamlit!
+class FaceAnonymizer:
+    def __init__(self):
+        # loads harcascade for facial detecition
+        self.face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+      
+    def detect_faces(self, image):
+        """ 
+        input : takes an image 
+        output : returns list of rectangles, each rectangle represent a face 
+        [[(100, 50, 80, 80), (250, 60, 85, 85)] : means two faces were detected. 
+        """
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        faces = self.face_cascade.detectMultiScale(
+            gray,
+            scaleFactor=1.1,
+            minNeighbors=5,
+            minSize=(30, 30)
+        )
+        return faces
+    
+    def pixelate_area(self, image, x, y, w, h, pixel_size=15):
+        """
+        input : image,
+                (x,y) is the top-left corner of the rectangle
+                (w,h) is the width and height of the rectangle
+        output : returns the image with the selected area pixelated.
+        """
+        reason_of_interest = image[y:y+h, x:x+w]
+        downscaled_roi = cv2.resize(reason_of_interest, (pixel_size, pixel_size), interpolation=cv2.INTER_LINEAR)
+        pixelated = cv2.resize(downscaled_roi, (w, h), interpolation=cv2.INTER_NEAREST)
+        image[y:y+h, x:x+w] = pixelated
+        return image
+    
+    def blur_area(self, image, x, y, w, h, blur_strength=25):
+        """Apply gaussian blur to a specific area"""
+        roi = image[y:y+h, x:x+w]
+        # Ensure blur strength is odd
+        if blur_strength % 2 == 0:
+            blur_strength += 1
+        blurred = cv2.GaussianBlur(roi, (blur_strength, blur_strength), 0)
+        image[y:y+h, x:x+w] = blurred
+        return image
+    
+    def process_image(self, image, method='blur', pixel_size=15, blur_strength=25, padding=10):
+        """Process an image to anonymize faces"""
+        result = image.copy()
+        faces = self.detect_faces(image)
+        
+        for (x, y, w, h) in faces:
+            # Add padding around the face
+            x = max(0, x - padding)
+            y = max(0, y - padding)
+            w = min(image.shape[1] - x, w + 2 * padding)
+            h = min(image.shape[0] - y, h + 2 * padding)
+            
+            if method == 'pixelate':
+                result = self.pixelate_area(result, x, y, w, h, pixel_size)
+            elif method == 'blur':
+                result = self.blur_area(result, x, y, w, h, blur_strength)
+                
+        return result, len(faces)
 
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# helper functions to convert PIL to CV2
+def pil_to_cv2(pil_image):
+    open_cv_image = np.array(pil_image.convert('RGB'))
+    return cv2.cvtColor(open_cv_image, cv2.COLOR_RGB2BGR)
 
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
+# helper functions to convert CV2 to PIL
+def cv2_to_pil(cv2_image):
+    """Convert OpenCV image to PIL format"""
+    rgb_image = cv2.cvtColor(cv2_image, cv2.COLOR_BGR2RGB)
+    return Image.fromarray(rgb_image)
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
+def main():
+    st.set_page_config(
+        page_title="Face Anonymizer",
+        page_icon="🙈",
+        layout="wide"
+    )
+    
+    st.title("Face Anonymizer")
+    st.markdown("Upload an image and automatically blur or pixelate faces for privacy protection")
+    
 
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
+    if 'anonymizer' not in st.session_state:
+        st.session_state.anonymizer = FaceAnonymizer()
+    
+    st.sidebar.header("Settings")
+    
+    method = st.sidebar.selectbox(
+        "Anonymization Method",
+        ["blur", "pixelate"],
+        help="Choose between blur or pixelation effect"
+    )
+    
+    if method == "blur":
+        blur_strength = st.sidebar.slider(
+            "Blur Strength",
+            min_value=5,
+            max_value=99,
+            value=25,
+            step=2,
+            help="Higher values = more blur (must be odd)"
+        )
+       
+        if blur_strength % 2 == 0:
+            blur_strength += 1
+    else:
+        pixel_size = st.sidebar.slider(
+            "Pixel Size",
+            min_value=5,
+            max_value=50,
+            value=15,
+            help="Lower values = more pixelated"
+        )
+    
+    padding = st.sidebar.slider(
+        "Face Padding",
+        min_value=0,
+        max_value=50,
+        value=10,
+        help="Adds an extra padding around detected faces"
+    )
+    
+    # upload a file 
+    uploaded_file = st.file_uploader(
+        "Choose an image file",
+        type=['jpg', 'jpeg', 'png'],
+        help="Upload a JPG, PNG or image"
+    )
+    
+    if uploaded_file is not None:
+        # if image is uploaded open and display the image 
+        pil_image = Image.open(uploaded_file)
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("📸 Original Image")
+            st.image(pil_image, use_column_width=True)
+        
+        # process the image
+        with st.spinner("detecting and anonymizing faces"):
+            # convert PIL to cv2 format 
+            cv2_image = pil_to_cv2(pil_image)
+            
+            # process based on selected method
+            if method == "blur":
+                processed_image, face_count = st.session_state.anonymizer.process_image(
+                    cv2_image, method=method, blur_strength=blur_strength, padding=padding
+                )
+            else:
+                processed_image, face_count = st.session_state.anonymizer.process_image(
+                    cv2_image, method=method, pixel_size=pixel_size, padding=padding
+                )
+            
+            # convert back to PIL for display
+            result_pil = cv2_to_pil(processed_image)
+        
+        with col2:
+            st.subheader("Anonymized Image")
+            st.image(result_pil, use_column_width=True)
+        
+        # Show results info
+        if face_count > 0:
+            st.success(f"Successfully anonymized {face_count} face(s) using {method}")
+        else:
+            st.warning("No faces detected in the image")
+        
+       
+        img_buffer = io.BytesIO()
+        result_pil.save(img_buffer, format='PNG')
+        img_buffer.seek(0)
+        
+        st.download_button(
+            label="Download Anonymized Image",
+            data=img_buffer.getvalue(),
+            file_name=f"anonymized_{uploaded_file.name}",
+            mime="image/png",
+            use_container_width=True
+        )
+        
+        # Settings info
+        with st.expander("ℹ️ Processing Details"):
+            st.write(f"**Method:** {method.title()}")
+            if method == "blur":
+                st.write(f"**Blur Strength:** {blur_strength}")
+            else:
+                st.write(f"**Pixel Size:** {pixel_size}")
+            st.write(f"**Face Padding:** {padding}px")
+           
 
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+if __name__ == "__main__":
+    main()