Wrapping up documentation, copy

.gitignore

@@ -261,7 +261,7 @@ venv.bak/
 
 # Assets and images generated 
 run_*/
-
+pages_draft/*
 
 # Spyder project settings
 .spyderproject

README.md

@@ -11,128 +11,98 @@ license: mit
 short_description: Generate an ugly hold
 ---
 
-## Project: Fireworks Model Comparison App
+🎉 **Ugly Holiday Card Generator** 🎉
 
-### Overview
-The **Fireworks Model Comparison App** is an interactive tool built using **Streamlit** that allows users to compare various Large Language Models (LLMs) hosted on **Fireworks AI**. Users can adjust key model parameters, provide custom prompts, and generate model outputs to compare their behavior and responses. Additionally, an LLM-as-a-Judge feature is available to evaluate the generated outputs and provide feedback on their quality.
+👋 **Welcome to the Ugly Holiday Card Generator!** 🎄❄️
 
+This fun and festive app allows you to create your own ugly holiday cards using AI-generated borders, custom messages, and creative controls to make your card as unique (and ugly!) as possible. Powered by Flux models on Fireworks AI, this app helps you get creative with your holiday greetings. 🎅🎁✨
 
-### Objectives
-- **Compare Models**: Select different models from the Fireworks platform and compare their outputs based on a shared prompt.
-- **Modify Parameters**: Fine-tune parameters such as **Max Tokens**, **Temperature**, **Top-p**, and **Top-k** to observe how they influence model behavior.
-- **Evaluate Using LLM-as-a-Judge**: After generating responses, use a separate model to act as a judge and evaluate the outputs from the selected models.
-  
+## 🎯 **Project: Ugly Holiday Card Generator**
 
-![Home Page Screenshot](img/home_page_1.png)
-![Home Page Screenshot](img/home_page_2.png)
+### 🛠️ **Overview**
+The **Ugly Holiday Card Generator** is an interactive tool built with **Streamlit** that allows users to upload images, adjust parameters, and generate customized holiday cards with AI-generated borders. Whether you want to add snowflakes, Christmas lights, or even fireworks, this app lets you craft the perfect holiday card to share with your friends and family! 🌟
 
+### 🎨 **Features**
+- **Custom Borders**: Choose from a variety of holiday-themed prompts like festive snowflakes, cozy fireplaces, and colorful fireworks! Or create your own custom border prompt! 🖼️🎆
+- **Crop It**: Adjust your image’s crop to focus on the best part of your photo. ✂️
+- **Personalized Message**: Add your own holiday message in different fonts and sizes to give it that final personal touch. ✏️💌
+- **Save & Download**: Easily download your masterpiece with just a click and share it with the world! 🌍🎁
 
-### Features
-- **Streamlit UI**: A simple and intuitive interface where users can select models, input prompts, and adjust model parameters.
-- **LLM Comparison**: Select up to three different models, run a query with the same prompt, and view side-by-side responses.
-- **Parameter Exploration**: Explore and modify different parameters such as Max Tokens, Temperature, Top-p, and more to see how they affect the model's response.
-- **LLM-as-a-Judge**: Let another LLM compare the generated responses from the models and provide a comparison.
+### 📝 **App Structure**
+The app is divided into two parts:
 
-### App Structure
-The app consists of two main pages:
-1. **Comparing LLMs**:
-   - Compare the outputs of three selected LLMs from Fireworks AI by providing a prompt.
-   - View the responses side-by-side for easy comparison.
-   - A selected LLM acts as a judge to evaluate the generated responses.
+1. **Prompt & Parameter Ideation**:
+   - Select or enter custom prompts for your holiday card's border.
+   - Adjust advanced parameters like **guidance scale** and **inference steps** to fine-tune your card.
+   - Crop your image and preview your card before moving to the final stage. 🎄📸
 
+2. **Personalization & Message Customization**:
+   - Add a custom holiday message with a variety of fonts and sizes.
+   - View the final card with your personalized message and download it in PNG format. 🖼️💌
 
-![Home Page Screenshot](img/page_1_empty.png)
-![Home Page Screenshot](img/page_1_a.png)
-![Home Page Screenshot](img/page_1_b.png)
-![Home Page Screenshot](img/page_1_c.png)
+### 💻 **Setup and Installation**
 
-   
-2. **Parameter Exploration**:
-   - Modify various parameters for the LLMs (e.g., Max Tokens, Temperature, Top-p) and observe how they affect the outputs.
-   - Compare three different outputs generated with varying parameter configurations.
-   - Use LLM-as-a-Judge to provide a final evaluation of the outputs.
-
-![Home Page Screenshot](img/page_2_empty.png)
-![Home Page Screenshot](img/page_2_a.png)
-![Home Page Screenshot](img/page_2_b.png)
-![Home Page Screenshot](img/page_2_c.png)
-
-### Setup and Installation
-
-#### Prerequisites
+#### 🚀 **Prerequisites**
 - **Python 3.x** installed on your machine.
 - A **Fireworks AI** API key, which you can obtain by signing up at [Fireworks AI](https://fireworks.ai).
 - Install **Streamlit** and the **Fireworks Python Client**.
 
-#### Step-by-Step Setup
-##### 1. Clone the Repository:
-   First, clone the repository from GitHub:
+#### �� **Step-by-Step Setup**
 
+1. **Clone the Repository**:
    ```bash
    git clone https://github.com/fw-ai/examples.git
    ```
 
-##### 2. Navigate to the Specific Project Sub-directory:
-   After cloning the repository, navigate to the `project_llm-as-a-judge-streamlit-dashboard` sub-directory:
-
+2. **Navigate to the Specific Project Sub-directory**:
    ```bash
-   cd learn/inference/project_llm-as-a-judge-streamlit-dashboard
+   cd learn/inference/ugly-holiday-card-generator
    ```
 
-##### 3. Set up a Virtual Environment (Optional but Recommended):
-   Create and activate a Python virtual environment:
-
+3. **Set up a Virtual Environment** (Optional but Recommended):
    ```bash
    python3 -m venv venv
    source venv/bin/activate  # On macOS/Linux
    .\venv\Scripts\activate  # On Windows
    ```
 
-##### 4. Install Required Dependencies:
-   Install the necessary Python dependencies using `pip3`:
-
+4. **Install Required Dependencies**:
    ```bash
-   pip3 install -r requirements.txt
+   pip install -r requirements.txt
    ```
 
-##### 5. Configure the `.env` File:
-   Copy the `.env.template` file and rename it to `.env` in the same project directory:
-
+5. **Configure the `.env` File**:
+   Copy the `.env.template` file and rename it to `.env` in the project directory:
    ```bash
-   mkdir env/
    cp .env.template env/.env
    ```
-
-   Open the `.env` file and add your **FIREWORKS_API_KEY**:
-
+   Add your **FIREWORKS_API_KEY**:
    ```bash
    FIREWORKS_API_KEY=<your_fireworks_api_key>
    ```
 
-##### 6. Run the Streamlit App:
-   Finally, run the Streamlit app:
-
+6. **Run the Streamlit App**:
    ```bash
-   streamlit run home.py
+   streamlit run app.py
    ```
 
+7. **Explore the App**:
+   - Open the app in your browser via the URL provided by Streamlit (typically `http://localhost:8501`).
+   - Navigate between the prompt ideation and message customization stages. ✨🎨
 
-##### 7. **Explore the app**:
-    - Open the app in your browser via the URL provided by Streamlit (typically `http://localhost:8501`).
-    - Navigate between the pages to compare models and adjust parameters.
+### 📝 **Example Prompts**
+Here are some example holiday prompts to try in the app:
+- "A border of festive snowflakes and winter patterns"
+- "A border of cozy Christmas ornaments and lights"
+- "A border of New Year's Eve fireworks with stars and confetti"
 
-### Example Prompts
-Here are some example prompts you can try in the app:
-- **Prompt 1**: "Describe the future of AI in 500 words."
-- **Prompt 2**: "Write a short story about a time traveler who visits ancient Rome."
-- **Prompt 3**: "Explain quantum computing in simple terms."
-- **Prompt 4**: "Generate a recipe for a healthy vegan dinner."
+### 🔗 **Fireworks API Documentation**
+To learn more about querying models and interacting with the Fireworks API, check out the [Fireworks API Documentation](https://docs.fireworks.ai/api-reference).
 
-### Fireworks API Documentation
-To learn more about how to query models and interact with the Fireworks API, visit the [Fireworks API Documentation](https://docs.fireworks.ai/api-reference/post-chatcompletions).
+### 🤝 **Contributing**
+Contributions are welcome! Feel free to fork the repository, make changes, and submit a pull request. 🎨🎄
 
-### Contributing
-We welcome contributions to improve this app! To contribute, fork the repository, make your changes, and submit a pull request.
+### 📝 **License**
+This project is licensed under the MIT License.
 
-### License
-This project is licensed under the MIT License.
+🎁 **Happy Holidays and Enjoy Creating Your Cards!** 🎁

app.py

@@ -1,6 +1,71 @@
 import streamlit as st
 from PIL import Image
 
-# Streamlit UI
-st.title("To be filled in")
-st.write("Blank on purpose")
+
+# Load images
+logo_image = Image.open("img/fireworksai_logo.png")
+parameters_1_image = Image.open("img/parameters_1.png")
+parameters_2_image = Image.open("img/parameters_2.png")
+parameters_3_image = Image.open("img/parameters_3.png")
+parameters_4_image = Image.open("img/parameters_4.png")
+card_with_message_1_image = Image.open("img/card_with_message_1.png")
+card_with_message_2_image = Image.open("img/card_with_message_2.png")
+
+
+
+# Fireworks Logo at the top
+st.image(logo_image)
+
+# Title of the app
+st.title("🎨 Flux Holiday Magic: Custom Card Creator")
+
+
+# Description using Streamlit text and markdown
+st.markdown("""
+Welcome to the ultimate holiday card design experience! 🎄❄️ 
+            
+\n Powered by **Flux models** through **Fireworks API**, this app lets you effortlessly create stunning, personalized holiday cards with just a few clicks. Here’s what you can do:
+""")
+
+# Features list with emojis
+st.markdown("""
+- **Upload Your Image**: Choose any photo as the base for your holiday card.
+- **Crop & Preview**: Fine-tune the area of your image to fit perfectly within the card.
+- **Holiday Borders**: Choose from festive prompts like snowflakes, ornaments, and cozy fireplace scenes to frame your photo.
+- **Add Custom Messages**: Personalize your card with a message, choosing from a variety of fonts and adjustable text sizes.
+- **Advanced Customization**: Take control of parameters like ControlNet conditioning, guidance scale, inference steps, and more for tailored results.
+- **Save & Share**: Download your final creations or save them for later in a handy ZIP file.
+            
+And be sure to share with us on social!
+            
+![Holiday Vibes](https://i.giphy.com/media/v1.Y2lkPTc5MGI3NjExMXo5Y3RhOGNzaTkzZHFmandsZmF0MW9jNHN4M3VjMjdpOGhyYnRxMSZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/637gfK5GJdv552H9ab/giphy.gif)
+""")
+
+# Call to action
+st.markdown("""
+Get started now and add a magical touch to your holiday greetings! 🎅🌟
+""")
+
+st.divider()
+st.subheader("Experiment with Flux to figure out the perfect look for your holiday card")
+st.markdown(""" ![For science!](https://i.giphy.com/media/v1.Y2lkPTc5MGI3NjExbGwwdGh4czc3bnU3czNzaWRhaXl4YXYzdm53Nmw1OXhpd2E4emFuYSZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/RdJIM4Uesg37eN1ZNL/giphy.gif)""")
+col1, col2 = st.columns(2)
+
+with col1:
+    st.image(parameters_1_image)
+    st.image(parameters_3_image)
+
+with col2:
+    st.image(parameters_2_image)
+    st.image(parameters_4_image)
+
+
+
+st.divider()
+st.subheader("Customize your holiday card with a special message")
+st.markdown(""" ![Special message, so special](https://i.giphy.com/media/v1.Y2lkPTc5MGI3NjExenVkdmZzZTdxNjIxcDk2b2NrdXUxbDBneTNqdHUyamFxNTQzd2dleiZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/qDJSK8oxEkBV0XJE7B/giphy.gif)""")
+col3, col4 = st.columns(2)
+with col3:
+    st.image(card_with_message_1_image)
+with col4:
+    st.image(card_with_message_2_image)

pages/1_Autocenter_HolidayCard.py

@@ -1,178 +0,0 @@
-import streamlit as st
-import cv2
-import requests
-from io import BytesIO
-from PIL import Image, ImageDraw
-import numpy as np
-import os
-from dotenv import load_dotenv
-
-# Load environment variables
-dotenv_path = os.path.join(os.path.dirname(__file__), '../env/.env')
-load_dotenv(dotenv_path, override=True)
-api_key = os.getenv("FIREWORKS_API_KEY")
-
-if not api_key:
-    st.error("API key not found. Make sure FIREWORKS_API_KEY is set in the .env file.")
-    st.stop()
-
-VALID_ASPECT_RATIOS = {
-    (1, 1): "1:1", (21, 9): "21:9", (16, 9): "16:9", (3, 2): "3:2", (5, 4): "5:4",
-    (4, 5): "4:5", (2, 3): "2:3", (9, 16): "9:16", (9, 21): "9:21",
-}
-
-def get_closest_aspect_ratio(width, height):
-    aspect_ratio = width / height
-    closest_ratio = min(VALID_ASPECT_RATIOS.keys(), key=lambda x: abs((x[0] / x[1]) - aspect_ratio))
-    return VALID_ASPECT_RATIOS[closest_ratio]
-
-def process_image(uploaded_image):
-    image = np.array(Image.open(uploaded_image).convert('L'))
-    edges = cv2.Canny(image, 100, 200)
-    edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
-    pil_image = Image.fromarray(edges_rgb)
-    byte_arr = BytesIO()
-    pil_image.save(byte_arr, format='JPEG')
-    byte_arr.seek(0)
-    return byte_arr, pil_image
-
-def call_control_net_api(uploaded_image, prompt, control_mode=0, guidance_scale=3.5, num_inference_steps=30, seed=0, controlnet_conditioning_scale=1.0):
-    control_image, processed_image = process_image(uploaded_image)
-    files = {'control_image': ('control_image.jpg', control_image, 'image/jpeg')}
-    original_image = Image.open(uploaded_image)
-    width, height = original_image.size
-    aspect_ratio = get_closest_aspect_ratio(width, height)
-    data = {
-        'prompt': prompt,
-        'control_mode': control_mode,
-        'aspect_ratio': aspect_ratio,
-        'guidance_scale': guidance_scale,
-        'num_inference_steps': num_inference_steps,
-        'seed': seed,
-        'controlnet_conditioning_scale': controlnet_conditioning_scale
-    }
-    headers = {
-        'accept': 'image/jpeg',
-        'authorization': f'Bearer {api_key}',
-    }
-    response = requests.post('https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/flux-1-dev-controlnet-union/control_net', 
-                             files=files, data=data, headers=headers)
-    if response.status_code == 200:
-        return Image.open(BytesIO(response.content)), processed_image, original_image
-    else:
-        st.error(f"Request failed with status code: {response.status_code}, Response: {response.text}")
-        return None, None, None
-
-def draw_crop_preview(image, x, y, width, height):
-    draw = ImageDraw.Draw(image)
-    draw.rectangle([x, y, x + width, y + height], outline="red", width=2)
-    return image
-
-st.title("Holiday Card Generator with ControlNet")
-
-uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
-
-if uploaded_file is not None:
-    original_image = Image.open(uploaded_file)
-    st.image(original_image, caption="Uploaded Image", use_column_width=True)
-
-    img_width, img_height = original_image.size
-
-    col1, col2 = st.columns(2)
-    with col1:
-        x_pos = st.slider("X position", 0, img_width, img_width // 4)
-        crop_width = st.slider("Width", 10, img_width - x_pos, min(img_width // 2, img_width - x_pos))
-    with col2:
-        y_pos = st.slider("Y position", 0, img_height, img_height // 4)
-        crop_height = st.slider("Height", 10, img_height - y_pos, min(img_height // 2, img_height - y_pos))
-
-    preview_image = draw_crop_preview(original_image.copy(), x_pos, y_pos, crop_width, crop_height)
-    st.image(preview_image, caption="Crop Preview", use_column_width=True)
-
-    st.subheader("Set Parameters for Each Holiday Card")
-
-    # Define the list of suggested holiday prompts
-    holiday_prompts = [
-        "A border of Festive snowflakes and winter patterns for a holiday card border",
-        "A border of Joyful Christmas ornaments and lights decorating the edges",
-        "A border of Warm and cozy fireplace scene with stockings and garlands",
-        "A border of Colorful Hanukkah menorahs and dreidels along the border",
-        "A border of New Year's Eve fireworks with stars and confetti framing the image"
-    ]
-
-    # Define input fields for each holiday card's parameters
-    card_params = []
-    for i in range(4):
-        st.write(f"### Holiday Card {i + 1}")
-        
-        # Dropdown to choose a suggested holiday prompt or enter custom prompt
-        selected_prompt = st.selectbox(f"Choose a holiday-themed prompt for Holiday Card {i + 1}", options=["Custom"] + holiday_prompts)
-        custom_prompt = st.text_input(f"Enter custom prompt for Holiday Card {i + 1}", value=f"Custom Prompt {i + 1}") if selected_prompt == "Custom" else selected_prompt
-        
-        # Parameter sliders for each holiday card
-        guidance_scale = st.slider(f"Guidance Scale for Holiday Card {i + 1}", min_value=0.0, max_value=20.0, value=3.5, step=0.1)
-        num_inference_steps = st.slider(f"Number of Inference Steps for Holiday Card {i + 1}", min_value=1, max_value=100, value=30, step=1)
-        seed = st.slider(f"Random Seed for Holiday Card {i + 1}", min_value=0, max_value=1000, value=i * 100)
-        controlnet_conditioning_scale = st.slider(f"ControlNet Conditioning Scale for Holiday Card {i + 1}", min_value=0.0, max_value=1.0, value=0.5, step=0.1)
-        control_mode = st.slider(f"Control Mode for Holiday Card {i + 1}", min_value=0, max_value=2, value=0, help="0: None, 1: Partial, 2: Full")
-        
-        # Save the parameters for each holiday card
-        card_params.append({
-            "prompt": custom_prompt,
-            "guidance_scale": guidance_scale,
-            "num_inference_steps": num_inference_steps,
-            "seed": seed,
-            "controlnet_conditioning_scale": controlnet_conditioning_scale,
-            "control_mode": control_mode
-        })
-
-    # Generate the holiday cards
-    if st.button("Generate Holiday Cards"):
-        with st.spinner("Processing..."):
-            # Create a column layout for displaying cards side by side
-            col1, col2 = st.columns(2)
-            col3, col4 = st.columns(2)
-            columns = [col1, col2, col3, col4]  # To display images in a 2x2 grid
-
-            # Loop through each card's parameters and generate the holiday card
-            for i, params in enumerate(card_params):
-                prompt = params['prompt']
-                guidance_scale = params['guidance_scale']
-                num_inference_steps = params['num_inference_steps']
-                seed = params['seed']
-                controlnet_conditioning_scale = params['controlnet_conditioning_scale']
-                control_mode = params['control_mode']
-                
-                # Generate the holiday card using the current parameters
-                generated_image, processed_image, _ = call_control_net_api(
-                    uploaded_file, prompt, control_mode=control_mode, 
-                    guidance_scale=guidance_scale, num_inference_steps=num_inference_steps,
-                    seed=seed, controlnet_conditioning_scale=controlnet_conditioning_scale
-                )
-
-                if generated_image is not None:
-                    # Resize generated_image to match original_image size
-                    generated_image = generated_image.resize(original_image.size)
-
-                    # Create a copy of the generated image
-                    final_image = generated_image.copy()
-
-                    # Crop the selected portion of the original image
-                    cropped_original = original_image.crop((x_pos, y_pos, x_pos + crop_width, y_pos + crop_height))
-
-                    # Get the size of the cropped image
-                    cropped_width, cropped_height = cropped_original.size
-
-                    # Calculate the center of the generated image
-                    center_x = (final_image.width - cropped_width) // 2
-                    center_y = (final_image.height - cropped_height) // 2
-
-                    # Paste the cropped portion of the original image onto the generated image at the calculated center
-                    final_image.paste(cropped_original, (center_x, center_y))
-
-                    # Display the final holiday card in one of the columns
-                    columns[i].image(final_image, caption=f"Holiday Card {i + 1}", use_column_width=True)
-                else:
-                    st.error(f"Failed to generate holiday card {i + 1}. Please try again.")
-else:
-    st.warning("Please upload an image to get started.")

pages/{2_Multiple_HolidayCard.py → 1_Part_A_-_Experimentation_Station.py}

@@ -6,6 +6,8 @@ from PIL import Image, ImageDraw
 import numpy as np
 import os
 from dotenv import load_dotenv
+import zipfile
+
 
 # Load environment variables
 dotenv_path = os.path.join(os.path.dirname(__file__), '../env/.env')
@@ -68,28 +70,92 @@ def draw_crop_preview(image, x, y, width, height):
     draw.rectangle([x, y, x + width, y + height], outline="red", width=2)
     return image
 
-st.title("Holiday Card Generator with ControlNet")
 
+# Fireworks Logo at the top
+logo_image = Image.open("img/fireworksai_logo.png")
+st.image(logo_image)
+
+st.title("🎨 Holiday Card Generator - Part A: Design & Ideation 🎨")
+st.markdown(
+    """Welcome to the first part of your holiday card creation journey! 🌟 Here, you’ll play around with different styles, prompts, and parameters to design the perfect card border before adding a personal message in Part B. Let your creativity flow! 🎉
+
+### How it works:
+
+1. **🖼️ Upload Your Image:** Choose the image that will be the center of your card.
+2. **✂️ Crop It:** Adjust the crop to highlight the most important part of your image.
+3. **💡 Choose Your Style:** Select from festive border themes or input your own custom prompt to design something unique.
+4. **⚙️ Fine-Tune Parameters:** Experiment with guidance scales, seeds, inference steps, and more for the perfect aesthetic.
+5. **👀 Preview & Download:** See your generated holiday cards, tweak them until they’re just right, and download the final designs and metadata in a neat ZIP file!
+
+Once you’ve got the perfect look, head over to **Part B** to add your personal message and finalize your holiday card! 💌
+
+"""
+)
+
+# Add divider and subheader for uploading section
+st.divider()
+st.subheader("🖼️ Step 1: Upload Your Picture!")
+st.markdown(""" 
+- Click on the **Upload Image** button to select the image you want to feature on your holiday card.  
+- Accepted formats: **JPG** or **PNG**.
+- Once uploaded, your image will appear on the screen—easy peasy!
+""")
+st.write("Upload the image that will be used for generating your holiday card.")
+
+# Initialize session state variables if they don't exist
+if 'uploaded_file' not in st.session_state:
+    st.session_state.uploaded_file = None
+if 'card_params' not in st.session_state:
+    st.session_state.card_params = [{} for _ in range(4)]  # Initialize for 4 cards
+if 'generated_cards' not in st.session_state:
+    st.session_state.generated_cards = [None for _ in range(4)]  # Store generated images and metadata
+
+# File uploader - if a file is uploaded, save it in session_state
 uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
+st.divider()
 
 if uploaded_file is not None:
-    original_image = Image.open(uploaded_file)
+    st.session_state.uploaded_file = uploaded_file  # Save to session state
+
+# Load the image from session state
+if st.session_state.uploaded_file is not None:
+    original_image = Image.open(st.session_state.uploaded_file)
     st.image(original_image, caption="Uploaded Image", use_column_width=True)
 
     img_width, img_height = original_image.size
 
+    # Add a divider and subheader for the crop section
+    st.divider()
+    st.subheader("✂️ Step 2: Crop It Like It's Hot!")
+    st.markdown(""" 
+    - Adjust the **crop** sliders to select the perfect area of your image.  
+    - This cropped section will be the centerpiece of your festive card. 🎨  
+    - A preview will show you exactly how your crop looks before moving to the next step!
+""")
+    st.write("Select the area you want to crop from the original image. This cropped portion will be used in the final card.")
+
     col1, col2 = st.columns(2)
     with col1:
-        x_pos = st.slider("X position", 0, img_width, img_width // 4)
-        crop_width = st.slider("Width", 10, img_width - x_pos, min(img_width // 2, img_width - x_pos))
+        x_pos = st.slider("X position (Left-Right)", 0, img_width, img_width // 4,
+                          help="Move the slider to adjust the crop's left-right position.")
+        crop_width = st.slider("Width", 10, img_width - x_pos, min(img_width // 2, img_width - x_pos),
+                               help="Adjust the width of the crop.")
     with col2:
-        y_pos = st.slider("Y position", 0, img_height, img_height // 4)
-        crop_height = st.slider("Height", 10, img_height - y_pos, min(img_height // 2, img_height - y_pos))
+        y_pos = st.slider("Y position (Up-Down)", 0, img_height, img_height // 4,
+                          help="Move the slider to adjust the crop's up-down position.")
+        crop_height = st.slider("Height", 10, img_height - y_pos, min(img_height // 2, img_height - y_pos),
+                                help="Adjust the height of the crop.")
 
     preview_image = draw_crop_preview(original_image.copy(), x_pos, y_pos, crop_width, crop_height)
     st.image(preview_image, caption="Crop Preview", use_column_width=True)
+    st.divider()
 
-    st.subheader("Set Parameters for Each Holiday Card")
+    st.subheader("⚙️ Step 3: Set Your Festive Border Design with Flux + Fireworks!")
+    st.markdown(""" 
+        - Choose from a selection of holiday-themed borders like **snowflakes**, **Christmas lights**, or even **New Year's Eve fireworks**—all generated through **Flux models on Fireworks!** ✨
+        - Want to get creative? No problem—enter your own **custom prompt** to create a border that's as unique as you are, all powered by **Fireworks' inference API**.
+""")
+    st.write("Customize the parameters for generating each holiday card. Each parameter will influence the final design and style of the card.")
 
     # Define the list of suggested holiday prompts
     holiday_prompts = [
@@ -101,33 +167,49 @@ if uploaded_file is not None:
     ]
 
     # Define input fields for each holiday card's parameters in expanders
-    card_params = []
     for i in range(4):
         with st.expander(f"Holiday Card {i + 1} Parameters"):
             st.write(f"### Holiday Card {i + 1}")
             
+            # Get the card params from session_state if they exist
+            card_params = st.session_state.card_params[i]
+            card_params.setdefault("prompt", f"Custom Prompt {i + 1}")
+            card_params.setdefault("guidance_scale", 3.5)
+            card_params.setdefault("num_inference_steps", 30)
+            card_params.setdefault("seed", i * 100)
+            card_params.setdefault("controlnet_conditioning_scale", 0.5)
+            card_params.setdefault("control_mode", 0)
+            
             # Dropdown to choose a suggested holiday prompt or enter custom prompt
             selected_prompt = st.selectbox(f"Choose a holiday-themed prompt for Holiday Card {i + 1}", options=["Custom"] + holiday_prompts)
-            custom_prompt = st.text_input(f"Enter custom prompt for Holiday Card {i + 1}", value=f"Custom Prompt {i + 1}") if selected_prompt == "Custom" else selected_prompt
+            custom_prompt = st.text_input(f"Enter custom prompt for Holiday Card {i + 1}", value=card_params["prompt"]) if selected_prompt == "Custom" else selected_prompt
             
-            # Parameter sliders for each holiday card
-            guidance_scale = st.slider(f"Guidance Scale for Holiday Card {i + 1}", min_value=0.0, max_value=20.0, value=3.5, step=0.1)
-            num_inference_steps = st.slider(f"Number of Inference Steps for Holiday Card {i + 1}", min_value=1, max_value=100, value=30, step=1)
-            seed = st.slider(f"Random Seed for Holiday Card {i + 1}", min_value=0, max_value=1000, value=i * 100)
-            controlnet_conditioning_scale = st.slider(f"ControlNet Conditioning Scale for Holiday Card {i + 1}", min_value=0.0, max_value=1.0, value=0.5, step=0.1)
-            control_mode = st.slider(f"Control Mode for Holiday Card {i + 1}", min_value=0, max_value=2, value=0, help="0: None, 1: Partial, 2: Full")
+            # Parameter sliders for each holiday card with tooltips
+            guidance_scale = st.slider(f"Guidance Scale for Holiday Card {i + 1}", min_value=0.0, max_value=20.0, value=card_params["guidance_scale"], step=0.1,
+                                       help="Adjusts how strongly the model follows the prompt. Higher values mean stronger adherence to the prompt.")
+            num_inference_steps = st.slider(f"Number of Inference Steps for Holiday Card {i + 1}", min_value=1, max_value=100, value=card_params["num_inference_steps"], step=1,
+                                            help="More inference steps can lead to a higher quality image but will take longer to generate.")
+            seed = st.slider(f"Random Seed for Holiday Card {i + 1}", min_value=0, max_value=1000, value=card_params["seed"],
+                             help="The seed value allows you to recreate the same image each time, or explore variations by changing the seed.")
+            controlnet_conditioning_scale = st.slider(f"ControlNet Conditioning Scale for Holiday Card {i + 1}", min_value=0.0, max_value=1.0, value=card_params["controlnet_conditioning_scale"], step=0.1,
+                                                      help="Controls how much the ControlNet input influences the output. A lower value reduces its influence.")
+            control_mode = st.slider(f"Control Mode for Holiday Card {i + 1}", min_value=0, max_value=2, value=card_params["control_mode"],
+                                     help="Choose how much ControlNet should influence the final image. 0: None, 1: Partial, 2: Full.")
             
-            # Save the parameters for each holiday card
-            card_params.append({
+            # Update session state with the latest parameters
+            st.session_state.card_params[i] = {
                 "prompt": custom_prompt,
                 "guidance_scale": guidance_scale,
                 "num_inference_steps": num_inference_steps,
                 "seed": seed,
                 "controlnet_conditioning_scale": controlnet_conditioning_scale,
                 "control_mode": control_mode
-            })
+            }
+
+    st.divider()  # Add a divider before the "Generate" button
 
     # Generate the holiday cards
+    st.subheader("Just hit play!")
     if st.button("Generate Holiday Cards"):
         with st.spinner("Processing..."):
             # Create a column layout for displaying cards side by side
@@ -135,8 +217,12 @@ if uploaded_file is not None:
             col3, col4 = st.columns(2)
             columns = [col1, col2, col3, col4]  # To display images in a 2x2 grid
 
+            # Store image bytes and metadata in lists
+            image_files = []
+            metadata = []
+
             # Loop through each card's parameters and generate the holiday card
-            for i, params in enumerate(card_params):
+            for i, params in enumerate(st.session_state.card_params):
                 prompt = params['prompt']
                 guidance_scale = params['guidance_scale']
                 num_inference_steps = params['num_inference_steps']
@@ -146,7 +232,7 @@ if uploaded_file is not None:
                 
                 # Generate the holiday card using the current parameters
                 generated_image, processed_image, _ = call_control_net_api(
-                    uploaded_file, prompt, control_mode=control_mode, 
+                    st.session_state.uploaded_file, prompt, control_mode=control_mode, 
                     guidance_scale=guidance_scale, num_inference_steps=num_inference_steps,
                     seed=seed, controlnet_conditioning_scale=controlnet_conditioning_scale
                 )
@@ -171,6 +257,29 @@ if uploaded_file is not None:
                     # Paste the cropped portion of the original image onto the generated image at the calculated center
                     final_image.paste(cropped_original, (center_x, center_y))
 
+                    # Save image to BytesIO
+                    img_byte_arr = BytesIO()
+                    final_image.save(img_byte_arr, format="PNG")
+                    img_byte_arr.seek(0)
+                    image_files.append((f"holiday_card_{i + 1}.png", img_byte_arr))
+
+                    # Store metadata
+                    metadata.append({
+                        "Card": f"Holiday Card {i + 1}",
+                        "Prompt": prompt,
+                        "Guidance Scale": guidance_scale,
+                        "Inference Steps": num_inference_steps,
+                        "Seed": seed,
+                        "ControlNet Conditioning Scale": controlnet_conditioning_scale,
+                        "Control Mode": control_mode
+                    })
+
+                    # Persist image and metadata in session state
+                    st.session_state.generated_cards[i] = {
+                        "image": final_image,
+                        "metadata": metadata[-1]
+                    }
+
                     # Display the final holiday card in one of the columns
                     columns[i].image(final_image, caption=f"Holiday Card {i + 1}", use_column_width=True)
 
@@ -183,6 +292,81 @@ if uploaded_file is not None:
                     columns[i].write(f"**Control Mode:** {control_mode}")
                 else:
                     st.error(f"Failed to generate holiday card {i + 1}. Please try again.")
-else:
-    st.warning("Please upload an image to get started.")
 
+            # Create ZIP file for download
+            if image_files:
+                zip_buffer = BytesIO()
+                with zipfile.ZipFile(zip_buffer, "w") as zf:
+                    # Add images to the ZIP file
+                    for file_name, img_data in image_files:
+                        zf.writestr(file_name, img_data.getvalue())
+                    
+                    # Add metadata to the ZIP file
+                    metadata_str = "\n\n".join([f"{m['Card']}:\nPrompt: {m['Prompt']}\nGuidance Scale: {m['Guidance Scale']}\nInference Steps: {m['Inference Steps']}\nSeed: {m['Seed']}\nControlNet Conditioning Scale: {m['ControlNet Conditioning Scale']}\nControl Mode: {m['Control Mode']}" for m in metadata])
+                    zf.writestr("metadata.txt", metadata_str)
+
+                zip_buffer.seek(0)
+                st.subheader("Step 4: Download & Share Your Masterpiece! 📥")
+                st.markdown(""" 
+                - Once you're happy with your card, simply hit the download button to save your card and message as a **PNG** image.
+                - You can also view and download any **previously generated holiday cards** from this session!
+                            """)
+                st.download_button(
+                    label="Download all images and metadata as ZIP",
+                    data=zip_buffer,
+                    file_name="holiday_cards.zip",
+                    mime="application/zip"
+                )
+
+# Display previously generated cards if they exist and create a ZIP download button
+st.divider()
+st.subheader("Previously Generated Holiday Cards")
+if any(st.session_state.generated_cards):
+    col1, col2 = st.columns(2)
+    col3, col4 = st.columns(2)
+    columns = [col1, col2, col3, col4]  # Display in 2x2 grid
+
+    image_files = []
+    metadata = []  # Ensure metadata is initialized as a list
+
+    # Loop through previously generated cards
+    for i, card in enumerate(st.session_state.generated_cards):
+        if card and "metadata" in card:  # Ensure the card exists and has metadata
+            columns[i].image(card['image'], caption=f"Holiday Card {i + 1} (Saved)")
+            card_metadata = card['metadata']  # Retrieve the metadata for the current card
+            columns[i].write(f"**Prompt:** {card_metadata['Prompt']}")
+            columns[i].write(f"**Guidance Scale:** {card_metadata['Guidance Scale']}")
+            columns[i].write(f"**Inference Steps:** {card_metadata['Inference Steps']}")
+            columns[i].write(f"**Seed:** {card_metadata['Seed']}")
+            columns[i].write(f"**ControlNet Conditioning Scale:** {card_metadata['ControlNet Conditioning Scale']}")
+            columns[i].write(f"**Control Mode:** {card_metadata['Control Mode']}")
+
+            # Add each image and its metadata to prepare for ZIP download
+            img_byte_arr = BytesIO()
+            card['image'].save(img_byte_arr, format="PNG")
+            img_byte_arr.seek(0)
+            image_files.append((f"holiday_card_{i + 1}.png", img_byte_arr))
+            metadata.append(card_metadata)  # Append card's metadata to the metadata list
+
+    # Provide a ZIP download button for previously generated cards
+    if image_files:
+        zip_buffer = BytesIO()
+        with zipfile.ZipFile(zip_buffer, "w") as zf:
+            # Add images to the ZIP file
+            for file_name, img_data in image_files:
+                zf.writestr(file_name, img_data.getvalue())
+
+            # Add metadata to the ZIP file
+            metadata_str = "\n\n".join([f"{m['Card']}:\nPrompt: {m['Prompt']}\nGuidance Scale: {m['Guidance Scale']}\nInference Steps: {m['Inference Steps']}\nSeed: {m['Seed']}\nControlNet Conditioning Scale: {m['ControlNet Conditioning Scale']}\nControl Mode: {m['Control Mode']}" for m in metadata])
+            zf.writestr("metadata.txt", metadata_str)
+
+# """         zip_buffer.seek(0)
+#         st.divider()
+#         st.subheader("Save images & metadata")
+#         st.download_button(
+#             label="Download all previously generated images and metadata as ZIP",
+#             data=zip_buffer,
+#             file_name="holiday_cards.zip",
+#             mime="application/zip"
+#         )
+#  """

pages/2_Customize_HolidayCard.py

@@ -1,322 +0,0 @@
-import streamlit as st
-import cv2
-import requests
-from io import BytesIO
-from PIL import Image, ImageDraw, ImageFont
-import numpy as np
-import os
-from dotenv import load_dotenv
-from datetime import datetime
-import json
-
-# Load environment variables
-dotenv_path = os.path.join(os.path.dirname(__file__), '../env/.env')
-load_dotenv(dotenv_path, override=True)
-api_key = os.getenv("FIREWORKS_API_KEY")
-
-if not api_key:
-    st.error("API key not found. Make sure FIREWORKS_API_KEY is set in the .env file.")
-    st.stop()
-
-VALID_ASPECT_RATIOS = {
-    (1, 1): "1:1", (21, 9): "21:9", (16, 9): "16:9", (3, 2): "3:2", (5, 4): "5:4",
-    (4, 5): "4:5", (2, 3): "2:3", (9, 16): "9:16", (9, 21): "9:21",
-}
-
-def get_closest_aspect_ratio(width, height):
-    aspect_ratio = width / height
-    closest_ratio = min(VALID_ASPECT_RATIOS.keys(), key=lambda x: abs((x[0] / x[1]) - aspect_ratio))
-    return VALID_ASPECT_RATIOS[closest_ratio]
-
-def create_control_image(original_image, x_pos, y_pos, crop_width, crop_height):
-    cropped_area = original_image.crop((x_pos, y_pos, x_pos + crop_width, y_pos + crop_height))
-    pad_width = int(crop_width * 0.2)
-    pad_height = int(crop_height * 0.2)
-    padded_width = crop_width + 2 * pad_width
-    padded_height = crop_height + 2 * pad_height
-    control_image = Image.new('RGB', (padded_width, padded_height), (128, 128, 128))
-    control_image.paste(cropped_area, (pad_width, pad_height))
-    return control_image
-
-def process_image(image):
-    gray_image = image.convert('L')
-    np_image = np.array(gray_image)
-    edges = cv2.Canny(np_image, 100, 200)
-    edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
-    edge_image = Image.fromarray(edges_rgb)
-    byte_arr = BytesIO()
-    edge_image.save(byte_arr, format='JPEG')
-    byte_arr.seek(0)
-    return byte_arr, edge_image
-
-def call_control_net_api(control_image, prompt, control_mode=0, guidance_scale=3.5, num_inference_steps=30, seed=0, controlnet_conditioning_scale=1.0):
-    processed_image_bytes, processed_image = process_image(control_image)
-    files = {'control_image': ('control_image.jpg', processed_image_bytes, 'image/jpeg')}
-    
-    width, height = control_image.size
-    aspect_ratio = get_closest_aspect_ratio(width, height)
-    
-    data = {
-        'prompt': prompt,
-        'control_mode': control_mode,
-        'aspect_ratio': aspect_ratio,
-        'guidance_scale': guidance_scale,
-        'num_inference_steps': num_inference_steps,
-        'seed': seed,
-        'controlnet_conditioning_scale': controlnet_conditioning_scale
-    }
-    
-    headers = {
-        'accept': 'image/jpeg',
-        'authorization': f'Bearer {api_key}',
-    }
-    
-    response = requests.post(
-        'https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/flux-1-dev-controlnet-union/control_net', 
-        files=files, data=data, headers=headers
-    )
-    
-    if response.status_code == 200:
-        return Image.open(BytesIO(response.content)), processed_image
-    else:
-        st.error(f"Request failed with status code: {response.status_code}, Response: {response.text}")
-        return None, None
-
-def draw_crop_preview(image, x, y, width, height):
-    draw = ImageDraw.Draw(image)
-    for i in range(5):  # Draw multiple rectangles for thickness
-        draw.rectangle([x+i, y+i, x+width-i, y+height-i], outline="red")
-    return image
-
-def create_placement_preview(generated_image, original_image, x_pos, y_pos, crop_width, crop_height, final_x_pos, final_y_pos, resize_factor):
-    expand_factor = 1.3
-    new_width = int(original_image.width * expand_factor)
-    new_height = int(original_image.height * expand_factor)
-
-    preview_image = generated_image.resize((new_width, new_height)).copy()
-    draw = ImageDraw.Draw(preview_image)
-
-    # Try to load a bold font, fall back to default if not available
-    try:
-        font = ImageFont.truetype("arialbd.ttf", 60)  # Trying to use Arial Bold with larger size
-    except IOError:
-        try:
-            font = ImageFont.truetype("arial.ttf", 60)  # Fallback to regular Arial
-        except IOError:
-            font = ImageFont.load_default()
-
-    # Function to draw text with background
-    def draw_text_with_background(draw, text, position, font, text_color, bg_color):
-        text_bbox = draw.textbbox(position, text, font=font)
-        draw.rectangle(text_bbox, fill=bg_color)
-        draw.text(position, text, font=font, fill=text_color)
-
-    # Draw rule of thirds lines with labels
-    for i in range(1, 3):
-        x = new_width * i // 3
-        y = new_height * i // 3
-        draw.line([(x, 0), (x, new_height)], fill=(255, 255, 0), width=5)  # Even thicker vertical lines
-        draw.line([(0, y), (new_width, y)], fill=(255, 255, 0), width=5)  # Even thicker horizontal lines
-        
-        # Add labels with background
-        draw_text_with_background(draw, f"{i/3:.2f}", (x + 10, 20), font, (0, 0, 0), (255, 255, 255, 180))
-        draw_text_with_background(draw, f"{i/3:.2f}", (20, y + 10), font, (0, 0, 0), (255, 255, 255, 180))
-
-    # Draw center crosshair
-    center_x, center_y = new_width // 2, new_height // 2
-    crosshair_size = min(new_width, new_height) // 15
-    draw.line([(center_x - crosshair_size, center_y), (center_x + crosshair_size, center_y)], fill=(0, 255, 255), width=5)
-    draw.line([(center_x, center_y - crosshair_size), (center_x, center_y + crosshair_size)], fill=(0, 255, 255), width=5)
-    draw_text_with_background(draw, "0.50", (center_x + 10, center_y + 10), font, (0, 0, 0), (255, 255, 255, 180))
-
-    # Add more position indicators
-    for i in range(0, 11):
-        x = new_width * i // 10
-        y = new_height * i // 10
-        if i % 5 != 0:  # Skip 0, 0.5, and 1 as they're already marked
-            draw_text_with_background(draw, f"{i/10:.2f}", (x + 10, 20), font, (0, 0, 0), (255, 255, 255, 180))
-            draw_text_with_background(draw, f"{i/10:.2f}", (20, y + 10), font, (0, 0, 0), (255, 255, 255, 180))
-
-    # Crop and resize the original image
-    cropped_original = original_image.crop((x_pos, y_pos, x_pos + crop_width, y_pos + crop_height))
-    new_crop_width = int(crop_width * resize_factor)
-    new_crop_height = int(crop_height * resize_factor)
-    cropped_original = cropped_original.resize((new_crop_width, new_crop_height), Image.LANCZOS)
-    
-    # Calculate paste position
-    paste_x = int(final_x_pos * new_width)
-    paste_y = int(final_y_pos * new_height)
-    
-    # Paste the cropped and resized original onto the preview
-    preview_image.paste(cropped_original, (paste_x, paste_y))
-    
-    # Draw a border around the pasted area
-    for i in range(5):  # Draw multiple rectangles for thickness
-        draw.rectangle([paste_x+i, paste_y+i, paste_x+new_crop_width-i, paste_y+new_crop_height-i], outline=(255, 0, 0), width=2)
-
-    return preview_image
-
-def create_final_image(original_image, generated_image, x_pos, y_pos, crop_width, crop_height, final_x_pos, final_y_pos, resize_factor):
-    expand_factor = 1.3
-    new_width = int(original_image.width * expand_factor)
-    new_height = int(original_image.height * expand_factor)
-
-    final_image = generated_image.resize((new_width, new_height))
-    paste_x = int(final_x_pos * new_width)
-    paste_y = int(final_y_pos * new_height)
-    cropped_original = original_image.crop((x_pos, y_pos, x_pos + crop_width, y_pos + crop_height))
-    new_crop_width = int(crop_width * resize_factor)
-    new_crop_height = int(crop_height * resize_factor)
-    cropped_original = cropped_original.resize((new_crop_width, new_crop_height), Image.LANCZOS)
-    final_image.paste(cropped_original, (paste_x, paste_y))
-
-    return final_image
-
-def create_run_folder():
-    folder_name = f"run_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-    full_path = os.path.join(os.path.dirname(__file__), folder_name)
-    os.makedirs(full_path, exist_ok=True)
-    return full_path
-
-def save_results(folder, original, generated, control, composite, metadata):
-    original.save(os.path.join(folder, "original.png"))
-    generated.save(os.path.join(folder, "generated.png"))
-    control.save(os.path.join(folder, "control.png"))
-    composite.save(os.path.join(folder, "composite.png"))
-    with open(os.path.join(folder, "metadata.json"), 'w') as f:
-        json.dump(metadata, f, indent=4)
-
-# Streamlit UI
-st.title("Holiday Card Generator with ControlNet")
-
-uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
-
-if uploaded_file is not None:
-    original_image = Image.open(uploaded_file)
-    st.image(original_image, caption="Uploaded Image", use_column_width=True)
-
-    img_width, img_height = original_image.size
-
-    st.subheader("Crop Selection")
-    col1, col2 = st.columns(2)
-    with col1:
-        x_pos = st.slider("X position", 0, img_width, img_width // 4)
-        crop_width = st.slider("Width", 10, img_width - x_pos, min(img_width // 2, img_width - x_pos))
-    with col2:
-        y_pos = st.slider("Y position", 0, img_height, img_height // 4)
-        crop_height = st.slider("Height", 10, img_height - y_pos, min(img_height // 2, img_height - y_pos))
-
-    preview_image = draw_crop_preview(original_image.copy(), x_pos, y_pos, crop_width, crop_height)
-    st.image(preview_image, caption="Crop Preview", use_column_width=True)
-
-    holiday_prompts = [
-        "A border of Festive snowflakes and winter patterns for a holiday card border",
-        "A border of Joyful Christmas ornaments and lights decorating the edges",
-        "A border of Warm and cozy fireplace scene with stockings and garlands",
-        "A border of Colorful Hanukkah menorahs and dreidels along the border",
-        "A border of New Year's Eve fireworks with stars and confetti framing the image"
-    ]
-
-    selected_prompt = st.selectbox("Choose a holiday-themed prompt or enter your own", options=["Custom"] + holiday_prompts)
-    custom_prompt = st.text_input("Enter your custom prompt") if selected_prompt == "Custom" else ""
-    prompt = custom_prompt if selected_prompt == "Custom" else selected_prompt
-
-    with st.expander("Advanced Parameters"):
-        control_mode = st.slider("Control Mode", min_value=0, max_value=2, value=0)
-        controlnet_conditioning_scale = st.slider("ControlNet Conditioning Scale", min_value=0.0, max_value=1.0, value=0.5, step=0.1)
-        guidance_scale = st.slider("Guidance Scale", min_value=0.0, max_value=20.0, value=3.5, step=0.1)
-        num_inference_steps = st.slider("Number of Inference Steps", min_value=1, max_value=100, value=30, step=1)
-        seed = st.slider("Random Seed", min_value=0, max_value=1000, value=0)
-
-    if st.button("Generate Flux Image"):
-        if not prompt.strip():
-            st.error("Please enter a prompt.")
-        else:
-            with st.spinner("Generating Flux image..."):
-                control_image = create_control_image(original_image, x_pos, y_pos, crop_width, crop_height)
-                st.image(control_image, caption="Control Image (Cropped and Padded)", use_column_width=True)
-
-                generated_image, processed_image = call_control_net_api(
-                    control_image, prompt, control_mode=control_mode, 
-                    guidance_scale=guidance_scale, num_inference_steps=num_inference_steps,
-                    seed=seed, controlnet_conditioning_scale=controlnet_conditioning_scale
-                )
-
-                if generated_image is not None:
-                    with st.expander("Edge Detection Result (Input to ControlNet)"):
-                        st.image(processed_image, caption="Processed Edge Detection Image", use_column_width=True)
-
-                    st.session_state.generated_image = generated_image
-                    st.session_state.control_image = control_image
-                    st.image(generated_image, caption="Generated Flux Image", use_column_width=True)
-                    st.success("Flux image generated successfully! Now you can choose the final placement and size.")
-                else:
-                    st.error("Failed to generate image. Please try again.")
-
-    if 'generated_image' in st.session_state:
-        st.subheader("Final Image Placement and Sizing")
-        
-        # Radio button for centering or manual position
-        placement_option = st.radio(
-            "Choose placement mode:",
-            ("Manual Position", "Auto Center")
-        )
-        
-        # Resize factor (applied in both modes)
-        resize_factor = st.slider("Resize factor", 0.1, 2.0, 1.0, 0.1, 
-                                help="1.0 is original size, <1 is smaller, >1 is larger")
-
-        # Get dimensions of generated image and resized cropped image
-        generated_width, generated_height = st.session_state.generated_image.size
-        crop_width_resized = int(crop_width * resize_factor)
-        crop_height_resized = int(crop_height * resize_factor)
-        
-        if placement_option == "Manual Position":
-            # Manual position: User selects final X & Y
-            col3, col4, col5 = st.columns(3)
-            with col3:
-                final_x_pos = st.slider("Final X position", 0.0, 1.0, 0.5, 0.01, 
-                                        help="0 is left, 1 is right")
-            with col4:
-                final_y_pos = st.slider("Final Y position", 0.0, 1.0, 0.5, 0.01, 
-                                        help="0 is top, 1 is bottom")
-        else:
-            # Auto-center: Calculate center positions, adjusting for the resized cropped image dimensions
-            final_x_pos = (generated_width - crop_width_resized) / 2 / generated_width
-            final_y_pos = (generated_height - crop_height_resized) / 2 / generated_height
-
-        # Generate placement preview with updated final X & Y positions and resize factor
-        placement_preview = create_placement_preview(st.session_state.generated_image, original_image, 
-                                                    x_pos, y_pos, crop_width, crop_height, 
-                                                    final_x_pos, final_y_pos, resize_factor)
-        st.image(placement_preview, caption="Placement and Size Preview (with numbered guidelines)", use_column_width=True)
-        st.info("Yellow lines show the rule of thirds. Cyan crosshair shows the center. White numbers indicate position values. Use these to help position your image.")
-
-
-
-        if st.button("Create Final Holiday Card"):
-            final_image = create_final_image(original_image, st.session_state.generated_image, 
-                                            x_pos, y_pos, crop_width, crop_height, 
-                                            final_x_pos, final_y_pos, resize_factor)
-            st.subheader("Final Holiday Card")
-            st.image(final_image, caption="Holiday Card Image with Custom Placement and Size", use_column_width=True)
-
-            # Save results
-            run_folder = create_run_folder()
-            metadata = {
-                "prompt": prompt,
-                "crop": {"x": x_pos, "y": y_pos, "width": crop_width, "height": crop_height},
-                "placement": {"x": final_x_pos, "y": final_y_pos},
-                "resize_factor": resize_factor,
-                "control_mode": control_mode,
-                "controlnet_conditioning_scale": controlnet_conditioning_scale,
-                "guidance_scale": guidance_scale,
-                "num_inference_steps": num_inference_steps,
-                "seed": seed
-            }
-            save_results(run_folder, original_image, st.session_state.generated_image, 
-                        st.session_state.control_image, final_image, metadata)
-            st.success(f"Results saved in folder: {run_folder}")
-
-else:
-    st.warning("Please upload an image to get started.")

pages/2_Part_B_-_Card_Generator.py

@@ -0,0 +1,338 @@
+import streamlit as st
+import cv2
+import requests
+from io import BytesIO
+from PIL import Image, ImageDraw, ImageFont, ImageFile
+import numpy as np
+import os
+from dotenv import load_dotenv
+import zipfile
+
+# Allow truncated images to be loaded
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+# Load environment variables
+dotenv_path = os.path.join(os.path.dirname(__file__), '../env/.env')
+load_dotenv(dotenv_path, override=True)
+api_key = os.getenv("FIREWORKS_API_KEY")
+
+# Folder to store generated images
+GENERATED_IMAGES_DIR = "generated_images"
+os.makedirs(GENERATED_IMAGES_DIR, exist_ok=True)
+
+if not api_key:
+    st.error("API key not found. Make sure FIREWORKS_API_KEY is set in the .env file.")
+    st.stop()
+
+VALID_ASPECT_RATIOS = {
+    (1, 1): "1:1", (21, 9): "21:9", (16, 9): "16:9", (3, 2): "3:2", (5, 4): "5:4",
+    (4, 5): "4:5", (2, 3): "2:3", (9, 16): "9:16", (9, 21): "9:21",
+}
+
+def get_closest_aspect_ratio(width, height):
+    aspect_ratio = width / height
+    closest_ratio = min(VALID_ASPECT_RATIOS.keys(), key=lambda x: abs((x[0] / x[1]) - aspect_ratio))
+    return VALID_ASPECT_RATIOS[closest_ratio]
+
+def process_image(uploaded_image):
+    image = np.array(Image.open(uploaded_image).convert('L'))
+    edges = cv2.Canny(image, 100, 200)
+    edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
+    pil_image = Image.fromarray(edges_rgb)
+    byte_arr = BytesIO()
+    pil_image.save(byte_arr, format='JPEG')
+    byte_arr.seek(0)
+    return byte_arr, pil_image
+
+def call_control_net_api(uploaded_image, prompt, control_mode=0, guidance_scale=3.5, num_inference_steps=30, seed=0, controlnet_conditioning_scale=1.0):
+    control_image, processed_image = process_image(uploaded_image)
+    files = {'control_image': ('control_image.jpg', control_image, 'image/jpeg')}
+    original_image = Image.open(uploaded_image)
+    width, height = original_image.size
+    aspect_ratio = get_closest_aspect_ratio(width, height)
+    data = {
+        'prompt': prompt,
+        'control_mode': control_mode,
+        'aspect_ratio': aspect_ratio,
+        'guidance_scale': guidance_scale,
+        'num_inference_steps': num_inference_steps,
+        'seed': seed,
+        'controlnet_conditioning_scale': controlnet_conditioning_scale
+    }
+    headers = {
+        'accept': 'image/jpeg',
+        'authorization': f'Bearer {api_key}',
+    }
+    response = requests.post('https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/flux-1-dev-controlnet-union/control_net', 
+                             files=files, data=data, headers=headers)
+    if response.status_code == 200:
+        return Image.open(BytesIO(response.content)), processed_image, original_image
+    else:
+        st.error(f"Request failed with status code: {response.status_code}, Response: {response.text}")
+        return None, None, None
+
+def draw_crop_preview(image, x, y, width, height):
+    draw = ImageDraw.Draw(image)
+    draw.rectangle([x, y, x + width, y + height], outline="red", width=2)
+    return image
+
+def add_message_to_image(image, cropped_bottom_y, message, font_path, font_size):
+    draw = ImageDraw.Draw(image)
+
+    # Try to load the selected font file with user-defined size
+    try:
+        font = ImageFont.truetype(font_path, font_size)
+        st.write(f"Loaded font from {font_path} with font size {font_size}")
+    except IOError as e:
+        st.error(f"Error loading font: {e}. Loading default font.")
+        font = ImageFont.load_default()
+
+    # Calculate the text size dynamically
+    text_bbox = draw.textbbox((0, 0), message, font=font)
+    text_width = text_bbox[2] - text_bbox[0]
+    text_height = text_bbox[3] - text_bbox[1]
+    st.write(f"Text width: {text_width}, Text height: {text_height}")
+
+    # Calculate the space between the bottom of the cropped image and the bottom of the card
+    bottom_space = image.height - cropped_bottom_y
+
+    # Place the text box centered along the Y axis in the bottom space
+    y_position = cropped_bottom_y + (bottom_space - text_height) // 2
+
+    # Position the text box at the center of the width of the image
+    x_position = (image.width - text_width) // 2
+
+    # Define the padding for the text box
+    padding_x = 50  # Adjust the padding width as needed
+    padding_y = 50  # Adjust the padding height as needed
+
+    # Define the text box (background) coordinates with padding
+    box_coords = [
+        x_position - padding_x, y_position - padding_y,
+        x_position + text_width + padding_x, y_position + text_height + padding_y
+    ]
+
+    # Draw a white rectangle as the background for the text box
+    draw.rectangle(box_coords, fill="white")
+
+    # Draw the text in black on top of the white background
+    draw.text((x_position, y_position), message, font=font, fill="black")
+
+    return image
+
+# Define the fonts you want to allow
+fonts = {
+    "DejaVu Sans Bold": "./fonts/dejavu-sans-bold.ttf",
+    "Covered By You": "./fonts/CoveredByYourGrace-Regular.ttf",  # Update this path to your actual font paths
+    "Julee Regular": "./fonts/Julee-Regular.ttf",  # Example font
+    "Kalam Regular": "./fonts/Kalam-Regular.ttf",
+    "Knewave Regular": "./fonts/Knewave-Regular.ttf",
+    "Sancreek Regular": "./fonts/Sancreek-Regular.ttf",
+    "Vast Shadow Regular": "./fonts/VastShadow-Regular.ttf",
+}
+
+# Fireworks Logo at the top
+logo_image = Image.open("img/fireworksai_logo.png")
+st.image(logo_image)
+
+st.title("🎨 Holiday Card Generator - Part B: Finalize Your Holiday Card")
+
+st.markdown("""
+Welcome back! You've already set your favorite parameters, and now it's time to finalize your custom holiday card.
+
+**Steps**:
+1. **Choose a Border**: Select or confirm a holiday-themed border to frame your image—choose from snowflakes, ornaments, cozy fireplaces, and more!
+2. **Add a Personalized Message**: Write your holiday greeting and customize it with font and size options to match your style.
+3. **Review & Download**: Preview your finished card and download it for sharing.
+
+**Features**:
+- Confirm your AI-generated border with your preferred parameters
+- Personalize the message with a variety of fonts and sizes
+- Save your card with metadata for future use
+
+🎁 Get your perfect holiday card ready to share! 🌟
+""")
+
+
+st.divider()
+
+# Initialize session state variables if they don't exist
+if 'uploaded_file' not in st.session_state:
+    st.session_state.uploaded_file = None
+if 'generated_image' not in st.session_state:
+    st.session_state.generated_image = None
+
+# File uploader - if a file is uploaded, save it in session_state
+st.subheader("🖼️ Step 1: Upload Your Picture!")
+st.markdown("""
+- Click on the "Upload Image" button to select the image you want to feature on your holiday card. Make sure it's a **JPG** or **PNG** file.
+- Once uploaded, your image will appear on the screen—easy peasy!
+            """)
+uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
+if uploaded_file is not None:
+    st.session_state.uploaded_file = uploaded_file  # Save to session state
+st.divider()
+
+# Load the image from session state if it exists
+if st.session_state.uploaded_file is not None:
+    try:
+        original_image = Image.open(st.session_state.uploaded_file)
+        st.subheader("Your uploaded image")
+        st.image(original_image, caption="Uploaded Image", use_column_width=True)
+
+        img_width, img_height = original_image.size
+        st.divider()
+
+        st.subheader("✂️ Step 2: Crop It Like It's Hot!")
+        st.markdown("""
+        - Adjust the **crop** sliders to select the perfect area of your image. This cropped section will be the centerpiece of your festive card. 🎨
+        - A preview will show you exactly how your crop looks before moving to the next step!
+                    """)
+        col1, col2 = st.columns(2)
+        with col1:
+            x_pos = st.slider("X position (Left-Right)", 0, img_width, img_width // 4,
+                            help="Move the slider to adjust the crop's left-right position.")
+            crop_width = st.slider("Crop Width", 10, img_width - x_pos, min(img_width // 2, img_width - x_pos),
+                                help="Adjust the width of the crop.")
+        with col2:
+            y_pos = st.slider("Y position (Up-Down)", 0, img_height, img_height // 4,
+                            help="Move the slider to adjust the crop's up-down position.")
+            crop_height = st.slider("Crop Height", 10, img_height - y_pos, min(img_height // 2, img_height - y_pos),
+                                    help="Adjust the height of the crop.")
+
+        preview_image = draw_crop_preview(original_image.copy(), x_pos, y_pos, crop_width, crop_height)
+        st.image(preview_image, caption="Crop Preview", use_column_width=True)
+
+        
+        # Holiday card prompt and parameters
+        st.divider()
+        holiday_prompts = [
+            "A border of Festive snowflakes and winter patterns for a holiday card border",
+            "A border of Joyful Christmas ornaments and lights decorating the edges",
+            "A border of Warm and cozy fireplace scene with stockings and garlands",
+            "A border of Colorful Hanukkah menorahs and dreidels along the border",
+            "A border of New Year's Eve fireworks with stars and confetti framing the image"
+        ]
+        st.subheader("⚙️ Step 3: Design Your Festive Border with Flux + Fireworks!")
+        st.markdown("""
+                    - Choose from a selection of holiday-themed borders like **snowflakes**, **Christmas lights**, or even **New Year's Eve fireworks**—all generated through **Flux models on Fireworks!** ✨
+                    - Want to get creative? No problem—enter your own **custom prompt** to create a border that's as unique as you are, all powered by **Fireworks' inference API**. """)
+        selected_prompt = st.selectbox("Choose a holiday-themed prompt or enter your own", options=["Custom"] + holiday_prompts)
+        custom_prompt = st.text_input("Enter your custom prompt") if selected_prompt == "Custom" else ""
+        prompt = custom_prompt if selected_prompt == "Custom" else selected_prompt
+
+        with st.expander("Advanced Parameters"):
+            control_mode = st.slider("Control Mode", min_value=0, max_value=2, value=0)
+            controlnet_conditioning_scale = st.slider("ControlNet Conditioning Scale", min_value=0.0, max_value=1.0, value=0.5, step=0.1)
+            guidance_scale = st.slider("Guidance Scale", min_value=0.0, max_value=20.0, value=3.5, step=0.1)
+            num_inference_steps = st.slider("Number of Inference Steps", min_value=1, max_value=100, value=30, step=1)
+            seed = st.slider("Random Seed", min_value=0, max_value=1000, value=0)
+
+        if st.button("Generate Holiday Card"):
+            if not prompt.strip():
+                st.error("Please enter a prompt.")
+            else:
+                with st.spinner("Processing..."):
+                    generated_image, processed_image, _ = call_control_net_api(
+                        st.session_state.uploaded_file, prompt, control_mode=control_mode, 
+                        guidance_scale=guidance_scale, num_inference_steps=num_inference_steps,
+                        seed=seed, controlnet_conditioning_scale=controlnet_conditioning_scale
+                    )
+
+                    if generated_image is not None:
+                        # Resize generated_image to match original_image size
+                        generated_image = generated_image.resize(original_image.size)
+
+                        # Create a copy of the generated image
+                        final_image = generated_image.copy()
+
+                        # Crop the selected portion of the original image
+                        cropped_original = original_image.crop((x_pos, y_pos, x_pos + crop_width, y_pos + crop_height))
+
+                        # Get the size of the cropped image
+                        cropped_width, cropped_height = cropped_original.size
+
+                        # Calculate the center of the generated image
+                        center_x = (final_image.width - cropped_width) // 2
+                        center_y = (final_image.height - cropped_height) // 2
+
+                        # Paste the cropped portion of the original image onto the generated image at the calculated center
+                        final_image.paste(cropped_original, (center_x, center_y))
+
+                        # Save the generated image in session state for persistence
+                        st.session_state.generated_image = final_image
+
+                        # Save the image locally
+                        final_image.save(f"{GENERATED_IMAGES_DIR}/holiday_card.png")
+
+                        # Display the final holiday card
+                        st.image(final_image, caption="Final Holiday Card", use_column_width=True)
+                    else:
+                        st.error("Failed to generate holiday card. Please try again.")
+
+        # Add a text box to input a custom message (limit to 280 characters like a tweet)
+        st.divider()
+        if 'generated_image' in st.session_state:
+            st.subheader("✏️ Step 4: Add Your Custom Holiday Message!")
+            st.markdown("""
+                        - Add a fun, heartfelt, or witty holiday message to the bottom of your card. 🎉
+                        - Choose from a variety of **festive fonts** and adjust the **font size** to make your message stand out! 🎅 """)
+
+            # Text input for custom message
+            custom_message = st.text_input("Add a custom holiday message to the card (max 280 characters)", max_chars=280)
+
+            # Font selection dropdown
+            selected_font = st.selectbox("Choose a font for your message", options=list(fonts.keys()))
+
+            # Slider to allow the user to adjust the font size
+            font_size = st.slider("Adjust font size", min_value=10, max_value=200, value=100, step=10)
+
+            # Get the corresponding font path
+            font_path = fonts[selected_font]
+
+            if st.button("Generate Holiday Card with Message"):
+                final_image_with_message = st.session_state.generated_image.copy()
+
+                # Get the dimensions of the cropped image and final image
+                cropped_bottom_y = y_pos + crop_height  # y_pos is the top Y position of the cropped area
+
+                # Add the custom message to the image
+                if custom_message:
+                    final_image_with_message = add_message_to_image(final_image_with_message, cropped_bottom_y, custom_message, font_path, font_size)
+
+                # Display the final holiday card with the message
+                st.image(final_image_with_message, caption="Holiday Card with Custom Message", use_column_width=True)
+
+                # Save image for download
+                img_byte_arr = BytesIO()
+                final_image_with_message.save(img_byte_arr, format="PNG")
+                img_byte_arr.seek(0)
+
+                # Download button for the final image
+                st.divider()
+                st.subheader("📥 Step 5: Download & Share Your Masterpiece!")
+                st.markdown("""
+                            - Once you're happy with your card, simply hit the download button to save your card and message as a PNG image.
+                            - You can also view and download any **previously generated holiday cards** from this session!""")
+                st.download_button(
+                    label="Download Holiday Card with Message",
+                    data=img_byte_arr,
+                    file_name="holiday_card_with_message.png",
+                    mime="image/png"
+                )
+
+                # Save image locally
+                final_image_with_message.save(f"{GENERATED_IMAGES_DIR}/holiday_card_with_message.png", format="PNG")
+    except OSError:
+        st.error("The uploaded image seems to be truncated or corrupted. Please try with a different image.")
+else:
+    st.warning("Please upload an image to get started.")
+
+# Load and display previously generated images
+st.divider()
+st.subheader("Previously Generated Holiday Cards")
+
+saved_image_path = f"{GENERATED_IMAGES_DIR}/holiday_card_with_message.png"
+if os.path.exists(saved_image_path):
+    saved_image = Image.open(saved_image_path)
+    st.image(saved_image, caption="Previously Generated Holiday Card", use_column_width=True)

pages/3_Pure_FLUX_ImageGeneration.py

@@ -1,77 +0,0 @@
-import os
-import requests
-from dotenv import load_dotenv
-from PIL import Image
-from io import BytesIO
-import streamlit as st
-
-# Set page configuration
-st.set_page_config(page_title="FLUX Image Generation Tool", page_icon="🎇")
-
-# Correct the path to the .env file to reflect its location
-dotenv_path = os.path.join(os.path.dirname(__file__), '../env/.env')
-
-# Load environment variables from the .env file
-load_dotenv(dotenv_path, override=True)
-
-# Get the Fireworks API key from the .env file
-fireworks_api_key = os.getenv("FIREWORKS_API_KEY")
-
-if not fireworks_api_key:
-    st.error("API key not found. Make sure FIREWORKS_API_KEY is set in the .env file.")
-
-# Function to make requests to the FLUX models
-def generate_flux_image(model_path, prompt, steps):
-    url = f"https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/{model_path}/text_to_image"
-    headers = {
-        "Authorization": f"Bearer {fireworks_api_key}",
-        "Content-Type": "application/json",
-        "Accept": "image/jpeg"
-    }
-    data = {
-        "prompt": prompt,
-        "aspect_ratio": "16:9",
-        "guidance_scale": 3.5,
-        "num_inference_steps": steps,
-        "seed": 0
-    }
-
-    # Send the request
-    response = requests.post(url, headers=headers, json=data)
-    
-    if response.status_code == 200:
-        # Convert the response to an image
-        img_data = response.content
-        img = Image.open(BytesIO(img_data))
-        return img
-    else:
-        raise RuntimeError(f"Error with FLUX model {model_path}: {response.text}")
-
-# Streamlit UI
-st.title("FLUX Image Generation")
-st.write("Generate images using the FLUX models.")
-
-# User input for the prompt
-prompt = st.text_input("Enter your prompt for image generation:")
-
-# Dropdown to select the model
-model_choice = st.selectbox("Select the model:", ["flux-1-dev", "flux-1-schnell"])
-
-# Button to generate images
-if st.button("Generate Image"):
-    if not prompt.strip():
-        st.error("Please provide a prompt.")
-    else:
-        try:
-            with st.spinner("Generating image..."):
-                # Determine steps based on model
-                steps = 30 if model_choice == "flux-1-dev" else 4
-
-                # Generate image
-                generated_image = generate_flux_image(model_choice, prompt, steps)
-
-                # Display the image
-                st.image(generated_image, caption=f"Generated using {model_choice}", use_column_width=True)
-                
-        except Exception as e:
-            st.error(f"An error occurred: {e}")