Update app.py

app.py

@@ -15,19 +15,7 @@ from pyzxing import BarCodeReader
 from PIL import ImageOps, ImageEnhance, ImageFilter
 from huggingface_hub import hf_hub_download, snapshot_download
 from PIL import ImageEnhance
-
-from diffusers import (
-    StableDiffusionPipeline,
-    StableDiffusionControlNetImg2ImgPipeline,
-    StableDiffusionControlNetPipeline,
-    ControlNetModel,
-    DDIMScheduler,
-    DPMSolverMultistepScheduler,
-    DEISMultistepScheduler,
-    HeunDiscreteScheduler,
-    EulerDiscreteScheduler,
-)
-
+import replicate
 from dotenv import load_dotenv
 
 # Load environment variables from .env file
@@ -35,6 +23,10 @@ load_dotenv()
 
 USERNAME = os.getenv("USERNAME")
 PASSWORD = os.getenv("PASSWORD")
+REPLICATE_API_TOKEN = os.getenv("REPLICATE_API_TOKEN")
+
+# Set the Replicate API token
+os.environ["REPLICATE_API_TOKEN"] = REPLICATE_API_TOKEN
 
 qrcode_generator = qrcode.QRCode(
     version=1,
@@ -61,36 +53,36 @@ DIFFUSION_MODELS = {
 loaded_controlnet = None
 loaded_pipe = None
 
-def load_models_on_launch():
-    global loaded_controlnet, loaded_pipe
-    print("Loading models on launch...")
-    
-    # Download the main repository
-    main_repo_path = snapshot_download("monster-labs/control_v1p_sd15_qrcode_monster")
+#   def load_models_on_launch():
+#    global loaded_controlnet, loaded_pipe
+#    print("Loading models on launch...")
     
-    # Construct the path to the subfolder
-    controlnet_path = os.path.join(main_repo_path, "v2")
+# Download the main repository
+#    main_repo_path = snapshot_download("monster-labs/control_v1p_sd15_qrcode_monster")
     
-    loaded_controlnet = ControlNetModel.from_pretrained(
-        controlnet_path,
-        torch_dtype=torch.float16
-    ).to("cuda")
-
-    diffusion_path = snapshot_download(DIFFUSION_MODELS["GhostMix"])
-    loaded_pipe = StableDiffusionControlNetImg2ImgPipeline.from_pretrained(
-        diffusion_path,
-        controlnet=loaded_controlnet,
-        torch_dtype=torch.float16,
-        safety_checker=None,
-    ).to("cuda")
-    print("Models loaded successfully!")
+# Construct the path to the subfolder
+#    controlnet_path = os.path.join(main_repo_path, "v2")
+
+#    loaded_controlnet = ControlNetModel.from_pretrained(
+#        controlnet_path,
+#        torch_dtype=torch.float16
+#    ).to("mps")
+
+#    diffusion_path = snapshot_download(DIFFUSION_MODELS["GhostMix"])
+#    loaded_pipe = StableDiffusionControlNetImg2ImgPipeline.from_pretrained(
+#        diffusion_path,
+#        controlnet=loaded_controlnet,
+#        torch_dtype=torch.float16,
+#        safety_checker=None,
+#    ).to("mps")
+#    print("Models loaded successfully!")
 
 # Modify the load_models function to use global variables
-def load_models(controlnet_model, diffusion_model):
-    global loaded_controlnet, loaded_pipe
-    if loaded_controlnet is None or loaded_pipe is None:
-        load_models_on_launch()
-    return loaded_pipe
+#def load_models(controlnet_model, diffusion_model):
+#    global loaded_controlnet, loaded_pipe
+#    if loaded_controlnet is None or loaded_pipe is None:
+#        load_models_on_launch()
+#    return loaded_pipe
 
 # Add new functions for image adjustments
 def adjust_image(image, brightness, contrast, saturation):
@@ -120,14 +112,14 @@ def resize_for_condition_image(input_image: Image.Image, resolution: int):
     return img
 
 
-SAMPLER_MAP = {
-    "DPM++ Karras SDE": lambda config: DPMSolverMultistepScheduler.from_config(config, use_karras=True, algorithm_type="sde-dpmsolver++"),
-    "DPM++ Karras": lambda config: DPMSolverMultistepScheduler.from_config(config, use_karras=True),
-    "Heun": lambda config: HeunDiscreteScheduler.from_config(config),
-    "Euler": lambda config: EulerDiscreteScheduler.from_config(config),
-    "DDIM": lambda config: DDIMScheduler.from_config(config),
-    "DEIS": lambda config: DEISMultistepScheduler.from_config(config),
-}
+#   SAMPLER_MAP = {
+#    "DPM++ Karras SDE": lambda config: DPMSolverMultistepScheduler.from_config(config, use_karras=True, algorithm_type="sde-dpmsolver++"),
+#    "DPM++ Karras": lambda config: DPMSolverMultistepScheduler.from_config(config, use_karras=True),
+#    "Heun": lambda config: HeunDiscreteScheduler.from_config(config),
+#    "Euler": lambda config: EulerDiscreteScheduler.from_config(config),
+#    "DDIM": lambda config: DDIMScheduler.from_config(config),
+#    "DEIS": lambda config: DEISMultistepScheduler.from_config(config),
+#}
 
 def scan_qr_code(image):
     # Convert gradio image to PIL Image if necessary
@@ -188,111 +180,98 @@ def invert_displayed_image(image):
     return inverted
 
 
-@spaces.GPU()
+#@spaces.GPU()
 def inference(
     qr_code_content: str,
     prompt: str,
     negative_prompt: str,
-    guidance_scale: float = 15.0,  # Increased from 10.0 to 15.0
-    controlnet_conditioning_scale: float = 1.5,  # Adjusted from 2.0 to 1.5
-    strength: float = 0.6,  # Reduced from 0.8 to 0.6
+    guidance_scale: float = 9.0,
+    qr_conditioning_scale: float = 1.47,
+    num_inference_steps: int = 20,
     seed: int = -1,
-    init_image: Image.Image | None = None,
-    qrcode_image: Image.Image | None = None,
-    use_qr_code_as_init_image = True,
-    sampler = "DPM++ Karras SDE",  
-    bg_color: str = "white",
-    qr_color: str = "black",
-    invert_final_image: bool = False,
-    invert_init_image: bool = False,
-    controlnet_model: str = "QR Code Monster",
-    diffusion_model: str = "Stable v1.5",
-    reference_image_strength: float = 0.6,
+    image_resolution: int = 512,
+    scheduler: str = "K_EULER",
+    eta: float = 0.0,
+    num_outputs: int = 1,
+    low_threshold: int = 100,
+    high_threshold: int = 200,
+    guess_mode: bool = False,
+    disable_safety_check: bool = False,
 ):
     try:
         progress = gr.Progress()
-        # Load models based on user selection
-        progress(0, desc="Downloading models...")
-        pipe = load_models(controlnet_model, diffusion_model)
-        progress(0.5, desc="Models downloaded, preparing for inference...")
-        
-        if prompt is None or prompt == "":
-            raise gr.Error("Prompt is required")
-
-        if qrcode_image is None and qr_code_content == "":
-            raise gr.Error("QR Code Image or QR Code Content is required")
+        progress(0, desc="Generating QR code...")
+
+        # Generate QR code image
+        qr = qrcode.QRCode(
+            version=1,
+            error_correction=qrcode.constants.ERROR_CORRECT_H,
+            box_size=10,
+            border=4,
+        )
+        qr.add_data(qr_code_content)
+        qr.make(fit=True)
+        qr_image = qr.make_image(fill_color="black", back_color="white")
+
+        # Save QR code image to a temporary file
+        temp_qr_path = "temp_qr.png"
+        qr_image.save(temp_qr_path)
+
+        progress(0.3, desc="Running inference...")
+
+        # Ensure num_outputs is within the allowed range
+        num_outputs = max(1, min(num_outputs, 10))
+
+        # Ensure seed is an integer and not null
+        seed = int(seed) if seed != -1 else None
+
+        # Ensure high_threshold is at least 1
+        high_threshold = max(1, int(high_threshold))
+
+        # Prepare the input dictionary
+        input_dict = {
+            "prompt": prompt,
+            "qr_image": open(temp_qr_path, "rb"),
+            "negative_prompt": negative_prompt,
+            "guidance_scale": float(guidance_scale),
+            "qr_conditioning_scale": float(qr_conditioning_scale),
+            "num_inference_steps": int(num_inference_steps),
+            "image_resolution": int(image_resolution),
+            "scheduler": scheduler,
+            "eta": float(eta),
+            "num_outputs": num_outputs,
+            "low_threshold": int(low_threshold),
+            "high_threshold": high_threshold,
+            "guess_mode": guess_mode,
+            "disable_safety_check": disable_safety_check,
+        }
+
+        # Only add seed to input_dict if it's not None
+        if seed is not None:
+            input_dict["seed"] = seed
+
+        # Run inference using Replicate API
+        output = replicate.run(
+            "anotherjesse/multi-control:76d8414a702e66c84fe2e6e9c8cbdc12e53f950f255aae9ffa5caa7873b12de0",
+            input=input_dict
+        )
 
-        pipe.scheduler = SAMPLER_MAP[sampler](pipe.scheduler.config)
+        progress(0.9, desc="Processing results...")
 
-        if seed == -1:
-            seed = torch.seed()  # Generate a truly random seed
-        generator = torch.manual_seed(seed)
+        # Download the generated image
+        response = requests.get(output[0])
+        img = Image.open(io.BytesIO(response.content))
 
-        if qr_code_content != "" or qrcode_image.size == (1, 1):
-            print("Generating QR Code from content")
-            qr = qrcode.QRCode(
-                version=1,
-                error_correction=qrcode.constants.ERROR_CORRECT_H,
-                box_size=10,
-                border=4,
-            )
-            qr.add_data(qr_code_content)
-            qr.make(fit=True)
+        # Clean up temporary file
+        os.remove(temp_qr_path)
 
-            qrcode_image = qr.make_image(fill_color=qr_color, back_color=bg_color)
-            qrcode_image = resize_for_condition_image(qrcode_image, 1024)
-        else:
-            print("Using QR Code Image")
-            qrcode_image = resize_for_condition_image(qrcode_image, 1024)
+        progress(1.0, desc="Done!")
+        return img, seed if seed is not None else -1
+    except Exception as e:
+        print(f"Error in inference: {str(e)}")
+        return Image.new('RGB', (512, 512), color='white'), -1
 
-        # Determine which image to use as init_image and control_image
-        if use_qr_code_as_init_image:
-            init_image = qrcode_image
-            control_image = qrcode_image
-        else:
-            control_image = qrcode_image
-            if init_image is None:
-                # If no init_image provided, set strength to 1.0 to generate a new image
-                strength = 1.0
-
-        # Adjust strength if using an init_image
-        if init_image is not None and not use_qr_code_as_init_image:
-            # Map the 0-5 range to 0-1 range for the strength parameter
-            mapped_strength = min(reference_image_strength / 5.0, 1.0)
-            strength = 1.0 - mapped_strength  # Invert the strength for img2img
-        elif use_qr_code_as_init_image:
-            strength = min(strength, 0.6)  # Cap strength at 0.6 when using QR code as init_image
-
-        # Invert init_image if requested
-        if invert_init_image and init_image is not None:
-            init_image = invert_image(init_image)
-
-        final_image = None
-        out = pipe(
-            prompt=prompt,  # Use the full prompt
-            negative_prompt=negative_prompt,  # Use the full negative prompt
-            image=init_image,
-            control_image=control_image,
-            width=1024,
-            height=1024,
-            guidance_scale=float(guidance_scale),
-            controlnet_conditioning_scale=float(controlnet_conditioning_scale),
-            generator=generator,
-            strength=float(strength),
-            num_inference_steps=50,
-        )
-        final_image = out.images[0] if final_image is None else final_image
 
-        if invert_final_image:
-            final_image = invert_image(final_image)
-        
-        return final_image, seed
-    except gr.Error as e:
-        print(f"Gradio error in inference: {str(e)}")
-        return Image.new('RGB', (1024, 1024), color='white'), -1
-    except Exception as e:
-        print(f"Unexpected error in inference: {str(e)}")
-        return Image.new('RGB', (1024, 1024), color='white'), -1
 
 def invert_init_image_display(image):
     if image is None:
@@ -361,7 +340,7 @@ def login(username, password):
         return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), gr.update(value="Login successful! You can now access the QR Code Art Generator tab.", visible=True)
     else:
         return gr.update(visible=False), gr.update(visible=True), gr.update(visible=True), gr.update(value="Invalid username or password. Please try again.", visible=True)
-
+    
 # Add login elements to the Gradio interface
 with gr.Blocks(theme='Hev832/Applio', css=css, fill_width=True, fill_height=True) as blocks:
     generated_images = gr.State([])
@@ -399,9 +378,9 @@ with gr.Blocks(theme='Hev832/Applio', css=css, fill_width=True, fill_height=True
                     )
 
                 with gr.Row():
-                    username = gr.Textbox(label="Username", placeholder="Enter your username", value="ugd")
+                    username = gr.Textbox(label="Username", placeholder="Enter your username")
                 with gr.Row():
-                    password = gr.Textbox(label="Password", type="password", placeholder="Enter your password", value="ugd!")
+                    password = gr.Textbox(label="Password", type="password", placeholder="Enter your password")
                 with gr.Row():
                     login_button = gr.Button("Login", size="sm")
                 login_message = gr.Markdown(visible=False)
@@ -421,7 +400,7 @@ with gr.Blocks(theme='Hev832/Applio', css=css, fill_width=True, fill_height=True
                 prompt = gr.Textbox(
                     label="Artistic Prompt",
                     placeholder="Describe the style or theme for your QR code art (For best results, keep the prompt to 75 characters or less as seen below)",
-                    value="A high-res, photo-realistic minimalist rendering of Mount Fuji as a sharp, semi-realistic silhouette on the horizon, traditional Japanese woodblock prints, nature photography, 4k, bold",
+                    value="A high-res, photo-realistic minimalist rendering of Mount Fuji as a sharp, semi-realistic silhouette on the horizon. The mountain conveys strength and motion with clean, crisp lines and natural flow. Features detailed snow textures, subtle ridge highlights, and a powerful yet serene atmosphere. Emphasizes strength with clarity and precision in texture and light.",
                     info="Describe the style or theme for your QR code art (For best results, keep the prompt to 75 characters or less as seen in the example)",
                     lines=8,
                 )
@@ -494,13 +473,14 @@ with gr.Blocks(theme='Hev832/Applio', css=css, fill_width=True, fill_height=True
             
             with gr.Column():
                 gr.Markdown("### Your Generated QR Code Art")
+                gr.Markdown("Click the download button below the image to save your creation.")
                 result_image = gr.Image(
                     label="Your Artistic QR Code", 
                     show_download_button=True, 
                     show_fullscreen_button=True, 
                     container=True
                 )
-                gr.Markdown("💾 Right-click and save to download your QR code art.")
+                gr.Markdown("💾 Use the download button above the image to save your QR code art.")
 
                 scan_button = gr.Button("Verify QR Code Works", visible=False)
                 scan_result = gr.Textbox(label="Validation Result of QR Code", interactive=False, visible=False)
@@ -529,90 +509,86 @@ with gr.Blocks(theme='Hev832/Applio', css=css, fill_width=True, fill_height=True
     with gr.Tab("Advanced Settings"):
         with gr.Accordion("Advanced Art Controls", open=True):
             with gr.Row():
-                controlnet_conditioning_scale = gr.Slider(
+                qr_conditioning_scale = gr.Slider(
                     minimum=0.0,
                     maximum=5.0,
                     step=0.01,
-                    value=2,
-                    label="QR Code Visibility in Image",
+                    value=1.47,
+                    label="QR Code Visibility",
                 )
-                with gr.Accordion("How Much QR Code Visibility is in Final Image (Click For Explanation)", open=False):
+                with gr.Accordion("QR Code Visibility Explanation", open=False):
                     gr.Markdown(
                         """
-                        **QR Code Visibility** determines how much the QR code itself stands out in the final design. Think of it like balancing between how "artistic" the image looks and how "functional" the QR code is.
-                
-                        - **Low settings (0.0-1)**: If you choose a lower value, the QR code will blend more into the art, and it might be hard to scan with a phone. This setting is great if you want the image to look amazing, but you might lose some of the scannability. Try this if you care more about art and less about the QR code being easily recognized.
-                        
-                        - **Medium settings (1-3)**: This is the sweet spot where the QR code remains clearly visible while still blending in with the art. You can still scan it easily with a phone, but it looks more creative. For most users, setting it around **1.1** is a great start to balance both art and function.
+                        **QR Code Visibility** controls how prominent the QR code is in the final image:
                         
-                        - **High settings (3-5.0)**: If you need to make sure that the QR code is super easy to scan, even if it means the image looks less like art and more like a regular QR code, then choose a higher value. This is ideal when functionality is the main goal, and the artistic side can take a backseat.
+                        - **Low (0.0-1.0)**: QR code blends more with the art, potentially harder to scan.
+                        - **Medium (1.0-3.0)**: Balanced visibility, usually scannable while maintaining artistic quality.
+                        - **High (3.0-5.0)**: QR code stands out more, easier to scan but less artistic.
                         
-                        Start with **1.3** if you're unsure, and adjust up or down depending on whether you want the QR code to be more artistic or more functional.
+                        Start with 1.47 for a good balance between art and functionality.
                         """
                     )
             
             with gr.Row():
-                strength = gr.Slider(
-                    minimum=0.0, 
-                    maximum=5, 
-                    step=0.10, 
-                    value=2, 
-                    label="Artistic Freedom for the AI When Generating",
+                guidance_scale = gr.Slider(
+                    minimum=0.1,
+                    maximum=30.0,
+                    step=0.1,
+                    value=9.0,
+                    label="Prompt Adherence",
                 )
-                with gr.Accordion("How Much Artistic Freedom the AI has When Generating Image (Click For Explanation)", open=False):
+                with gr.Accordion("Prompt Adherence Explanation", open=False):
                     gr.Markdown(
                         """
-                        **Artistic Freedom** controls how much the AI is allowed to change the QR code's look to match your description. It's like telling the AI how creative it can get with your QR code:
-                
-                        - **Low settings (0.10-2)**: If you set this low, the AI will make small changes and your QR code will look more like a regular, plain QR code. This is useful if you want something that is still creative but not too wild, keeping it simple and easy to scan.
-                
-                        - **Medium settings (2-3)**: Here, the AI will add more artistic touches but keep the QR code recognizable. You get the best of both worlds—your QR code will have some creative flair, but it will still be easy to scan. For most cases, setting it to **0.6** is a great way to keep the code functional and artistic.
-                
-                        - **High settings (3-5)**: If you set this high, the AI will go all-out creative. The QR code will look amazing, but it might be difficult to scan because the art can start to take over the code. This setting is perfect if you're aiming for a highly creative piece of art and don't mind if it's a bit harder to scan. Start at **0.9** to explore creative but functional designs.
+                        **Prompt Adherence** determines how closely the AI follows your prompt:
+                        
+                        - **Low (0.1-5.0)**: More creative freedom, may deviate from prompt.
+                        - **Medium (5.0-15.0)**: Balanced between prompt and AI creativity.
+                        - **High (15.0-30.0)**: Strictly follows the prompt, less creative freedom.
+                        
+                        A value of 9.0 provides a good balance between creativity and prompt adherence.
                         """
                     )
             
             with gr.Row():
-                guidance_scale = gr.Slider(
-                    minimum=0.0,
-                    maximum=100.0,
-                    step=0.25,
-                    value=7.5,
-                    label="How Closely the AI Follows the Prompt",
+                num_inference_steps = gr.Slider(
+                    minimum=1,
+                    maximum=100,
+                    step=1,
+                    value=20,
+                    label="Generation Steps",
                 )
-                with gr.Accordion("How Closely the AI Follows the Prompt (Click For Explanation)", open=False):
+                with gr.Accordion("Generation Steps Explanation", open=False):
                     gr.Markdown(
                         """
-                        **Follow the Prompt** tells the AI how closely it should follow your description when creating the QR code art. Think of it like giving the AI instructions on how strict or flexible it can be with your design ideas:
-                
-                        - **Low settings (0-5)**: If you choose a lower value, the AI has more freedom to get creative on its own and may not stick too closely to your description. This is great if you want to see how the AI interprets your ideas in unexpected ways.
-                
-                        - **Medium settings (5-15)**: This is a good balance where the AI will mostly follow your prompt but will also add some of its own creative touches. If you want to see some surprises but still want the design to look like what you described, start at around **7.5**.
-                
-                        - **High settings (15+)**: If you choose a higher value, the AI will stick very closely to what you wrote in the description. This is good if you have a very specific idea and don't want the AI to change much. Just keep in mind that this might limit the AI's creativity.
+                        **Generation Steps** affects the detail and quality of the generated image:
+                        
+                        - **Low (1-10)**: Faster generation, less detailed results.
+                        - **Medium (11-30)**: Good balance between speed and quality.
+                        - **High (31-100)**: More detailed results, slower generation.
                         
-                        Start at **7.5** for a balanced approach where the AI follows your ideas but still adds some artistic flair.
+                        20 steps is a good starting point for most generations.
                         """
                     )
             
             with gr.Row():
-                sampler = gr.Dropdown(
-                    choices=list(SAMPLER_MAP.keys()), 
-                    value="DPM++ Karras SDE", 
-                    label="Art Style Used to Create the Image",
+                image_resolution = gr.Slider(
+                    minimum=256,
+                    maximum=1024,
+                    step=64,
+                    value=512,
+                    label="Image Resolution",
                 )
-                with gr.Accordion("Details on Art Style the AI Uses to Create the Image (Click For Explanation)", open=False):
+                with gr.Accordion("Image Resolution Explanation", open=False):
                     gr.Markdown(
                         """
-                        **Art Style** changes how the AI creates the image, using different methods (or "samplers"). Each method has a different effect on how detailed or artistic the final QR code looks:
-                
-                        - **DPM++ Karras SDE**: This is a great all-around option for creating high-quality, detailed images. It's a good place to start if you want a balance of sharpness and creativity.
-                
-                        - **Euler**: This method creates very sharp, detailed images, making the QR code look crisp and clear. Choose this if you want a precise, well-defined design.
-                
-                        - **DDIM**: This method is better if you want the QR code to have a more artistic, abstract style. It's great for when you want the QR code to look like a piece of modern art.
+                        **Image Resolution** determines the size and detail of the generated image:
                         
-                        Feel free to experiment with different samplers to see what works best for the look you're going for!
+                        - **Low (256-384)**: Faster generation, less detailed.
+                        - **Medium (512-768)**: Good balance of detail and generation time.
+                        - **High (832-1024)**: More detailed, slower generation.
+                        
+                        512x512 is a good default for most use cases.
                         """
                     )
             
@@ -622,32 +598,123 @@ with gr.Blocks(theme='Hev832/Applio', css=css, fill_width=True, fill_height=True
                     maximum=9999999999,
                     step=1,
                     value=-1,
-                    label="Creative Seed for the Image Generation",                 
+                    label="Generation Seed",
                 )
-                with gr.Accordion("How Creative Seed Works for Generating New and Unique Images (Click For Explanation)", open=False):
+                with gr.Accordion("Generation Seed Explanation", open=False):
                     gr.Markdown(
                         """
-                        **Creative Seed** controls whether the AI creates a completely new design each time or sticks to a specific design. Think of it like a recipe: with the same seed number, you get the same "recipe" for your QR code every time.
-                
-                        - **-1**: This setting makes the AI create something completely new every time you run it. Use this if you want to explore different design ideas with each attempt.
-                
-                        - **Any other number**: If you set a specific number, the AI will always create the same image based on that number. This is useful if you find a design you like and want to recreate it exactly.
-                
-                        Try **-1** if you want to explore and generate different designs. If you find something you really love, write down the seed number and use it again to recreate the same design.
+                        **Generation Seed** controls the randomness of the generation:
+                        
+                        - **-1**: Random seed each time, producing different results.
+                        - **Any positive number**: Consistent results for the same inputs.
+                        
+                        Use -1 to explore various designs, or set a specific seed to recreate a particular result.
+                        """
+                    )
+            
+            with gr.Row():
+                scheduler = gr.Dropdown(
+                    choices=["DDIM", "K_EULER", "DPMSolverMultistep", "K_EULER_ANCESTRAL", "PNDM", "KLMS"],
+                    value="K_EULER",
+                    label="Sampling Method",
+                )
+                with gr.Accordion("Sampling Method Explanation", open=False):
+                    gr.Markdown(
+                        """
+                        **Sampling Method** affects the image generation process:
+                        
+                        - **K_EULER**: Good balance of speed and quality.
+                        - **DDIM**: Can produce sharper results but may be slower.
+                        - **DPMSolverMultistep**: Often produces high-quality results.
+                        - **K_EULER_ANCESTRAL**: Can introduce more variations.
+                        - **PNDM**: Another quality-focused option.
+                        - **KLMS**: Can produce smooth results.
+                        
+                        Experiment with different methods to find what works best for your specific prompts.
                         """
                     )
 
             with gr.Row():
-                reference_image_strength = gr.Slider(
+                eta = gr.Slider(
                     minimum=0.0,
-                    maximum=5.0,
-                    step=0.05,
-                    value=0.6,
-                    label="Reference Image Influence",
-                    info="Controls how much the reference image influences the final result (0 = ignore, 5 = copy exactly)",
-                    visible=False  # We'll make this visible when a reference image is uploaded
+                    maximum=1.0,
+                    step=0.01,
+                    value=0.0,
+                    label="ETA (Noise Level)",
+                )
+                with gr.Accordion("ETA Explanation", open=False):
+                    gr.Markdown(
+                        """
+                        **ETA (Noise Level)** controls the amount of noise in the generation process:
+                        
+                        - **0.0**: No added noise, more deterministic results.
+                        - **0.1-0.5**: Slight variations in output.
+                        - **0.6-1.0**: More variations, potentially more creative results.
+                        
+                        Start with 0.0 and increase if you want more variation in your outputs.
+                        """
+                    )
+
+            with gr.Row():
+                low_threshold = gr.Slider(
+                    minimum=1,
+                    maximum=255,
+                    step=1,
+                    value=100,
+                    label="Edge Detection Low Threshold",
+                )
+                high_threshold = gr.Slider(
+                    minimum=1,
+                    maximum=255,
+                    step=1,
+                    value=200,
+                    label="Edge Detection High Threshold",
+                )
+                with gr.Accordion("Edge Detection Thresholds Explanation", open=False):
+                    gr.Markdown(
+                        """
+                        **Edge Detection Thresholds** affect how the QR code edges are processed:
+                        
+                        - **Low Threshold**: Lower values detect more edges, higher values fewer.
+                        - **High Threshold**: Determines which edges are strong. Higher values result in fewer strong edges.
+                        
+                        Default values (100, 200) work well for most QR codes. Adjust if you need more or less edge definition.
+                        """
+                    )
+
+            with gr.Row():
+                guess_mode = gr.Checkbox(
+                    label="Guess Mode",
+                    value=False,
                 )
+                with gr.Accordion("Guess Mode Explanation", open=False):
+                    gr.Markdown(
+                        """
+                        **Guess Mode**, when enabled, allows the AI to interpret the input image more freely:
+                        
+                        - **Unchecked**: AI follows the QR code structure more strictly.
+                        - **Checked**: AI has more freedom to interpret the input, potentially leading to more creative results.
+                        
+                        Use this if you want more artistic interpretations of your QR code.
+                        """
+                    )
 
+            with gr.Row():
+                disable_safety_check = gr.Checkbox(
+                    label="Disable Safety Check",
+                    value=False,
+                )
+                with gr.Accordion("Safety Check Explanation", open=False):
+                    gr.Markdown(
+                        """
+                        **Disable Safety Check** removes content filtering from the generation process:
+                        
+                        - **Unchecked**: Normal content filtering applied.
+                        - **Checked**: No content filtering, may produce unexpected or inappropriate results.
+                        
+                        Use with caution and only if necessary for your specific use case.
+                        """
+                    )
     with gr.Tab("Image Editing"):
         with gr.Column():
             image_selector = gr.Dropdown(label="Select Image to Edit", choices=[], interactive=True, visible=False)
@@ -761,19 +828,16 @@ with gr.Blocks(theme='Hev832/Applio', css=css, fill_width=True, fill_height=True
             prompt,
             negative_prompt,
             guidance_scale,
-            controlnet_conditioning_scale,
-            strength,
+            qr_conditioning_scale,
+            num_inference_steps,
             seed,
-            init_image,
-            qr_code_image,
-            use_qr_code_as_init_image,
-            sampler,
-            bg_color,
-            qr_color,
-            invert_final_image,
-            controlnet_model_dropdown,
-            diffusion_model_dropdown,
-            reference_image_strength,
+            image_resolution,
+            scheduler,
+            eta,
+            low_threshold,
+            high_threshold,
+            guess_mode,
+            disable_safety_check,
         ],
         outputs=[result_image, used_seed],
         concurrency_limit=20
@@ -794,7 +858,7 @@ with gr.Blocks(theme='Hev832/Applio', css=css, fill_width=True, fill_height=True
     )
 
 # Load models on launch
-load_models_on_launch()
+#load_models_on_launch()
 
 blocks.queue(max_size=20)
-blocks.launch(share=False, show_api=True)
+blocks.launch(share=False, show_api=False)