Create app.py

app.py

@@ -0,0 +1,558 @@
+import streamlit as st
+from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageEnhance, ImageOps, ImageChops, ImageColor
+import numpy as np
+import io
+import os
+import json
+from rembg import remove
+import requests
+from pathlib import Path
+import zipfile
+
+# ------------------------------
+# Utility Functions
+# ------------------------------
+
+def download_file(url, dest_path):
+    """
+    Downloads a file from a URL to the specified destination path.
+    """
+    try:
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        with open(dest_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        st.info(f"Downloaded: {dest_path.name}")
+    except Exception as e:
+        st.error(f"Failed to download {url}: {e}")
+
+def setup_fonts():
+    """
+    Ensures that all required fonts are downloaded and available locally.
+    Uses open-source fonts from Google Fonts.
+    """
+    fonts_dir = Path("fonts")
+    fonts_dir.mkdir(exist_ok=True)
+
+    # Define open-source fonts to download
+    font_info = {
+        "Roboto": {
+            "name": "Roboto-Regular.ttf",
+            "url": "https://github.com/google/fonts/raw/main/apache/roboto/Roboto-Regular.ttf"
+        },
+        "OpenSans": {
+            "name": "OpenSans-Regular.ttf",
+            "url": "https://github.com/google/fonts/raw/main/apache/opensans/OpenSans-Regular.ttf"
+        },
+        "Lato": {
+            "name": "Lato-Regular.ttf",
+            "url": "https://github.com/google/fonts/raw/main/ofl/lato/Lato-Regular.ttf"
+        },
+        "Montserrat": {
+            "name": "Montserrat-Regular.ttf",
+            "url": "https://github.com/google/fonts/raw/main/ofl/montserrat/Montserrat-Regular.ttf"
+        },
+        "SourceSansPro": {
+            "name": "SourceSansPro-Regular.ttf",
+            "url": "https://github.com/google/fonts/raw/main/ofl/sourcesanspro/SourceSansPro-Regular.ttf"
+        }
+    }
+
+    # Download fonts if not already present
+    for font_key, font_details in font_info.items():
+        font_path = fonts_dir / font_details["name"]
+        if not font_path.exists():
+            st.info(f"Downloading {font_key} font...")
+            download_file(font_details["url"], font_path)
+        else:
+            st.success(f"Font {font_key} already exists.")
+
+    # Return a mapping of font names to paths
+    font_paths = {font_key: str(fonts_dir / details["name"]) for font_key, details in font_info.items()}
+    return font_paths
+
+def setup_stickers():
+    """
+    Ensures that all required stickers are downloaded and available locally.
+    Downloads a set of free stickers from a reliable source.
+    """
+    stickers_dir = Path("stickers")
+    stickers_dir.mkdir(exist_ok=True)
+
+    # Define stickers to download
+    sticker_info = {
+        "Star": {
+            "name": "Star.png",
+            "url": "https://github.com/huggingface/datasets/raw/main/datasets/emoji/images/Star.png"
+        },
+        "Heart": {
+            "name": "Heart.png",
+            "url": "https://github.com/huggingface/datasets/raw/main/datasets/emoji/images/Heart.png"
+        },
+        "Smile": {
+            "name": "Smile.png",
+            "url": "https://github.com/huggingface/datasets/raw/main/datasets/emoji/images/Smile.png"
+        }
+    }
+
+    # Download stickers if not already present
+    for sticker_key, sticker_details in sticker_info.items():
+        sticker_path = stickers_dir / sticker_details["name"]
+        if not sticker_path.exists():
+            st.info(f"Downloading {sticker_key} sticker...")
+            download_file(sticker_details["url"], sticker_path)
+        else:
+            st.success(f"Sticker {sticker_key} already exists.")
+
+# ------------------------------
+# Initialize Application
+# ------------------------------
+
+# Set Streamlit page configuration
+st.set_page_config(page_title="🎨 Pro Image Editor", layout="wide")
+
+# Display a loading spinner while setting up fonts and stickers
+with st.spinner('Setting up fonts and stickers...'):
+    font_paths = setup_fonts()
+    setup_stickers()
+
+# Initialize session state for layers and history
+if 'layers' not in st.session_state:
+    st.session_state['layers'] = []
+if 'history' not in st.session_state:
+    st.session_state['history'] = []
+if 'redo_stack' not in st.session_state:
+    st.session_state['redo_stack'] = []
+
+# ------------------------------
+# Layer Management Functions
+# ------------------------------
+
+def add_layer(layer):
+    st.session_state['layers'].append(layer)
+    st.session_state['history'].append(('add', layer))
+    st.session_state['redo_stack'] = []
+
+def remove_layer(index):
+    layer = st.session_state['layers'].pop(index)
+    st.session_state['history'].append(('remove', layer, index))
+    st.session_state['redo_stack'] = []
+
+def reorder_layers(from_idx, to_idx):
+    layer = st.session_state['layers'].pop(from_idx)
+    st.session_state['layers'].insert(to_idx, layer)
+    st.session_state['history'].append(('reorder', from_idx, to_idx))
+    st.session_state['redo_stack'] = []
+
+def toggle_visibility(index):
+    st.session_state['layers'][index]['visible'] = not st.session_state['layers'][index].get('visible', True)
+    st.session_state['history'].append(('toggle', index))
+    st.session_state['redo_stack'] = []
+
+def undo():
+    if not st.session_state['history']:
+        st.warning("No actions to undo.")
+        return
+    action = st.session_state['history'].pop()
+    st.session_state['redo_stack'].append(action)
+    action_type = action[0]
+    if action_type == 'add':
+        st.session_state['layers'].pop()
+    elif action_type == 'remove':
+        _, layer, index = action
+        st.session_state['layers'].insert(index, layer)
+    elif action_type == 'reorder':
+        _, from_idx, to_idx = action
+        layer = st.session_state['layers'].pop(to_idx)
+        st.session_state['layers'].insert(from_idx, layer)
+    elif action_type == 'toggle':
+        _, index = action
+        st.session_state['layers'][index]['visible'] = not st.session_state['layers'][index].get('visible', True)
+
+def redo():
+    if not st.session_state['redo_stack']:
+        st.warning("No actions to redo.")
+        return
+    action = st.session_state['redo_stack'].pop()
+    st.session_state['history'].append(action)
+    action_type = action[0]
+    if action_type == 'add':
+        _, layer = action
+        st.session_state['layers'].append(layer)
+    elif action_type == 'remove':
+        _, _, index = action
+        st.session_state['layers'].pop(index)
+    elif action_type == 'reorder':
+        _, from_idx, to_idx = action
+        layer = st.session_state['layers'].pop(from_idx)
+        st.session_state['layers'].insert(to_idx, layer)
+    elif action_type == 'toggle':
+        _, index = action
+        st.session_state['layers'][index]['visible'] = not st.session_state['layers'][index].get('visible', True)
+
+# ------------------------------
+# Image Processing Functions
+# ------------------------------
+
+def apply_filters(image, filters):
+    if filters.get('grayscale'):
+        image = ImageOps.grayscale(image).convert("RGBA")
+    if filters.get('sepia'):
+        sepia_image = ImageOps.colorize(ImageOps.grayscale(image), '#704214', '#C0A080')
+        image = sepia_image.convert("RGBA")
+    if filters.get('blur'):
+        image = image.filter(ImageFilter.GaussianBlur(radius=filters.get('blur_radius', 2)))
+    if filters.get('brightness') != 1.0:
+        enhancer = ImageEnhance.Brightness(image)
+        image = enhancer.enhance(filters['brightness'])
+    if filters.get('contrast') != 1.0:
+        enhancer = ImageEnhance.Contrast(image)
+        image = enhancer.enhance(filters['contrast'])
+    return image
+
+def auto_enhance(image):
+    enhancer = ImageEnhance.Color(image)
+    enhanced_image = enhancer.enhance(1.5)  # Example enhancement factor
+    enhancer = ImageEnhance.Brightness(enhanced_image)
+    enhanced_image = enhancer.enhance(1.2)
+    enhancer = ImageEnhance.Contrast(enhanced_image)
+    enhanced_image = enhancer.enhance(1.3)
+    return enhanced_image
+
+def remove_background(image):
+    img_bytes = io.BytesIO()
+    image.save(img_bytes, format='PNG')
+    img_bytes = img_bytes.getvalue()
+    output = remove(img_bytes)
+    new_image = Image.open(io.BytesIO(output)).convert("RGBA")
+    return new_image
+
+def blend_images(base, overlay, mode):
+    if mode == "Multiply":
+        return ImageChops.multiply(base, overlay)
+    elif mode == "Screen":
+        return ImageChops.screen(base, overlay)
+    elif mode == "Overlay":
+        return ImageChops.overlay(base, overlay)
+    else:
+        return Image.alpha_composite(base, overlay)
+
+# ------------------------------
+# Sidebar Components
+# ------------------------------
+
+# 1. Upload Base Image
+st.sidebar.header("1. Upload Base Image")
+uploaded_file = st.sidebar.file_uploader("Choose an image file", type=["jpg", "jpeg", "png"])
+
+# 2. Add a Layer
+st.sidebar.header("2. Add a Layer")
+layer_type = st.sidebar.selectbox("Select Layer Type", ["Text", "Image", "Shape", "Sticker"])
+
+if layer_type == "Text":
+    text_content = st.sidebar.text_input("Enter Text", "Your text here")
+    font_size = st.sidebar.slider("Font Size", 10, 200, 40)
+    font_color = st.sidebar.color_picker("Font Color", "#000000")
+    font_choice = st.sidebar.selectbox(
+        "Select Font",
+        list(font_paths.keys())
+    )
+    selected_font_path = font_paths.get(font_choice, list(font_paths.values())[0])
+    x_position = st.sidebar.slider("X Position", 0, 2000, 50)
+    y_position = st.sidebar.slider("Y Position", 0, 2000, 50)
+    opacity = st.sidebar.slider("Opacity", 0, 100, 100)
+    alignment = st.sidebar.selectbox("Text Alignment", ["left", "center", "right"])
+    blending_mode = st.sidebar.selectbox("Blending Mode", ["Normal", "Multiply", "Screen", "Overlay"])
+
+    if st.sidebar.button("Add Text Layer"):
+        layer = {
+            'type': 'Text',
+            'content': text_content,
+            'x': x_position,
+            'y': y_position,
+            'font_size': font_size,
+            'font_color': font_color,
+            'font_path': selected_font_path,
+            'opacity': opacity,
+            'visible': True,
+            'alignment': alignment,
+            'blending_mode': blending_mode
+        }
+        add_layer(layer)
+        st.sidebar.success("Text layer added!")
+
+elif layer_type == "Image":
+    overlay_file = st.sidebar.file_uploader("Upload an image for the layer", type=["jpg", "jpeg", "png"], key="overlay")
+    if overlay_file:
+        overlay_image = Image.open(overlay_file).convert("RGBA")
+        img_width, img_height = overlay_image.size
+        max_width = st.sidebar.slider("Width", 10, 2000, img_width)
+        max_height = st.sidebar.slider("Height", 10, 2000, img_height)
+        overlay_image = overlay_image.resize((max_width, max_height))
+        x_position = st.sidebar.slider("X Position", 0, 2000, 50)
+        y_position = st.sidebar.slider("Y Position", 0, 2000, 50)
+        opacity = st.sidebar.slider("Opacity", 0, 100, 100)
+        rotation = st.sidebar.slider("Rotation (degrees)", 0, 360, 0)
+        blending_mode = st.sidebar.selectbox("Blending Mode", ["Normal", "Multiply", "Screen", "Overlay"])
+
+        if st.sidebar.button("Add Image Layer"):
+            overlay_image = overlay_image.rotate(rotation, expand=True)
+            layer = {
+                'type': 'Image',
+                'content': overlay_image,
+                'x': x_position,
+                'y': y_position,
+                'opacity': opacity,
+                'visible': True,
+                'blending_mode': blending_mode
+            }
+            add_layer(layer)
+            st.sidebar.success("Image layer added!")
+
+elif layer_type == "Shape":
+    shape_type = st.sidebar.selectbox("Shape Type", ["Rectangle", "Circle", "Line"])
+    shape_color = st.sidebar.color_picker("Shape Color", "#FF0000")
+    x1 = st.sidebar.slider("Start X", 0, 2000, 100)
+    y1 = st.sidebar.slider("Start Y", 0, 2000, 100)
+    x2 = st.sidebar.slider("End X", 0, 2000, 300)
+    y2 = st.sidebar.slider("End Y", 0, 2000, 300)
+    thickness = st.sidebar.slider("Thickness", 1, 50, 5)
+    opacity = st.sidebar.slider("Opacity", 0, 100, 100)
+    blending_mode = st.sidebar.selectbox("Blending Mode", ["Normal", "Multiply", "Screen", "Overlay"])
+
+    if st.sidebar.button("Add Shape Layer"):
+        layer = {
+            'type': 'Shape',
+            'shape': shape_type,
+            'color': shape_color,
+            'coordinates': (x1, y1, x2, y2),
+            'thickness': thickness,
+            'opacity': opacity,
+            'visible': True,
+            'blending_mode': blending_mode
+        }
+        add_layer(layer)
+        st.sidebar.success("Shape layer added!")
+
+elif layer_type == "Sticker":
+    sticker_options = ["Star", "Heart", "Smile"]
+    sticker = st.sidebar.selectbox("Select Sticker", sticker_options)
+    sticker_path = Path(f"stickers/{sticker}.png")
+    if sticker_path.exists():
+        sticker_image = Image.open(sticker_path).convert("RGBA")
+        img_width, img_height = sticker_image.size
+        max_width = st.sidebar.slider("Width", 10, 500, img_width)
+        max_height = st.sidebar.slider("Height", 10, 500, img_height)
+        sticker_image = sticker_image.resize((max_width, max_height))
+        x_position = st.sidebar.slider("X Position", 0, 2000, 50)
+        y_position = st.sidebar.slider("Y Position", 0, 2000, 50)
+        opacity = st.sidebar.slider("Opacity", 0, 100, 100)
+        rotation = st.sidebar.slider("Rotation (degrees)", 0, 360, 0)
+        blending_mode = st.sidebar.selectbox("Blending Mode", ["Normal", "Multiply", "Screen", "Overlay"])
+
+        if st.sidebar.button("Add Sticker Layer"):
+            sticker_image = sticker_image.rotate(rotation, expand=True)
+            layer = {
+                'type': 'Sticker',
+                'content': sticker_image,
+                'x': x_position,
+                'y': y_position,
+                'opacity': opacity,
+                'visible': True,
+                'blending_mode': blending_mode
+            }
+            add_layer(layer)
+            st.sidebar.success("Sticker layer added!")
+    else:
+        st.sidebar.error("Sticker image not found.")
+
+# 3. Manage Layers
+st.sidebar.header("3. Manage Layers")
+if st.session_state['layers']:
+    st.sidebar.subheader("Layers")
+    for idx, layer in enumerate(reversed(st.session_state['layers'])):
+        layer_num = len(st.session_state['layers']) - idx
+        with st.sidebar.expander(f"Layer {layer_num} ({layer['type']})"):
+            visibility = st.checkbox("Visible", value=layer.get('visible', True), key=f"visibility_{idx}")
+            if visibility != layer.get('visible', True):
+                toggle_visibility(len(st.session_state['layers']) - idx - 1)
+            if st.button("Remove", key=f"remove_{idx}"):
+                remove_layer(len(st.session_state['layers']) - idx - 1)
+            # Reordering
+            new_order = st.selectbox(
+                "Move to position",
+                options=list(range(1, len(st.session_state['layers'])+1)), 
+                index=len(st.session_state['layers'])-idx-1, 
+                key=f"move_{idx}"
+            )
+            if new_order != (len(st.session_state['layers']) - idx):
+                reorder_layers(len(st.session_state['layers']) - idx - 1, new_order - 1)
+
+# 4. History (Undo/Redo)
+st.sidebar.header("4. History")
+col1, col2 = st.sidebar.columns(2)
+with col1:
+    if st.sidebar.button("Undo"):
+        undo()
+with col2:
+    if st.sidebar.button("Redo"):
+        redo()
+
+# 5. Filters & Adjustments
+st.sidebar.header("5. Filters & Adjustments")
+apply_grayscale = st.sidebar.checkbox("Grayscale")
+apply_sepia = st.sidebar.checkbox("Sepia")
+apply_blur = st.sidebar.checkbox("Blur")
+blur_radius = st.sidebar.slider("Blur Radius", 0.0, 10.0, 2.0)
+brightness = st.sidebar.slider("Brightness", 0.5, 2.0, 1.0)
+contrast = st.sidebar.slider("Contrast", 0.5, 2.0, 1.0)
+apply_auto_enhance = st.sidebar.checkbox("Auto Enhance")
+remove_bg = st.sidebar.checkbox("Remove Background")
+
+filters = {
+    'grayscale': apply_grayscale,
+    'sepia': apply_sepia,
+    'blur': apply_blur,
+    'blur_radius': blur_radius,
+    'brightness': brightness,
+    'contrast': contrast
+}
+
+# 6. Advanced Tools
+st.sidebar.header("6. Advanced Tools")
+if st.sidebar.button("Remove Background"):
+    if uploaded_file:
+        try:
+            base_image = Image.open(uploaded_file).convert("RGBA")
+            canvas = remove_background(base_image)
+            st.session_state['layers'] = []  # Clear existing layers
+            st.success("Background removed successfully!")
+        except Exception as e:
+            st.error(f"Background removal failed: {e}")
+    else:
+        st.warning("Please upload an image first.")
+
+# 7. Save/Load Project
+st.sidebar.header("7. Save/Load Project")
+project_name = st.sidebar.text_input("Project Name")
+if st.sidebar.button("Save Project") and project_name:
+    projects_dir = Path("projects")
+    projects_dir.mkdir(exist_ok=True)
+    project_path = projects_dir / f"{project_name}.json"
+    try:
+        with open(project_path, "w") as f:
+            json.dump(st.session_state['layers'], f)
+        st.sidebar.success(f"Project '{project_name}' saved!")
+    except Exception as e:
+        st.sidebar.error(f"Failed to save project: {e}")
+
+load_project = st.sidebar.file_uploader("Load Project", type=["json"], key="load_project")
+if load_project:
+    try:
+        loaded_layers = json.load(load_project)
+        st.session_state['layers'] = loaded_layers
+        st.sidebar.success("Project loaded successfully!")
+    except Exception as e:
+        st.sidebar.error(f"Failed to load project: {e}")
+
+# ------------------------------
+# Main Area: Display and Edit Image
+# ------------------------------
+
+if uploaded_file:
+    base_image = Image.open(uploaded_file).convert("RGBA")
+    canvas = base_image.copy()
+
+    # Apply auto enhance if selected
+    if apply_auto_enhance:
+        canvas = auto_enhance(canvas)
+
+    # Initialize drawing context
+    draw = ImageDraw.Draw(canvas, 'RGBA')
+
+    for layer in st.session_state['layers']:
+        if not layer.get('visible', True):
+            continue
+        if layer['type'] == "Text":
+            try:
+                font = ImageFont.truetype(layer['font_path'], layer['font_size'])
+            except IOError:
+                font = ImageFont.load_default()
+                st.warning(f"Font not found: {layer['font_path']}. Using default font.")
+            text_color = layer['font_color']
+            text_opacity = int(255 * (layer.get('opacity', 100) / 100))
+            try:
+                text_color_rgba = ImageColor.getcolor(text_color, "RGBA")
+            except ValueError:
+                text_color_rgba = (0, 0, 0, text_opacity)
+            text_color_rgba = text_color_rgba[:3] + (text_opacity,)
+            text_layer = Image.new('RGBA', canvas.size, (255,255,255,0))
+            text_draw = ImageDraw.Draw(text_layer)
+            alignment = layer.get('alignment', 'left')
+            text_position = (layer['x'], layer['y'])
+            text_draw.text(text_position, layer['content'], fill=text_color_rgba, font=font, align=alignment)
+            if layer.get('blending_mode') and layer['blending_mode'] != "Normal":
+                canvas = blend_images(canvas, text_layer, layer['blending_mode'])
+            else:
+                canvas = Image.alpha_composite(canvas, text_layer)
+        elif layer['type'] in ["Image", "Sticker"]:
+            overlay = layer['content'].copy()
+            opacity = layer.get('opacity', 100)
+            if opacity < 100:
+                alpha = overlay.split()[3]
+                alpha = alpha.point(lambda p: p * opacity / 100)
+                overlay.putalpha(alpha)
+            if layer.get('blending_mode') and layer['blending_mode'] != "Normal":
+                canvas = blend_images(canvas, overlay, layer['blending_mode'])
+            else:
+                canvas.paste(overlay, (layer['x'], layer['y']), overlay)
+        elif layer['type'] == "Shape":
+            shape_layer = Image.new('RGBA', canvas.size, (255,255,255,0))
+            shape_draw = ImageDraw.Draw(shape_layer)
+            color = layer['color']
+            opacity = layer.get('opacity', 100)
+            try:
+                shape_color_rgba = ImageColor.getcolor(color, "RGBA")
+            except ValueError:
+                shape_color_rgba = (255, 0, 0, int(255 * (opacity / 100)))
+            shape_color_rgba = shape_color_rgba[:3] + (int(255 * (opacity / 100)),)
+            x1, y1, x2, y2 = layer['coordinates']
+            thickness = layer['thickness']
+            if layer['shape'] == "Rectangle":
+                shape_draw.rectangle([x1, y1, x2, y2], outline=shape_color_rgba, width=thickness)
+            elif layer['shape'] == "Circle":
+                shape_draw.ellipse([x1, y1, x2, y2], outline=shape_color_rgba, width=thickness)
+            elif layer['shape'] == "Line":
+                shape_draw.line([x1, y1, x2, y2], fill=shape_color_rgba, width=thickness)
+            if layer.get('blending_mode') and layer['blending_mode'] != "Normal":
+                canvas = blend_images(canvas, shape_layer, layer['blending_mode'])
+            else:
+                canvas = Image.alpha_composite(canvas, shape_layer)
+
+    # Apply filters
+    canvas = apply_filters(canvas, filters)
+
+    # Remove background if selected
+    if remove_bg:
+        try:
+            canvas = remove_background(canvas)
+            st.success("Background removed successfully!")
+        except Exception as e:
+            st.error(f"Background removal failed: {e}")
+
+    # Display the final image
+    st.image(canvas, caption="Edited Image", use_column_width=True)
+
+    # Download options
+    buffer = io.BytesIO()
+    canvas.save(buffer, format="PNG")
+    st.download_button(
+        label="📥 Download Edited Image",
+        data=buffer.getvalue(),
+        file_name="edited_image.png",
+        mime="image/png"
+    )
+
+else:
+    st.warning("Please upload an image to start editing.")