Update app.py

app.py

@@ -1,228 +1,131 @@
 import streamlit as st
 from PIL import Image, ImageEnhance, ImageFilter, ImageOps
 import numpy as np
-import cv2
-import io
+from io import BytesIO
 
 # Function to apply grayscale filter
 def apply_grayscale(image):
     return image.convert("L")
 
-# Function to adjust brightness
-def adjust_brightness(image, factor):
+# Function to apply brightness adjustment
+def apply_brightness(image, factor):
     enhancer = ImageEnhance.Brightness(image)
     return enhancer.enhance(factor)
 
-# Function to adjust contrast
-def adjust_contrast(image, factor):
+# Function to apply contrast adjustment
+def apply_contrast(image, factor):
     enhancer = ImageEnhance.Contrast(image)
     return enhancer.enhance(factor)
 
-# Function to adjust saturation
-def adjust_saturation(image, factor):
-    enhancer = ImageEnhance.Color(image)
-    return enhancer.enhance(factor)
-
-# Function to apply sharpness enhancement
+# Function to apply sharpness adjustment
 def apply_sharpness(image, factor):
     enhancer = ImageEnhance.Sharpness(image)
     return enhancer.enhance(factor)
 
-# Function to apply sepia effect
-def apply_sepia(image):
-    img = np.array(image)
-    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-    sepia_filter = np.array([[0.393, 0.769, 0.189],
-                             [0.349, 0.686, 0.168],
-                             [0.272, 0.534, 0.131]])
-    img = cv2.transform(img, sepia_filter)
-    img = np.clip(img, 0, 255)
-    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    return Image.fromarray(img)
-
-# Function to apply vignette effect
-def apply_vignette(image):
-    img = np.array(image)
-    rows, cols = img.shape[:2]
-    X_resultant_kernel = cv2.getGaussianKernel(cols, cols / 3)
-    Y_resultant_kernel = cv2.getGaussianKernel(rows, rows / 3)
-    resultant_kernel = Y_resultant_kernel * X_resultant_kernel.T
-    mask = 255 * resultant_kernel / np.linalg.norm(resultant_kernel)
-    img = np.multiply(img, mask[..., np.newaxis].astype(img.dtype))
-    return Image.fromarray(img)
-
-# Function to apply blur effect
-def apply_blur(image, blur_factor):
-    return image.filter(ImageFilter.GaussianBlur(radius=blur_factor))
-
-# Function to apply edge detection
-def apply_edge_detection(image):
-    img = np.array(image)
-    edges = cv2.Canny(img, 100, 200)
-    return Image.fromarray(edges)
-
-# Function to add border
-def add_border(image, border_color, border_width):
-    # Adding border using PIL ImageOps
-    return ImageOps.expand(image, border=border_width, fill=border_color)
-
-# Function to add frame
-def add_frame(image, frame_style="Simple"):
+# Function to apply blur filter
+def apply_blur(image, blur_radius):
+    return image.filter(ImageFilter.GaussianBlur(radius=blur_radius))
+
+# Function to add border to image
+def add_border(image, border_type, color, thickness):
     width, height = image.size
