Create app.py

app.py

@@ -0,0 +1,433 @@
+import gradio as gr
+import random
+from random import choice
+import requests
+import base64
+import io
+import re
+import plotly.graph_objects as go
+import numpy as np
+from PIL import Image, ImageDraw
+import random
+import re
+import os
+import shutil
+import gdown
+import pandas as pd
+import plotly.express as px
+import streamlit as st
+
+
+# Try to import plotly, if not installed, install it
+try:
+    import plotly
+except ImportError:
+    os.system('pip install plotly')
+
+# Define your inputs outside of the gr.Row() block
+# These are the inputs that will be used to generate the radar chart
+input_parameters = gr.Textbox(placeholder="Enter parameters, separated by commas", label="Parameters")
+randomize_values = gr.Checkbox(label="Randomize Values", value=True)
+randomize_titles = gr.Checkbox(label="Randomize Titles", value=True)
+randomize_param_count = gr.Checkbox(label="Randomize Parameter Count")
+chart_title = gr.Textbox(value="Radar Chart", label="Chart Title")
+param_count = gr.Slider(minimum=3, maximum=10, step=1, label="Parameter Count")
+param1 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 1", value=.75)
+param2 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 2", value=.75)
+param3 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 3", value=.75)
+param4 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 4", value=.75)
+param5 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 5", value=.75)
+param6 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 6", value=.75)
+param7 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 7", value=.75)
+param8 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 8", value=.75)
+param9 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 9", value=.75)
+param10 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 10", value=.75)
+prompt_input = gr.Textbox(lines=2, placeholder="Imagine something...", label="Prompt", value="__cars__")
+steps_input = gr.Slider(minimum=15, maximum=50, step=15, value=5, label="Steps")
+reset_seed_input = gr.Checkbox(label="Randomize Composition")
+increment_seed_input = gr.Checkbox(label="New Composition")
+img_output = gr.Image(label="Generated Image")
+radar_output = gr.Plot(label="Radar Chart")
+slider_labels_output = gr.Textbox(label="Prompt: Slider Labels")
+title1 = gr.Textbox(value='Minimalism', label="Title 1")
+title2 = gr.Textbox(value='Bauhaus', label="Title 2")
+title3 = gr.Textbox(value='Organic Design', label="Title 3")
+title4 = gr.Textbox(value='Brutalism', label="Title 4")
+title5 = gr.Textbox(value='Mid-century Modern', label="Title 5")
+title6 = gr.Textbox(value='Retro-Vintage', label="Title 6")
+title7 = gr.Textbox(value='Futurism', label="Title 7")
+title8 = gr.Textbox(value='Tesselated', label="Title 8")
+title9 = gr.Textbox(value='Streamlined', label="Title 9")
+title10 = gr.Textbox(value='Timeless', label="Title 10")
+
+# Define other inputs and outputs
+# These are the inputs and outputs that will be used to generate the image
+prompt_input = gr.Textbox(lines=2, placeholder="Imagine something...", label="Prompt", value="__cars__")
+steps_input = gr.Slider(minimum=15, maximum=50, step=5, value=15, label="Steps")
+img_output = gr.Image(label="Generated Image")
+prompt = "__cars__" 
+slider_labels = "concept art sketch"
+full_prompt = f"{prompt} {slider_labels}"
+prompt_input1 = title1
+prompt_input2 = title2
+prompt_input3 = title3
+
+
+# Global variables
+url = "http://73.255.78.150:7909/sdapi/v1/txt2img"
+session_seed = 1
+# Set a global variable for steps_input
+steps_input = 25
+last_session_seed = 2
+ALL_TITLES = [
+    'Minimalism', 'Bauhaus', 'Organic Design', 'Brutalism', 'Mid-century Modern',
+    'Retro-Vintage', 'Futurism', 'Tesselated', 'Streamlined', 'Timeless',
+    'Industrial Chic', 'Art Deco', 'Elegant', 'Biomorphic Design', 'High Contrast',
+    'Deconstructivism', 'Zen Design', 'Pop Art', 'Cyberpunk', 'Sustainable Design',
+    'Angular', 'Textured', 'Symmetric', 'Utilitarian', 'Dynamic Energy Flow',
+    'Less Extreme', 'Moderately Avant-Garde', 'Highly Avant-Garde'
+]
+ALL_VALUES = [
+    1.5, 1.2, 0.8, 1.0, 0.5, 1.0, 0.3, 0.5, 1.1, 0.7,
+    0.9, 1.3, 0.2, 1.3, 0.9, 1.1, 0.7, 0.6, 0.8, 0.4,
+    0.2, 0.1, 1.2, 0.0, 0.4
+]
+base_payload = {
+    "steps": 25,
+    "seed": 1,
+    "width": 768,
+    "height": 512,
+}
+
+# Function to change the global variable 'prompt'
+def change_prompt(new_prompt):
+    global prompt  # declare that we're using the global variable
+    prompt = new_prompt  # overwrite the global variable
+
+change_prompt("__trains__")
+print(prompt)  # will output "__trains__"
+
+def generate_image(prompt_input, steps, reset_seed, increment_seed):
+    global session_seed
+    global last_session_seed
+    global slider_labels
+    global prompt  # declare that we're using the global variable
+    prompt = prompt_input  # overwrite the global variable with the new input
+    if reset_seed:
+        if session_seed != -1:
+            last_session_seed = session_seed
+        session_seed = -1
+    elif not reset_seed and last_session_seed is not None:
+        session_seed = last_session_seed
+    elif session_seed is None:
+        session_seed = random.randint(0, 10000)
+    if increment_seed and session_seed != -1:
+        session_seed += 1
+        
+
+
+
+# Function definitions
+def generate_figure(r_values, theta_values, chart_title):
+    fig = go.Figure(data=go.Scatterpolar(
+        r=r_values, theta=theta_values, mode='lines+markers',
+        marker=dict(size=10), fill='toself')
+    )
+    fig.update_layout(
+        polar=dict(radialaxis=dict(visible=True, range=[-1.5, 1.75])),
+        showlegend=False, title=chart_title
+    )
+    return fig
+
+# Global variables to store the initial values
+initial_values = [("Textured", 0.75), ("Deconstructivism", 0.75), ("Utilitarian", 0.75)]
+
+# Global variables to store the temporary arrays
+temp_parameters = [title for title, value in initial_values]
+temp_array = [value for title, value in initial_values]
+temp_r_values = [value for title, value in initial_values]
+
+def display_radar_chart(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, *params):
+    global slider_labels  # Ensure this variable is available in your scope
+    global temp_parameters, temp_r_values  # Declare the global variables
+
+    print(f"Input Parameters: {input_parameters}")
+    print(f"Randomize Values: {randomize_values}")
+    print(f"Randomize Titles: {randomize_titles}")
+    print(f"Randomize Parameter Count: {randomize_param_count}")
+    print(f"Chart Title: {chart_title}")
+    print(f"Parameter Count: {param_count}")
+
+    if randomize_param_count:
+        param_count = random.randint(3, 10)
+    
+    # Create a temporary array from comma-separated input_parameters
+    if input_parameters:
+        temp_parameters = re.split(r'\s*,\s*', input_parameters.strip())
+        if len(temp_parameters) > param_count:
+            temp_parameters = temp_parameters[:param_count]
+    elif randomize_titles:
+        temp_parameters = random.sample(ALL_TITLES, param_count)
+    else:
+        temp_parameters = []
+
+    # Fill in missing parameters based on param_count
+    if len(temp_parameters) < param_count:
+        remaining_count = param_count - len(temp_parameters)
+        additional_params = random.sample(set(ALL_TITLES) - set(temp_parameters), remaining_count)
+        temp_parameters.extend(additional_params)
+
+    # Create a temporary array for values
+    if randomize_values:
+        temp_r_values = random.sample(ALL_VALUES, len(temp_parameters))
+    else:
+        temp_r_values = list(params[:len(temp_parameters)])
+    
+    chart_figure = generate_figure(temp_r_values, temp_parameters, chart_title)
+    slider_labels = ", ".join([f"({temp_parameters[i]}: {temp_r_values[i]:.2f})" for i in range(len(temp_r_values))])
+    
+    # Generate the radar chart
+    fig = generate_figure(temp_r_values, temp_parameters, chart_title)    
+    return fig, slider_labels
+
+def set_initial_state():
+    # Set default values for the form
+    input_parameters = ""
+    randomize_values = True
+    randomize_titles = True
+    randomize_param_count = False
+    chart_title = "Radar Chart"
+    param_count = 5
+    title1 = 'Minimalism'
+    param1 = 0.75
+    title2 = 'Bauhaus'
+    param2 = 0.75
+    title3 = 'Organic Design'
+    param3 = 0.75
+    title4 = 'Brutalism'
+    param4 = 0.75
+    title5 = 'Mid-century Modern'
+    param5 = 0.75
+    title6 = 'Retro-Vintage'
+    param6 = 0.75
+    title7 = 'Futurism'
+    param7 = 0.75
+    title8 = 'Tesselated'
+    param8 = 0.75
+    title9 = 'Streamlined'
+    param9 = 0.75
+    title10 = 'Timeless'
+    param10 = 0.75
+
+    
+
+    # Call display_radar_chart with default values
+    return display_radar_chart(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, title1, param1, title2, param2, title3, param3, title4, param4, title5, param5, title6, param6, title7, param7, title8, param8, title9, param9, title10, param10)
+
+# Call set_initial_state when the app is first loaded
+set_initial_state()
+
+def generate_image(prompt_input, steps_input, reset_seed_input, increment_seed_input):
+    global session_seed, last_session_seed, slider_labels
+    print(f"Prompt Input: {prompt_input}")
+    print(f"Steps Input: {steps_input}")
+    print(f"Reset Seed Input: {reset_seed_input}")
+    print(f"Increment Seed Input: {increment_seed_input}")
+
+    if reset_seed_input:
+        session_seed = random.randint(1, 10000)
+    elif increment_seed_input and last_session_seed is not None:
+        session_seed = last_session_seed + 1
+        last_session_seed = session_seed
+    # Update the base_payload with the new values
+    full_prompt = f"{prompt_input} inspired by {slider_labels}"
+    base_payload.update({
+        "prompt": full_prompt,
+        "steps": 25,
+        "seed": session_seed,
+        "negative_prompt": "",
+        "prompt_styles": ["RayOPunk"],
+        "sampler_index": "DPM++ 2M Karras",
+        "restore_faces": False,
+        "tiling": False,
+        "n_iter": 1,
+        "batch_size": 1,
+        "cfg_scale": 7.0,
+        "subseed": -1,
+        "subseed_strength": 0.0,
+        "seed_resize_from_h": -1,
+        "seed_resize_from_w": -1,
+        "seed_enable_extras": False,
+        "height": 768,
+        "width": 1024,
+        "enable_hr": False,
+        "denoising_strength": 0.0,
+        "hr_scale": 2.0,
+        "hr_upscaler": "Latent",
+        "hr_second_pass_steps": 0,
+        "hr_resize_x": 0,
+        "hr_resize_y": 0,
+        "hr_sampler_index": "",
+        "hr_prompt": "",
+        "hr_negative_prompt": "",
+        "override_settings_texts": ""
+    })
+    # Make the API call
+    response = requests.post(url, json=base_payload)
+
+    # Handle the response
+    response_data = response.json()
+    try:
+        # Decode the base64 image
+        img_data = base64.b64decode(response_data['images'][0])
+        img = Image.open(io.BytesIO(img_data))
+    except KeyError:
+        # Handle error in response
+        error_message = response_data.get('error', 'Unknown error')
+        error_image = Image.new('RGB', (512, 512), color=(73, 109, 137))
+        d = ImageDraw.Draw(error_image)
+        d.text((10, 10), f"Error: {error_message}", fill=(255, 255, 0))
+        img = error_image
+
+    return img
+
+def update_titles(title1, title2, title3, title4, title5, title6, title7, title8, title9, title10):
+    global slider_labels
+    slider_labels = ', '.join([title1, title2, title3, title4, title5, title6, title7, title8, title9, title10])
+    return slider_labels
+
+def radar_chart_fn(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10):
+    # Generate the radar chart
+    radar_chart, slider_labels = display_radar_chart(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10)
+    return radar_chart, slider_labels
+
+last_radar_chart = None
+last_slider_labels = None
+last_img = None
+
+def radar_chart_fn(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10):
+    global last_radar_chart, last_slider_labels
+    # Generate the radar chart
+    last_radar_chart, last_slider_labels = display_radar_chart(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10)
+    return last_radar_chart, last_slider_labels
+
+def image_fn(prompt_input, steps_input, reset_seed_input, increment_seed_input):
+    global last_img
+    # Generate the image
+    last_img = generate_image(prompt_input, steps_input, reset_seed_input, increment_seed_input)
+    return last_img
+
+def output_radar_chart_fn():
+    # Return the last generated radar chart
+    return last_radar_chart, last_slider_labels
+
+def output_image_fn():
+    # Return the last generated image
+    return last_img
+
+# Create the Gradio Interface for Radar Chart
+with gr.Blocks() as app:
+    gr.Markdown("# Radar Chart")
+
+    radar_interface = gr.Interface(
+        fn=radar_chart_fn,
+        inputs=[input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10],
+        outputs=[radar_output, slider_labels_output])
+
+
+def image_fn(prompt_input, steps_input, reset_seed_input, increment_seed_input):
+    # Generate the image
+    img = generate_image(prompt_input, steps_input, reset_seed_input, increment_seed_input)
+    return img
+
+def generate_and_display_image(prompt_input, title, param, steps_input):
+    full_prompt = f"{prompt_input} inspired by ({title}:{param})"
+    img = generate_image(full_prompt, steps_input, reset_seed_input=False, increment_seed_input=False)
+    return img
+
+
+def radar_chart_fn(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10):
+    global last_radar_chart, last_slider_labels
+    # Generate the radar chart
+    last_radar_chart, last_slider_labels = display_radar_chart(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10)
+    set_textbox_values(last_slider_labels)
+    return last_radar_chart, last_slider_labels
+
+def output_radar_chart_fn():
+    # Return the last generated radar chart
+    set_textbox_values(last_slider_labels)
+    return last_radar_chart, last_slider_labels
+
+with gr.Blocks() as app:
+    with gr.Accordion("Inputs and Outputs", collapsed=True):
+        radar_interface = gr.Interface(
+            fn=radar_chart_fn,
+            inputs=[input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3],
+            outputs=[radar_output, slider_labels_output])
+        prompt_input = gr.Textbox(lines=2, placeholder="Imagine something...", label="Prompt", value="__cars__")
+        reset_seed_input = gr.Checkbox(label="Randomize Composition")
+        increment_seed_input = gr.Checkbox(label="New Composition")
+        img_output = gr.Image(label="Generated Image")
+        iface = gr.Interface(
+            fn=image_fn,
+            inputs=[prompt_input, reset_seed_input, increment_seed_input],
+            outputs=[img_output],
+            live=False
+        )
+    with gr.Row():
+        with gr.Column(scale=2):
+            output_image_interface = gr.Interface(
+                fn=output_image_fn,
+                inputs=[],
+                outputs=[img_output],
+                live=True
+            )
+        with gr.Column(scale=1):
+            output_radar_interface = gr.Interface(
+                fn=output_radar_chart_fn,
+                inputs=[],
+                outputs=[radar_output, slider_labels_output])
+
+        def set_textbox_values(slider_labels_output):
+            # Validate the input
+            if not slider_labels_output:
+                return
+            
+            # Split and parse the slider_labels_output
+            slider_data = slider_labels_output.split(', ')
+            
+            for i, data in enumerate(slider_data):
+                try:
+                    title, value = data.split(':')
+                    globals()[f'title{i+1}'].value = title.strip()
+                    globals()[f'param{i+1}'].value = float(value.strip())
+                except ValueError:
+                    print(f"Could not parse data for slider {i+1}")
+
+        # Example usage:
+        slider_labels_output = "title1: 0.5, title2: 0.8, title3: 0.2"
+        set_textbox_values(slider_labels_output)
+
+
+        # Call this function to update the textboxes and sliders before creating them
+        set_textbox_values(last_slider_labels)
+        # Assuming slider_labels_output is a string like "(title1: value1), (title2: value2), ..."
+        slider_labels_output = "(title1: 0.75), (title2: 0.5), (title3: 1.25)"
+        # Split the string into individual labels
+        labels = slider_labels_output.split(", ")
+
+        # Extract the values from each label and convert them to floats
+        initial_values = [float(label.split(": ")[1].strip(")")) for label in slider_labels_output.split(", ")]
+        
+    with gr.Row():
+        for i in range(1, len(initial_values) + 1):
+            with gr.Column(scale=1):
+                param = gr.Slider(minimum=0, maximum=1.5, step=0.25, label=f"Parameter {i}", value=temp_array[i-1])
+                title = gr.Textbox(value=temp_parameters[i-1], label=f"Inspiration Word {i}")
+                img = gr.Interface(fn=generate_and_display_image, inputs=[prompt_input, title, param], outputs="image")
+
+    # Add the slider_labels_output textbox to a new row
+    with gr.Row():
+        slider_labels_output = gr.Textbox(value=slider_labels_output, label="Slider Labels")
+# Launch the app
+app.launch(share=True)