Code Editor for app.py

import streamlit as st
import pandas as pd
from PIL import Image, ImageEnhance, ImageFilter
import numpy as np
import cv2
import io

st.set_page_config(page_title="Image Editor", layout="wide")

st.title("🖼️ Image Editor")
st.markdown("Upload an image and apply various filters and adjustments!")

# File upload
uploaded_file = st.file_uploader("Choose an image...", type=['png', 'jpg', 'jpeg', 'gif', 'bmp'])

if uploaded_file is not None:
    # Load the image
    image = Image.open(uploaded_file)
    
    # Create columns for layout
    col1, col2 = st.columns([1, 2])
    
    with col1:
        st.subheader("Original Image")
        st.image(image, use_column_width=True)
        
        # Image info
        st.write(f"**Size:** {image.size[0]} x {image.size[1]} pixels")
        st.write(f"**Mode:** {image.mode}")
        st.write(f"**Format:** {image.format}")
    
    with col2:
        st.subheader("Edited Image")
        
        # Create tabs for different editing options
        tab1, tab2, tab3, tab4 = st.tabs(["Adjustments", "Filters", "Transformations", "Effects"])
        
        # Start with the original image
        edited_image = image.copy()
        
        with tab1:
            st.subheader("Image Adjustments")
            
            # Brightness
            brightness = st.slider("Brightness", 0.0, 3.0, 1.0, 0.1)
            if brightness != 1.0:
                enhancer = ImageEnhance.Brightness(edited_image)
                edited_image = enhancer.enhance(brightness)
            
            # Contrast
            contrast = st.slider("Contrast", 0.0, 3.0, 1.0, 0.1)
            if contrast != 1.0:
                enhancer = ImageEnhance.Contrast(edited_image)
                edited_image = enhancer.enhance(contrast)
            
            # Color saturation
            saturation = st.slider("Saturation", 0.0, 3.0, 1.0, 0.1)
            if saturation != 1.0:
                enhancer = ImageEnhance.Color(edited_image)
                edited_image = enhancer.enhance(saturation)
            
            # Sharpness
            sharpness = st.slider("Sharpness", 0.0, 3.0, 1.0, 0.1)
            if sharpness != 1.0:
                enhancer = ImageEnhance.Sharpness(edited_image)
                edited_image = enhancer.enhance(sharpness)
        
        with tab2:
            st.subheader("Filters")
            
            filter_options = {
                "None": None,
                "Blur": ImageFilter.BLUR,
                "Detail": ImageFilter.DETAIL,
                "Edge Enhance": ImageFilter.EDGE_ENHANCE,
                "Edge Enhance More": ImageFilter.EDGE_ENHANCE_MORE,
                "Emboss": ImageFilter.EMBOSS,
                "Find Edges": ImageFilter.FIND_EDGES,
                "Sharpen": ImageFilter.SHARPEN,
                "Smooth": ImageFilter.SMOOTH,
                "Smooth More": ImageFilter.SMOOTH_MORE,
                "Gaussian Blur": ImageFilter.GaussianBlur(radius=2)
            }
            
            selected_filter = st.selectbox("Choose a filter", list(filter_options.keys()))
            
            if selected_filter != "None" and filter_options[selected_filter] is not None:
                edited_image = edited_image.filter(filter_options[selected_filter])
        
        with tab3:
            st.subheader("Transformations")
            
            # Rotation
            rotation_angle = st.slider("Rotation (degrees)", -180, 180, 0, 5)
            if rotation_angle != 0:
                edited_image = edited_image.rotate(rotation_angle, expand=True)
            
            # Resize
            resize_factor = st.slider("Resize Factor", 0.1, 2.0, 1.0, 0.1)
            if resize_factor != 1.0:
                new_width = int(edited_image.size[0] * resize_factor)
                new_height = int(edited_image.size[1] * resize_factor)
                edited_image = edited_image.resize((new_width, new_height), Image.Resampling.LANCZOS)
            
            # Flip options
            flip_horizontal = st.checkbox("Flip Horizontal")
            flip_vertical = st.checkbox("Flip Vertical")
            
            if flip_horizontal:
                edited_image = edited_image.transpose(Image.Transpose.FLIP_LEFT_RIGHT)
            if flip_vertical:
                edited_image = edited_image.transpose(Image.Transpose.FLIP_TOP_BOTTOM)
        
        with tab4:
            st.subheader("Special Effects")
            
            # Convert to grayscale
            grayscale = st.checkbox("Convert to Grayscale")
            if grayscale:
                edited_image = edited_image.convert('L')
            
            # Sepia effect
            sepia = st.checkbox("Apply Sepia Effect")
            if sepia and not grayscale:
                # Convert to numpy array for sepia effect
                img_array = np.array(edited_image)
                sepia_filter = np.array([
                    [0.393, 0.769, 0.189],
                    [0.349, 0.686, 0.168],
                    [0.272, 0.534, 0.131]
                ])
                sepia_img = img_array.dot(sepia_filter.T)
                sepia_img = np.clip(sepia_img, 0, 255).astype(np.uint8)
                edited_image = Image.fromarray(sepia_img)
            
            # Posterize
            posterize_levels = st.slider("Posterize Levels (lower = more posterized)", 1, 8, 8)
            if posterize_levels < 8:
                from PIL import ImageOps
                edited_image = ImageOps.posterize(edited_image, posterize_levels)
        
        # Display the edited image
        st.image(edited_image, use_column_width=True)
        
        # Download button
        def convert_image_to_bytes(img):
            buf = io.BytesIO()
            img.save(buf, format='PNG')
            byte_im = buf.getvalue()
            return byte_im
        
        if st.button("Download Edited Image"):
            edited_bytes = convert_image_to_bytes(edited_image)
            st.download_button(
                label="Click to Download",
                data=edited_bytes,
                file_name="edited_image.png",
                mime="image/png"
            )

else:
    st.info("👆 Upload an image to get started!")
    
    # Show sample images
    st.markdown("### Sample Features:")
    st.markdown("""
    - **Adjustments**: Brightness, Contrast, Saturation, Sharpness
    - **Filters**: Blur, Sharpen, Edge Enhancement, Emboss, and more
    - **Transformations**: Rotate, Resize, Flip
    - **Effects**: Grayscale, Sepia, Posterize
    - **Download**: Save your edited image
    """)