-    if frame_style == "Simple":
-        # Add simple black border
-        frame_width = 30
-        return ImageOps.expand(image, border=frame_width, fill="black")
-    elif frame_style == "Ornate":
-        # Add ornate frame (you can customize with more ornate styles)
-        frame_width = 50
-        return ImageOps.expand(image, border=frame_width, fill="gold")
-    elif frame_style == "Rounded":
-        # Add rounded frame (with radius)
-        frame_width = 30
-        image_with_frame = ImageOps.expand(image, border=frame_width, fill="blue")
-        return image_with_frame.convert("RGBA").rotate(0, resample=Image.BICUBIC)
-    elif frame_style == "Polaroid":
-        # Add Polaroid-style frame (white bottom for caption)
-        frame_width = 40
-        image_with_frame = ImageOps.expand(image, border=frame_width, fill="white")
-        bottom_margin = Image.new('RGB', (image_with_frame.width, 50), color='white')
-        return Image.new('RGB', (image_with_frame.width, image_with_frame.height + bottom_margin.height), color='white').paste(image_with_frame, (0, 0)).paste(bottom_margin, (0, image_with_frame.height))
-    elif frame_style == "Shadow":
-        # Add shadow frame
-        frame_width = 50
-        shadow_image = Image.new("RGBA", (image.width + 2 * frame_width, image.height + 2 * frame_width), (0, 0, 0, 180))
-        shadow_image.paste(image, (frame_width, frame_width))
-        return shadow_image.convert("RGB")
-    elif frame_style == "Vintage":
-        # Add vintage-style frame with a distressed look (this can be more complex)
-        frame_width = 30
-        return ImageOps.expand(image, border=frame_width, fill="beige")
-    elif frame_style == "Filmstrip":
-        # Add a filmstrip frame with a perforated edge
-        frame_width = 60
-        return ImageOps.expand(image, border=frame_width, fill="black")
-    elif frame_style == "Double Border":
-        # Add a double border (one thin, one thick)
-        outer_width = 60
-        inner_width = 20
-        image_with_outer_border = ImageOps.expand(image, border=outer_width, fill="black")
-        return ImageOps.expand(image_with_outer_border, border=inner_width, fill="white")
-    elif frame_style == "Metallic":
-        # Add metallic frame (gold, silver, etc.)
-        frame_width = 40
-        return ImageOps.expand(image, border=frame_width, fill="gold")
-    elif frame_style == "Heart-Shaped":
-        # Add heart-shaped frame
-        image_with_frame = image.resize((450, 450))  # Adjust for better fit
-        return image_with_frame.convert("RGBA")
-    elif frame_style == "Circular":
-        # Add circular frame
-        image_with_frame = image.resize((450, 450))  # Adjust for better fit
-        return image_with_frame.convert("RGBA")
-    elif frame_style == "Wooden":
-        # Add wooden frame
-        frame_width = 50
-        return ImageOps.expand(image, border=frame_width, fill="saddlebrown")
-    elif frame_style == "Neon Glow":
-        # Add neon glow frame
-        frame_width = 50
-        neon_image = Image.new("RGBA", (image.width + 2 * frame_width, image.height + 2 * frame_width), (0, 255, 255, 255))
-        neon_image.paste(image, (frame_width, frame_width))
-        return neon_image.convert("RGB")
-    elif frame_style == "Gradient":
-        # Add gradient frame
-        frame_width = 40
-        return ImageOps.expand(image, border=frame_width, fill="gradient")
-    elif frame_style == "Geometric":
-        # Add geometric frame (triangles, hexagons, etc.)
-        frame_width = 30
-        return ImageOps.expand(image, border=frame_width, fill="purple")
-
-# Function to convert PIL image to bytes for download
-def pil_to_bytes(image, format="JPEG"):
-    img_byte_arr = io.BytesIO()
-    image.save(img_byte_arr, format=format)
-    img_byte_arr.seek(0)
-    return img_byte_arr
-
-# Streamlit app
+    border_color = tuple(int(c) for c in color.split(','))
+    if border_type == "Solid Color":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Dotted":
+        # Use dotted pattern
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Dashed":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Double":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Inset":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Outset":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Rounded Corner":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Shadowed":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Polaroid":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Metallic":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Wooden":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Textured":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Neon":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Polka Dots":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Stripe":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Sketch":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+    elif border_type == "Lace":
+        return ImageOps.expand(image, border=thickness, fill=border_color)
+
 def main():
-    st.title("Advanced Image Editor")
+    st.title("Image Editor")
+    st.sidebar.title("Enhance Image")
 
-    # Upload image
-    uploaded_image = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
+    # Upload Image
+    uploaded_image = st.sidebar.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
 
     if uploaded_image is not None:
-        # Open the uploaded image using PIL
         image = Image.open(uploaded_image)
 
-        # Resize the image for better side-by-side display
-        original_image_resized = image.resize((400, int(image.height * 400 / image.width)))
+        # Show original image
+        st.image(image, caption="Original Image", use_container_width=True)
 
-        # Apply filters
-        st.sidebar.title("Adjust Filters")
-        
-        filter_option = st.sidebar.selectbox("Choose a filter", ("None", "Grayscale", "Brightness", "Contrast", "Saturation", "Sharpness", "Sepia", "Vignette", "Blur", "Edge Detection"))
-        
-        if filter_option == "Grayscale":
+        # Grayscale option
+        grayscale = st.sidebar.checkbox("Apply Grayscale")
+        if grayscale:
             image = apply_grayscale(image)
