Create app.py

app.py

@@ -0,0 +1,217 @@
+# app.py
+
+import streamlit as st
+from PIL import Image, ImageOps, ImageEnhance, ImageFilter, ImageDraw, ImageChops
+import random
+import os
+import io
+import time
+import numpy as np
+
+# Title
+st.title("Unique Generative Photo Editor")
+
+# Record the start time
+start_time = time.time()
+
+# Image Upload
+uploaded_file = st.file_uploader("Upload an image...", type=["jpg", "jpeg", "png"])
+
+if uploaded_file is not None:
+    # Display the uploaded image
+    input_image = Image.open(uploaded_file).convert("RGB")
+    st.image(input_image, caption='Uploaded Image', use_column_width=True)
+
+    # Get original image size
+    original_width, original_height = input_image.size
+
+    # Sidebar for parameter adjustments
+    st.sidebar.title("Parameter Adjustments")
+
+    # Image scale (size) adjustment
+    scale_factor = st.sidebar.slider("Image Scale (Size)", 0.1, 1.0, 1.0, 0.01)
+    new_width = int(original_width * scale_factor)
+    new_height = int(original_height * scale_factor)
+    input_image = input_image.resize((new_width, new_height), resample=Image.LANCZOS)
+    st.write(f"Resized Image: {input_image.size}")
+
+    # Contrast adjustment
+    contrast_factor = st.sidebar.slider("Contrast Strength", 0.5, 3.0, 1.5, 0.1)
+
+    # Brightness adjustment
+    brightness_factor = st.sidebar.slider("Brightness", 0.5, 3.0, 1.0, 0.1)
+
+    # Sharpness adjustment
+    sharpness_factor = st.sidebar.slider("Sharpness", 0.0, 5.0, 1.0, 0.1)
+
+    # Sepia depth
+    sepia_depth = st.sidebar.slider("Sepia Depth", 0, 100, 30, 1)
+
+    # Vignette effect strength
+    vignette_strength = st.sidebar.slider("Vignette Strength", 0.0, 1.0, 0.5, 0.01)
+
+    # Noise level
+    noise_level = st.sidebar.slider("Noise Level", 0, 100, 30, 1)
+
+    # Generate a unique seed
+    seed = random.randint(0, 2**32 - 1)
+    st.write(f"Unique Seed Value: {seed}")
+
+    # Seed file to record used seeds
+    seed_file = "used_seeds.txt"
+
+    # Load used seeds
+    if os.path.exists(seed_file):
+        with open(seed_file, 'r') as f:
+            used_seeds = set(int(line.strip()) for line in f)
+    else:
+        used_seeds = set()
+
+    if seed in used_seeds:
+        st.error("This seed value has already been used. Please try again.")
+    else:
+        # Save the seed value
+        with open(seed_file, 'a') as f:
+            f.write(f"{seed}\n")
+
+        # Image processing
+        with st.spinner('Processing image...'):
+            try:
+                def apply_unique_effect(image, seed, contrast_factor, brightness_factor, sharpness_factor,
+                                        sepia_depth, vignette_strength, noise_level):
+                    # Set the seed values
+                    np.random.seed(seed)
+                    random.seed(seed)
+
+                    # Step 1: Convert to grayscale
+                    image = ImageOps.grayscale(image)
+
+                    # Step 2: Adjust contrast
+                    enhancer = ImageEnhance.Contrast(image)
+                    image = enhancer.enhance(contrast_factor)
+
+                    # Step 3: Adjust brightness
+                    enhancer = ImageEnhance.Brightness(image)
+                    image = enhancer.enhance(brightness_factor)
+
+                    # Step 4: Adjust sharpness
+                    enhancer = ImageEnhance.Sharpness(image)
+                    image = enhancer.enhance(sharpness_factor)
+
+                    # Step 5: Apply sepia tone
+                    sepia_image = np.array(image).astype(np.float64)
+                    sepia_image = sepia_image / 255.0
+
+                    sepia_filter = np.array([[1.0, 0.95, 0.82]])  # Sepia color
+                    sepia_image = sepia_image[..., np.newaxis] * sepia_filter
+
+                    sepia_image = np.clip(sepia_image * (1 + sepia_depth / 100), 0, 1)
+                    sepia_image = (sepia_image * 255).astype(np.uint8)
+
+                    image = Image.fromarray(sepia_image, mode='RGB')
+
+                    # Step 6: Add vignette effect
+                    width, height = image.size
+                    x = np.linspace(-1, 1, width)
+                    y = np.linspace(-1, 1, height)
+                    xx, yy = np.meshgrid(x, y)
+                    gradient = np.sqrt(xx**2 + yy**2)
+                    mask = (1 - gradient / gradient.max())
+                    mask = np.clip(mask, 0, 1)
+                    mask = mask ** (vignette_strength * 10)  # Adjust strength
+
+                    alpha = (mask * 255).astype(np.uint8)
+                    vignette = Image.fromarray(alpha, mode='L')
+                    image.putalpha(vignette)
+
+                    # Step 7: Add noise
+                    noise_array = np.random.randint(0, noise_level, (height, width), dtype='uint8')
+                    noise_image = Image.fromarray(noise_array, mode='L')
+                    noise_image = noise_image.convert('RGBA')
+
+                    # Combine image and noise
+                    r, g, b, a = image.split()
+                    noise_r, noise_g, noise_b, noise_a = noise_image.split()
+
+                    r = ImageChops.add(r, noise_r)
+                    g = ImageChops.add(g, noise_g)
+                    b = ImageChops.add(b, noise_b)
+
+                    image = Image.merge('RGBA', (r, g, b, a))
+
+                    # Step 8: Remove alpha channel if necessary
+                    image = image.convert("RGB")
+
+                    # Check processing time
+                    processing_time = time.time() - start_time
+                    if processing_time > 30:
+                        raise TimeoutError("Processing timed out. Please try again with a smaller image size.")
+
+                    return image
+
+                # Apply the effect
+                output_image = apply_unique_effect(
+                    input_image,
+                    seed,
+                    contrast_factor,
+                    brightness_factor,
+                    sharpness_factor,
+                    sepia_depth,
+                    vignette_strength,
+                    noise_level
+                )
+
+                # Check total processing time
+                total_time = time.time() - start_time
+                st.write(f"Processing Time: {total_time:.2f} seconds")
+
+                st.image(output_image, caption='Transformed Image', use_column_width=True)
+
+                # Download button
+                buffered = io.BytesIO()
+                output_image.save(buffered, format="PNG")
+                img_data = buffered.getvalue()
+
+                st.download_button(
+                    label="Download Image",
+                    data=img_data,
+                    file_name="transformed_image.png",
+                    mime="image/png"
+                )
+            except TimeoutError as e:
+                st.error(str(e))
+
+
+# Original Concept Explanation
+markdown_text = """
+# Unique Generative Photo Editor
+
+This application allows you to apply unique, artistic effects to your images, emulating a vintage style. Each image transformation is guaranteed to be unique due to the use of a random seed, ensuring that the same effect cannot be reproduced.
+
+## Features
+
+- **Uniqueness Guaranteed:** Uses a random seed for each transformation, so every image is one-of-a-kind.
+- **User Control:** Adjust various parameters like image scale, contrast, brightness, sharpness, sepia depth, vignette strength, and noise level to customize the effect.
+- **Vintage Effects:** Emulates the ambiance of classic photography techniques through digital image processing.
+
+## How to Use
+
+1. **Upload an Image:** Select the image you want to transform.
+2. **Adjust Parameters:** Use the sliders to fine-tune the effects to your liking.
+3. **Unique Seed Generation:** A unique seed value is generated for each transformation to ensure uniqueness.
+4. **Image Processing:** The app applies the effects based on your settings and the unique seed.
+5. **View and Download:** Preview the transformed image and download it if you're satisfied.
+
+## Notes
+
+- The uniqueness of each image is based on the random seed and your chosen parameters.
+- Images are processed locally and are not saved on the server.
+- Experiment with different settings to create your own unique piece of art.
+
+## Reference
+
+[1] Chinatsu Ozawa, Tatsuya Minagawa, and Yoichi Ochiai. 2024. Can AI Generated Ambrotype Chain the Aura of Alternative Process? In *SIGGRAPH Asia 2024 Art Papers (SA Art Papers '24)*, December 03–06, 2024, Tokyo, Japan. ACM, New York, NY, USA, 13 Pages. [https://doi.org/10.1145/3680530.3695434](https://doi.org/10.1145/3680530.3695434)
+"""
+
+# Display the Markdown Explanation
+st.markdown(markdown_text)