Added different variants of card generation

pages/1_Generate_Holiday_Postcard.py

@@ -0,0 +1,195 @@
+import os
+import requests
+from dotenv import load_dotenv
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import streamlit as st
+import textwrap
+
+# 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.")
+
+# Define the fonts you want to allow
+fonts = {
+    "DejaVu Sans Bold": "./fonts/dejavu-sans-bold.ttf",
+    "Covered By You": "./fonts/CoveredByYourGrace-Regular.ttf",
+    "Julee Regular": "./fonts/Julee-Regular.ttf",
+    "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",
+}
+
+# Holiday-themed prompts list
+holiday_prompts = [
+    "A peaceful winter landscape covered in fresh snow, with delicate snowflakes drifting through the air and soft, frosty patterns along the edges, creating a serene holiday card",
+    "A cozy Christmas scene featuring a warmly lit cabin in the woods, surrounded by snow-covered trees and twinkling holiday lights, with a sky glowing softly in the background",
+    "A fireplace with stockings, garlands, and a glowing hearth, set in a cozy room decorated for the holidays, capturing the warmth and tranquility of the season",
+    "A colorful Hanukkah celebration with glowing menorahs, dreidels, and shimmering holiday lights illuminating the night, set against a rich, deep blue backdrop for a festive scene",
+    "A vibrant New Year's Eve cityscape with bright fireworks exploding in the sky, colorful confetti drifting through the air, and stars twinkling above the skyline, radiating excitement",
+    "A mystical Samhain forest scene, with pumpkins glowing softly among tall trees, and a full moon casting light over an ancient Celtic stone circle, evoking an air of magic and mystery",
+    "A lively Día de Muertos altar adorned with colorful calaveras, bright marigold flowers, and glowing candles, set against a traditional Mexican backdrop, celebrating the holiday’s joy",
+    "A wintery Yule forest scene under a starry sky, with snow-covered pine trees, holly bushes, and traditional Norse winter symbols decorating the landscape, capturing the warmth of the season",
+    "A bright and vibrant Diwali celebration with glowing diyas lining a courtyard, intricate rangoli patterns on the ground, and colorful fireworks lighting up the night sky",
+    "A serene Kwanzaa scene featuring a kinara with glowing candles, surrounded by decorations in red, black, and green, set in a peaceful and reflective atmosphere",
+    "A bountiful Thanksgiving table scene set outdoors, surrounded by autumn leaves, pumpkins, and a golden sunset, capturing the essence of gratitude and togetherness",
+    "A tranquil Winter Solstice night with a glowing full moon above, bare trees, stars twinkling in the sky, and a peaceful blanket of snow covering the quiet landscape",
+    "A festive St. Patrick's Day scene featuring a green countryside, with shamrocks covering the rolling hills, a rainbow stretching across the sky, and a pot of gold in the distance",
+    "A colorful Lunar New Year street scene with red lanterns hanging from the rooftops, dragon dancers parading down the street, and vibrant fireworks lighting up the night",
+    "A peaceful Easter garden filled with blooming spring flowers, pastel-colored eggs hidden among the grass, and soft sunlight streaming through the trees",
+    "A romantic Valentine's Day scene with glowing candles, heart-shaped decorations hanging from tree branches, and a soft pink and red sunset in the sky",
+    "A lively Holi celebration in an open field, with bursts of vibrant color powder filling the air, and people joyfully celebrating under a bright blue sky",
+    "A tranquil Ramadan evening scene with a crescent moon and stars hanging in the night sky, glowing lanterns decorating the streets, and peaceful reflections along a quiet river",
+    "A lively Independence Day celebration with colorful fireworks lighting up the night sky, flags waving in the breeze, and a peaceful lakeside reflecting the celebration"
+]
+
+
+
+# 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}")
+
+# Function to wrap text to a specified number of characters
+def wrap_text(text, max_chars):
+    """Wrap text to a specified number of characters per line."""
+    return "\n".join(textwrap.fill(line, width=max_chars) for line in text.split("\n"))
+
+# Function to add the holiday message to the image
+def add_custom_message(image, message, font_path, font_size, position_vertical, position_horizontal, max_chars, bg_color, font_color):
+    try:
+        font = ImageFont.truetype(font_path, font_size)
+    except IOError:
+        font = ImageFont.load_default()
+
+    draw = ImageDraw.Draw(image)
+
+    # Wrap the text based on the max_chars input
+    message = wrap_text(message, max_chars)
+
+    img_width, img_height = image.size
+
+    # Calculate the text bounding box dynamically
+    text_lines = message.split("\n")
+    line_height = draw.textbbox((0, 0), "A", font=font)[3]  # Get height of one line of text (bbox returns top, left, bottom, right)
+    total_text_height = line_height * len(text_lines)
+    text_width = max([draw.textbbox((0, 0), line, font=font)[2] for line in text_lines])
+
+    # Horizontal positioning
+    if position_horizontal == "Left":
+        x_pos = 10  # Padding from the left
+    elif position_horizontal == "Center":
+        x_pos = (img_width - text_width) // 2
+    else:  # "Right"
+        x_pos = img_width - text_width - 10  # Padding from the right
+
+    # Vertical positioning
+    if position_vertical == "Top":
+        y_pos = 10  # Padding from the top
+    elif position_vertical == "Center":
+        y_pos = (img_height - total_text_height) // 2
+    else:  # "Bottom"
+        y_pos = img_height - total_text_height - 10  # Padding from the bottom
+
+    # Define the padding for the background box behind the text
+    padding = 10
+
+    # Draw the background rectangle (the text box) with user-specified background color
+    draw.rectangle([x_pos - padding, y_pos - padding, x_pos + text_width + padding, y_pos + total_text_height + padding], fill=bg_color)
+
+    # Draw the text line by line with the user-specified font color
+    for i, line in enumerate(text_lines):
+        draw.text((x_pos, y_pos + i * line_height), line, font=font, fill=font_color)
+
+    return image
+
+# Streamlit UI
+st.title("FLUX Image Generation")
+st.write("Generate images using the FLUX models and customize them with a holiday message.")
+
+# Dropdown to select a holiday-themed prompt or enter a custom prompt
+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
+
+# Dropdown to select the model
+model_choice = st.selectbox("Select the model:", ["flux-1-dev", "flux-1-schnell"])
+
+# Additional inputs for customizing the message
+message = st.text_input("Enter a holiday message to add:")
+font_choice = st.selectbox("Select a font:", list(fonts.keys()))
+font_size = st.slider("Select font size:", 10, 100, 40)
+max_chars = st.slider("Max characters per line:", 10, 100, 40)  # Slider to select character wrap limit
+
+# Background color and font color pickers
+bg_color = st.color_picker("Pick a background color for the text box:", "#FFFFFF")
+font_color = st.color_picker("Pick a font color:", "#000000")
+
+# Position options for the message (vertical and horizontal)
+position_vertical = st.radio("Select message vertical position:", ["Top", "Center", "Bottom"])
+position_horizontal = st.radio("Select message horizontal position:", ["Left", "Center", "Right"])
+
+# 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)
+
+                # Get the selected font path
+                font_path = fonts[font_choice]
+
+                # Add the holiday message to the generated image
+                image_with_message = add_custom_message(
+                    generated_image.copy(), message, font_path, font_size, 
+                    position_vertical, position_horizontal, max_chars, bg_color, font_color
+                )
+
+                # Display the image with the message
+                st.image(image_with_message, caption=f"Generated using {model_choice} with custom message", use_column_width=True)
+
+                # Preview the placement
+                st.write(f"Message preview (vertical position: {position_vertical}, horizontal position: {position_horizontal}, font: {font_choice}, size: {font_size}, max chars: {max_chars}, bg color: {bg_color}, font color: {font_color})")
+                
+        except Exception as e:
+            st.error(f"An error occurred: {e}")

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

