app as updated

app.py

@@ -2,86 +2,132 @@ import streamlit as st
 import cv2
 import numpy as np
 from PIL import Image
+import io
 
-# Function to apply filters
-def apply_filter(image, filter_name, scale):
-    if filter_name == "Grayscale":
-        return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    elif filter_name == "Blur":
-        # Ensure kernel size is a positive odd integer
-        ksize = max(1, scale)
-        ksize = ksize if ksize % 2 == 1 else ksize + 1
-        return cv2.GaussianBlur(image, (ksize, ksize), 0)
-    elif filter_name == "Sharpen":
-        kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
-        return cv2.filter2D(image, -1, kernel)
-    elif filter_name == "Edge Detection":
-        # Ensure scale is within valid range for Canny
-        scale = max(1, scale)
-        return cv2.Canny(image, scale, scale * 2)
-    elif filter_name == "Brightness":
-        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
-        hsv[:, :, 2] = np.clip(hsv[:, :, 2] + scale, 0, 255)
-        return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
-    elif filter_name == "Contrast":
-        alpha = scale / 50.0
-        return cv2.convertScaleAbs(image, alpha=alpha, beta=0)
-    elif filter_name == "Threshold":
-        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-        _, thresh = cv2.threshold(gray, scale, 255, cv2.THRESH_BINARY)
-        return thresh
-    elif filter_name == "Sepia":
-        kernel = np.array([[0.272, 0.534, 0.131],
-                           [0.349, 0.686, 0.168],
-                           [0.393, 0.769, 0.189]])
-        return cv2.transform(image, kernel)
-    else:
-        return image
-
-# Streamlit app
-st.title("🎨 Image Processing App 🖼️")
-st.write("Upload an image and apply filters to see the magic! ✨")
+# App title and emojis
+st.title("📸 Image Processing App 🎨")
+st.write("Upload an image, apply filters, and download the processed image! ✨")
+
+# Sidebar for feature selection
+st.sidebar.header("🎨 Filter Options")
+filter_type = st.sidebar.selectbox(
+    "Select a filter:",
+    [
+        "Blur",
+        "Edge Detection (Canny)",
+        "Grayscale",
+        "Sharpen",
+        "Sepia",
+        "Invert Colors",
+        "Brightness Adjustment",
+        "Contrast Adjustment",
+    ],
+)
 
 # Upload image
-uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+uploaded_file = st.file_uploader(".Upload an image 🖼️", type=["jpg", "jpeg", "png"])
 
 if uploaded_file is not None:
-    # Read and display the original image
-    image = Image.open(uploaded_file)
-    image = np.array(image)
-    st.write("### Original Image 🖼️")
-    st.image(image, caption="Original Image", use_container_width=True)
-
-    # Select filter
-    filter_name = st.selectbox(
-        "Choose a filter 🎛️",
-        ["Grayscale", "Blur", "Sharpen", "Edge Detection", "Brightness", "Contrast", "Threshold", "Sepia"]
-    )
-
-    # Add slider for filter scale
-    scale = st.slider(f"Adjust {filter_name} intensity ⚙️", 1, 100, 50)
+    # Convert the file to an OpenCV image
+    file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+    img = cv2.imdecode(file_bytes, 1)
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB
 
-    # Apply filter
-    processed_image = apply_filter(image, filter_name, scale)
-
-    # Display input and output images in the same row
+    # Display original image
     col1, col2 = st.columns(2)
     with col1:
-        st.write("### Original Image 🖼️")
-        st.image(image, caption="Original Image", use_container_width=True)
+        st.subheader("Original Image 📷")
+        st.image(img, use_container_width=True)
+
+    # Apply filters based on user selection
+    processed_img = img.copy()
+
+    if filter_type == "Blur":
+        blur_type = st.sidebar.selectbox(
+            "Blur Type", ["Gaussian Blur", "Average Blur", "Median Blur", "Bilateral Filter"]
+        )
+        if blur_type == "Gaussian Blur":
+            kernel_size = st.sidebar.slider("Kernel Size 🔍", 1, 31, 5, step=2)
+            sigma_x = st.sidebar.slider("Sigma X (Standard Deviation)", 0, 10, 0)
+            processed_img = cv2.GaussianBlur(processed_img, (kernel_size, kernel_size), sigma_x)
+
+        elif blur_type == "Average Blur":
+            kernel_size = st.sidebar.slider("Kernel Size 🔍", 1, 31, 5, step=2)
+            processed_img = cv2.blur(processed_img, (kernel_size, kernel_size))
+
+        elif blur_type == "Median Blur":
+            kernel_size = st.sidebar.slider("Kernel Size 🔍", 1, 31, 5, step=2)
+            processed_img = cv2.medianBlur(processed_img, kernel_size)
+
+        elif blur_type == "Bilateral Filter":
+            diameter = st.sidebar.slider("Diameter", 1, 31, 9, step=2)
+            sigma_color = st.sidebar.slider("Sigma Color", 1, 200, 75)
+            sigma_space = st.sidebar.slider("Sigma Space", 1, 200, 75)
+            processed_img = cv2.bilateralFilter(processed_img, diameter, sigma_color, sigma_space)
+
+    elif filter_type == "Edge Detection (Canny)":
+        lower_threshold = st.sidebar.slider("Lower Threshold ⬇️", 0, 255, 100)
+        upper_threshold = st.sidebar.slider("Upper Threshold ⬆️", 0, 255, 200)
+        processed_img = cv2.Canny(processed_img, lower_threshold, upper_threshold)
+
+    elif filter_type == "Grayscale":
+        grayscale_method = st.sidebar.selectbox(
+            "Grayscale Method", ["Weighted Average", "Simple Average"]
+        )
+        if grayscale_method == "Weighted Average":
+            processed_img = cv2.cvtColor(processed_img, cv2.COLOR_RGB2GRAY)
+        else:
+            processed_img = np.mean(processed_img, axis=2).astype(np.uint8)
+
+    elif filter_type == "Sharpen":
+        sharpness = st.sidebar.slider("Sharpness Intensity", 1.0, 10.0, 1.0)
+        kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]) * sharpness
+        processed_img = cv2.filter2D(processed_img, -1, kernel)
+
+    elif filter_type == "Sepia":
+        sepia_intensity = st.sidebar.slider("Sepia Intensity", 0.1, 1.0, 1.0)
+        sepia_filter = (
+            np.array(
+                [[0.272, 0.534, 0.131], [0.349, 0.686, 0.168], [0.393, 0.769, 0.189]]
+            )
+            * sepia_intensity
+        )
+        processed_img = cv2.transform(processed_img, sepia_filter)
+        processed_img = np.clip(processed_img, 0, 255)
+
+    elif filter_type == "Invert Colors":
+        blend_factor = st.sidebar.slider("Inversion Blend Factor", 0.0, 1.0, 1.0)
+        inverted_img = 255 - processed_img
+        processed_img = cv2.addWeighted(
+            processed_img, 1 - blend_factor, inverted_img, blend_factor, 0
+        )
+
+    elif filter_type == "Brightness Adjustment":
+        brightness = st.sidebar.slider("Brightness ☀️", -100, 100, 0)
+        processed_img = cv2.convertScaleAbs(processed_img, alpha=1, beta=brightness)
+
+    elif filter_type == "Contrast Adjustment":
+        contrast = st.sidebar.slider("Contrast ⚡", 0.1, 3.0, 1.0, step=0.1)
+        processed_img = cv2.convertScaleAbs(processed_img, alpha=contrast, beta=0)
+
+    # Display processed image
     with col2:
-        st.write("### Processed Image 🎨")
-        st.image(processed_image, caption=f"{filter_name} Applied", use_container_width=True)
+        st.subheader("Processed Image 🎯")
+        st.image(processed_img, use_container_width=True)
 
     # Download button for processed image
-    processed_image_pil = Image.fromarray(processed_image)
+    st.markdown("---")
+    st.subheader("Download Processed Image 💾")
+    buf = io.BytesIO()
+    pil_img = Image.fromarray(processed_img)
+    pil_img.save(buf, format="PNG")
+    byte_im = buf.getvalue()
     st.download_button(
-        label="Download Processed Image ⬇️",
-        data=processed_image_pil.tobytes(),
+        label="📥 Download Image",
+        data=byte_im,
         file_name="processed_image.png",
-        mime="image/png"
+        mime="image/png",
     )
 
-    st.success("✅ Image processing complete! Enjoy your masterpiece! 🎨")
 else:
-    st.info("👆 Please upload an image to get started! 🖼️")
+    st.info("Please upload an image to get started. 📂")