-        elif filter_option == "Brightness":
-            brightness_factor = st.sidebar.slider("Brightness Factor", 0.1, 2.0, 1.0)
-            image = adjust_brightness(image, brightness_factor)
-        elif filter_option == "Contrast":
-            contrast_factor = st.sidebar.slider("Contrast Factor", 0.1, 2.0, 1.0)
-            image = adjust_contrast(image, contrast_factor)
-        elif filter_option == "Saturation":
-            saturation_factor = st.sidebar.slider("Saturation Factor", 0.1, 2.0, 1.0)
-            image = adjust_saturation(image, saturation_factor)
-        elif filter_option == "Sharpness":
-            sharpness_factor = st.sidebar.slider("Sharpness Factor", 0.1, 2.0, 1.0)
-            image = apply_sharpness(image, sharpness_factor)
-        elif filter_option == "Sepia":
-            image = apply_sepia(image)
-        elif filter_option == "Vignette":
-            image = apply_vignette(image)
-        elif filter_option == "Blur":
-            blur_factor = st.sidebar.slider("Blur Radius", 0.1, 10.0, 2.0)
-            image = apply_blur(image, blur_factor)
-        elif filter_option == "Edge Detection":
-            image = apply_edge_detection(image)
-
-        # Add border or frame
-        border_option = st.sidebar.selectbox("Add Border or Frame", ("None", "Border", "Frame"))
-        
-        if border_option == "Border":
-            border_color = st.sidebar.color_picker("Pick a border color", "#000000")
-            border_width = st.sidebar.slider("Border Width", 1, 100, 10)
-            image = add_border(image, border_color, border_width)
-        elif border_option == "Frame":
-            frame_style = st.sidebar.selectbox("Choose a frame style", (
-                "Simple", "Ornate", "Rounded", "Polaroid", "Shadow", "Vintage", "Filmstrip", "Double Border", "Metallic", 
-                "Heart-Shaped", "Circular", "Wooden", "Neon Glow", "Gradient", "Geometric"
-            ))
-            image = add_frame(image, frame_style)
-
-        # Resize the filtered image for display
-        modified_image_resized = image.resize((400, int(image.height * 400 / image.width)))
-
-        # Create two columns to display images side by side
-        col1, col2 = st.columns(2)
-
-        # Display the original image in the first column
-        with col1:
-            st.image(original_image_resized, caption="Original Image", use_container_width=True)
-
-        # Display the modified image in the second column
-        with col2:
-            st.image(modified_image_resized, caption="Modified Image", use_container_width=True)
-
-        # Convert the edited image to bytes for download
-        img_bytes = pil_to_bytes(image)
-
-        # Button to download the edited image below the modified image
-        with col2:
-            st.download_button("Download Edited Image", img_bytes, "edited_image.jpg", "image/jpeg")
+
+        # Brightness adjustment
+        brightness_factor = st.sidebar.slider("Adjust Brightness", 0.0, 2.0, 1.0)
+        image = apply_brightness(image, brightness_factor)
+
+        # Contrast adjustment
+        contrast_factor = st.sidebar.slider("Adjust Contrast", 0.0, 2.0, 1.0)
+        image = apply_contrast(image, contrast_factor)
+
+        # Sharpness adjustment
+        sharpness_factor = st.sidebar.slider("Adjust Sharpness", 0.0, 2.0, 1.0)
+        image = apply_sharpness(image, sharpness_factor)
+
+        # Blur effect
+        blur_radius = st.sidebar.slider("Blur Radius", 0, 10, 0)
+        if blur_radius > 0:
+            image = apply_blur(image, blur_radius)
+
+        # Border options
+        border_type = st.sidebar.selectbox("Select Border Type", [
+            "Solid Color", "Dotted", "Dashed", "Double", "Inset", "Outset", "Rounded Corner",
+            "Shadowed", "Polaroid", "Metallic", "Wooden", "Textured", "Neon", "Polka Dots",
+            "Stripe", "Sketch", "Lace"])
+
+        border_color = st.sidebar.color_picker("Pick a Border Color", "#000000")
+        border_thickness = st.sidebar.slider("Select Border Thickness", 0, 50, 10)
+
+        image = add_border(image, border_type, border_color[1:], border_thickness)
+
+        # Display the modified image
+        st.image(image, caption="Modified Image", use_container_width=True)
+
+        # Download button
+        buffered = BytesIO()
+        image.save(buffered, format="JPEG")
+        buffered.seek(0)
+
+        st.sidebar.download_button(
+            label="Download Edited Image",
+            data=buffered,
+            file_name="edited_image.jpg",
+            mime="image/jpeg"
+        )
 
 if __name__ == "__main__":
     main()