@@ -368,15 +368,4 @@ if any(st.session_state.generated_cards):
 
             # 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"
-#         )
-#  """
+            zf.writestr("metadata.txt", metadata_str)

pages/{2_Part_B_-_Card_Generator.py → 3_Customize_Holiday_Borders.py}

@@ -220,7 +220,7 @@ if st.session_state.uploaded_file is not None:
             "A border of Soyal dancers, sun symbols, and traditional Zuni and Hopi winter motifs to welcome the sun's return",
             "A border of Winter Solstice symbols with bare trees, stars, and the moon against a cold winter night",
             "A border of spooky Halloween elements like pumpkins, bats, ghosts, and cobwebs for a haunted theme",
-            "A border of Thanksgiving harvest items like pumpkins, cornucopias, autumn leaves, and turkeys",
+            "A border of fall harvest items like pumpkins, cornucopias, autumn leaves, and turkeys",
             "A border of Christmas ornaments, wreaths, and lights for a joyful, festive holiday look"
             ]
         st.subheader("⚙️ Step 3: Design Your Festive Border with Flux + Fireworks!")

pages/4_Morph_Holiday_Card.py

@@ -0,0 +1,268 @@
+import streamlit as st
+import cv2
+import requests
+from io import BytesIO
+from PIL import Image, ImageDraw, ImageFont, ImageFilter
+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()
+
+# 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
+if 'control_image' not in st.session_state:
+    st.session_state.control_image = None
+
+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 closest_ratio, VALID_ASPECT_RATIOS[closest_ratio]
+
+def add_padding_to_aspect_ratio(image, target_aspect_ratio):
+    width, height = image.size
+    target_width, target_height = target_aspect_ratio
+
+    if width / height > target_width / target_height:
+        new_height = int(width * target_height / target_width)
+        new_width = width
+    else:
+        new_width = int(height * target_width / target_height)
+        new_height = height
+
+    # Create a new image with the target aspect ratio and paste the original image in the center
+    padded_image = Image.new('RGB', (new_width, new_height), (128, 128, 128))  # Grey padding
+    paste_x = (new_width - width) // 2
+    paste_y = (new_height - height) // 2
+    padded_image.paste(image, (paste_x, paste_y))
+
+    return padded_image
+
+def create_control_image(original_image, x_pos, y_pos, crop_width, crop_height):
+    # Crop the selected area
+    cropped_area = original_image.crop((x_pos, y_pos, x_pos + crop_width, y_pos + crop_height))
+    
+    # Add 20% padding around the cropped area
+    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
+    padded_image = Image.new('RGB', (padded_width, padded_height), (128, 128, 128))  # Grey padding
+    padded_image.paste(cropped_area, (pad_width, pad_height))
+
+    # Adjust the padded image to match the closest valid aspect ratio
+    closest_aspect_ratio, _ = get_closest_aspect_ratio(padded_width, padded_height)
+    control_image = add_padding_to_aspect_ratio(padded_image, closest_aspect_ratio)
+
+    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)[1]
+    
+    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 smooth_edges(image, crop_box, blur_radius=5):
+    # Create a mask for the cropped area
+    mask = Image.new("L", image.size, 0)
+    draw = ImageDraw.Draw(mask)
+    draw.rectangle(crop_box, fill=255)
+    mask = mask.filter(ImageFilter.GaussianBlur(blur_radius))
+    
+    # Create a new image for blending
+    blended_image = Image.composite(image, Image.new("RGB", image.size, (0, 0, 0)), mask)
+    return blended_image
+
+def add_custom_message(image, message, font_path, font_size):
+    # Load a font
+    try:
+        font = ImageFont.truetype(font_path, font_size)
+    except IOError:
+        font = ImageFont.load_default()
+
+    draw = ImageDraw.Draw(image)
+
+    # Calculate the text bounding box 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]
+    img_width, img_height = image.size
+
+    # Center the text
+    x_pos = (img_width - text_width) // 2
+    y_pos = img_height - text_height - 10  # 10 px padding from the bottom
+
+    # Define the padding for the white box
+    padding = 10
+
+    # Draw a white rectangle (the background box) behind the text
+    draw.rectangle([x_pos - padding, y_pos - padding, x_pos + text_width + padding, y_pos + text_height + padding], fill="white")
+
+    # Draw the black text on top of the white box
+    draw.text((x_pos, y_pos), message, font=font, fill="black")
+
+    return image
+
+
+# Define available fonts
+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",
+}
+
+# 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:
+    st.session_state.uploaded_file = uploaded_file  # Save the file to session state
+    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
+
+    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 portrait of a person framed by festive snowflakes and winter patterns, with soft, frosty details along the edges for a holiday card",
+    "A joyful portrait with Christmas ornaments and twinkling lights decorating the borders, framing the person in a warm, festive glow",
+    "A cozy portrait with a fireplace scene, stockings, and garlands along the edges, enhancing the warmth of the person in the center",
+    "A colorful Hanukkah-themed portrait with menorahs, dreidels, and holiday lights framing the person against a rich backdrop",
+    "A New Year's Eve portrait with celebratory fireworks, stars, and confetti surrounding the person, giving an energetic, celebratory vibe",
+    "A mystical portrait framed by Samhain symbols like Celtic knots, pumpkins, and candles, creating an enchanting October atmosphere",
+    "A vibrant Día de Muertos portrait with colorful skulls (calaveras), marigold flowers, and candles framing the subject with traditional flair",
+    "A Yule-themed portrait framed by holly, pine trees, and Norse winter symbols under a starry sky, bringing out the warmth of the subject",
+    "A bright and joyful Diwali portrait with lamps (diyas), intricate rangoli patterns, and lotus flowers framing the person for a festive look",
+    "A cozy winter portrait with Dongzhi Festival glutinous rice balls and family gathering symbols along the edges, giving a homely, warm feeling",
+    "A spiritual portrait framed by Zuni and Hopi winter motifs, including Soyal dancers and sun symbols, welcoming the return of the sun",
+    "A winter solstice portrait with bare trees, stars, and the moon softly framing the person in a serene, cold night atmosphere",
+    "A spooky Halloween-themed portrait framed by pumpkins, bats, ghosts, and cobwebs, adding a playful, haunting edge to the subject",
+    "A harvest-themed portrait surrounded by pumpkins, cornucopias, autumn leaves, and turkeys, capturing the essence of Thanksgiving",
+    "A joyful Christmas portrait framed by ornaments, wreaths, and glowing lights, creating a festive and heartwarming holiday look"
+]
+
+    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)
+
+    custom_message = st.text_input("Enter a custom holiday message to add to the card")
+    
+    # Font selection dropdown and font size slider
+    selected_font = st.selectbox("Choose a font for your message", options=list(fonts.keys()))
+    font_size = st.slider("Font size", 10, 100, 40)
+
+    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:
+                    st.session_state.generated_image = generated_image
+                    st.session_state.control_image = control_image
+
+                    # Add custom message if provided
+                    if custom_message:
+                        font_path = fonts[selected_font]
+                        generated_image_with_message = add_custom_message(generated_image.copy(), custom_message, font_path, font_size)
+                        st.image(generated_image_with_message, caption="Generated Flux Image with Message", use_column_width=True)
+                    else:
+                        st.image(generated_image, caption="Generated Flux Image", use_column_width=True)
+
+                    st.success("Flux image generated successfully!")
+                else:
+                    st.error("Failed to generate image. Please try again.")
+
+else:
+    st.warning("Please upload an image to get started.")
+