Update app.py

made for maree

app.py

@@ -32,11 +32,11 @@ parser = argparse.ArgumentParser()
 parser.add_argument("--opt", type=str, default='options/SUPIR_v0.yaml')
 parser.add_argument("--ip", type=str, default='127.0.0.1')
 parser.add_argument("--port", type=int, default='6688')
-parser.add_argument("--no_llava", action='store_true', default=True)#False
-parser.add_argument("--use_image_slider", action='store_true', default=False)#False
+parser.add_argument("--no_llava", action='store_true', default=True)
+parser.add_argument("--use_image_slider", action='store_true', default=False)
 parser.add_argument("--log_history", action='store_true', default=False)
-parser.add_argument("--loading_half_params", action='store_true', default=False)#False
-parser.add_argument("--use_tile_vae", action='store_true', default=True)#False
+parser.add_argument("--loading_half_params", action='store_true', default=False)
+parser.add_argument("--use_tile_vae", action='store_true', default=True)
 parser.add_argument("--encoder_tile_size", type=int, default=512)
 parser.add_argument("--decoder_tile_size", type=int, default=64)
 parser.add_argument("--load_8bit_llava", action='store_true', default=False)
@@ -59,7 +59,22 @@ if torch.cuda.device_count() > 0:
 def check_upload(input_image):
     if input_image is None:
         raise gr.Error("Please provide an image to restore.")
-    return gr.update(visible = True)
+    return gr.update(visible=True)
+
+def process_uploaded_image(image_path):
+    image = Image.open(image_path)
+    width, height = image.size
+    max_dim = max(width, height)
+    if max_dim > 1024:
+        if width > height:
+            new_width = 1024
+            new_height = int((1024 / width) * height)
+        else:
+            new_height = 1024
+            new_width = int((1024 / height) * width)
+        image = image.resize((new_width, new_height), Image.ANTIALIAS)
+        image.save(image_path)
+    return image_path
 
 def update_seed(is_randomize_seed, seed):
     if is_randomize_seed:
@@ -68,94 +83,98 @@ def update_seed(is_randomize_seed, seed):
 
 def reset():
     return [
-        None,
-        0,
-        None,
-        None,
-        "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-        "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-        1,
-        1024,
-        1,
-        2,
-        50,
-        -1.0,
-        1.,
-        default_setting.s_cfg_Quality if torch.cuda.device_count() > 0 else 1.0,
-        True,
-        random.randint(0, max_64_bit_int),
-        5,
-        1.003,
-        "Wavelet",
-        "fp32",
-        "fp32",
-        1.0,
-        True,
-        False,
-        default_setting.spt_linear_CFG_Quality if torch.cuda.device_count() > 0 else 1.0,
-        0.,
-        "v0-Q",
-        "input",
-        6
+        None,  # input_image
+        "",  # prompt
+        'Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.',  # a_prompt
+        'painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth',  # n_prompt
+        1,  # num_samples
+        1024,  # min_size
+        1,  # downscale
+        2,  # upscale
+        default_setting.edm_steps if torch.cuda.device_count() > 0 else 1,  # edm_steps
+        -1.0,  # s_stage1
+        1.0,  # s_stage2
+        default_setting.s_cfg_Quality if torch.cuda.device_count() > 0 else 1.0,  # s_cfg
+        random.randint(0, max_64_bit_int),  # seed
+        5,  # s_churn
+        1.003,  # s_noise
+        'Wavelet',  # color_fix_type
+        'fp32',  # diff_dtype
+        'fp32',  # ae_dtype
+        1.0,  # gamma_correction
+        True,  # linear_CFG
+        False,  # linear_s_stage2
+        default_setting.spt_linear_CFG_Quality if torch.cuda.device_count() > 0 else 1.0,  # spt_linear_CFG
+        0.0,  # spt_linear_s_stage2
+        'v0-Q',  # model_select
+        4  # allocation
     ]
 
 def check(input_image):
     if input_image is None:
         raise gr.Error("Please provide an image to restore.")
 
-@spaces.GPU(duration=420)
-def stage1_process(
+def stage2_process(
     input_image,
-    gamma_correction,
+    prompt,
+    a_prompt,
+    n_prompt,
+    num_samples,
+    min_size,
+    downscale,
+    upscale,
+    edm_steps,
+    s_stage1,
+    s_stage2,
+    s_cfg,
+    seed,
+    s_churn,
+    s_noise,
+    color_fix_type,
     diff_dtype,
-    ae_dtype
+    ae_dtype,
+    gamma_correction,
+    linear_CFG,
+    linear_s_stage2,
+    spt_linear_CFG,
+    spt_linear_s_stage2,
+    model_select,
+    allocation
 ):
-    print('stage1_process ==>>')
-    if torch.cuda.device_count() == 0:
-        gr.Warning('Set this space to GPU config to make it work.')
-        return None, None
-    torch.cuda.set_device(SUPIR_device)
-    LQ = HWC3(np.array(Image.open(input_image)))
-    LQ = fix_resize(LQ, 512)
-    # stage1
-    LQ = np.array(LQ) / 255 * 2 - 1
-    LQ = torch.tensor(LQ, dtype=torch.float32).permute(2, 0, 1).unsqueeze(0).to(SUPIR_device)[:, :3, :, :]
-
-    model.ae_dtype = convert_dtype(ae_dtype)
-    model.model.dtype = convert_dtype(diff_dtype)
-
-    LQ = model.batchify_denoise(LQ, is_stage1=True)
-    LQ = (LQ[0].permute(1, 2, 0) * 127.5 + 127.5).cpu().numpy().round().clip(0, 255).astype(np.uint8)
-    # gamma correction
-    LQ = LQ / 255.0
-    LQ = np.power(LQ, gamma_correction)
-    LQ *= 255.0
-    LQ = LQ.round().clip(0, 255).astype(np.uint8)
-    print('<<== stage1_process')
-    return LQ, gr.update(visible = True)
-
-def stage2_process(*args, **kwargs):
     try:
-        return restore_in_Xmin(*args, **kwargs)
+        return restore_in_Xmin(
+            input_image,
+            prompt,
+            a_prompt,
+            n_prompt,
+            num_samples,
+            min_size,
+            downscale,
+            upscale,
+            edm_steps,
+            s_stage1,
+            s_stage2,
+            s_cfg,
+            seed,
+            s_churn,
+            s_noise,
+            color_fix_type,
+            diff_dtype,
+            ae_dtype,
+            gamma_correction,
+            linear_CFG,
+            linear_s_stage2,
+            spt_linear_CFG,
+            spt_linear_s_stage2,
+            model_select,
+            allocation
+        )
     except Exception as e:
-        # NO_GPU_MESSAGE_INQUEUE
-        print("gradio.exceptions.Error 'No GPU is currently available for you after 60s'")
-        print('str(type(e)): ' + str(type(e))) # <class 'gradio.exceptions.Error'>
-        print('str(e): ' + str(e)) # You have exceeded your GPU quota...
-        try:
-            print('e.message: ' + e.message) # No GPU is currently available for you after 60s
-        except Exception as e2:
-            print('Failure')
-        if str(e).startswith("No GPU is currently available for you after 60s"):
-            print('Exception identified!!!')
-        #if str(type(e)) == "<class 'gradio.exceptions.Error'>":
-            #print('Exception of name ' + type(e).__name__)
+        print(f"Exception occurred: {str(e)}")
         raise e
 
 def restore_in_Xmin(
-    noisy_image,
-    rotation,
-    denoise_image,
+    input_image_path,
     prompt,
     a_prompt,
     n_prompt,
@@ -167,7 +186,6 @@ def restore_in_Xmin(
     s_stage1,
     s_stage2,
     s_cfg,
-    randomize_seed,
     seed,
     s_churn,
     s_noise,
@@ -180,51 +198,16 @@ def restore_in_Xmin(
     spt_linear_CFG,
     spt_linear_s_stage2,
     model_select,
-    output_format,
     allocation
 ):
-    print("noisy_image:\n" + str(noisy_image))
-    print("denoise_image:\n" + str(denoise_image))
-    print("rotation: " + str(rotation))
-    print("prompt: " + str(prompt))
-    print("a_prompt: " + str(a_prompt))
-    print("n_prompt: " + str(n_prompt))
-    print("num_samples: " + str(num_samples))
-    print("min_size: " + str(min_size))
-    print("downscale: " + str(downscale))
-    print("upscale: " + str(upscale))
-    print("edm_steps: " + str(edm_steps))
-    print("s_stage1: " + str(s_stage1))
-    print("s_stage2: " + str(s_stage2))
-    print("s_cfg: " + str(s_cfg))
-    print("randomize_seed: " + str(randomize_seed))
-    print("seed: " + str(seed))
-    print("s_churn: " + str(s_churn))
-    print("s_noise: " + str(s_noise))
-    print("color_fix_type: " + str(color_fix_type))
-    print("diff_dtype: " + str(diff_dtype))
-    print("ae_dtype: " + str(ae_dtype))
-    print("gamma_correction: " + str(gamma_correction))
-    print("linear_CFG: " + str(linear_CFG))
-    print("linear_s_stage2: " + str(linear_s_stage2))
-    print("spt_linear_CFG: " + str(spt_linear_CFG))
-    print("spt_linear_s_stage2: " + str(spt_linear_s_stage2))
-    print("model_select: " + str(model_select))
-    print("GPU time allocation: " + str(allocation) + " min")
-    print("output_format: " + str(output_format))
-
-    input_format = re.sub(r"^.*\.([^\.]+)$", r"\1", noisy_image)
-
-    if input_format not in ['png', 'webp', 'jpg', 'jpeg', 'gif', 'bmp', 'heic']:
-        gr.Warning('Invalid image format. Please first convert into *.png, *.webp, *.jpg, *.jpeg, *.gif, *.bmp or *.heic.')
+    print("Starting image restoration process...")
+    input_format = re.sub(r"^.*\.([^\.]+)$", r"\1", input_image_path)
+
+    if input_format.lower() not in ['png', 'webp', 'jpg', 'jpeg', 'gif', 'bmp', 'heic']:
+        gr.Warning('Invalid image format. Please use a supported image format.')
         return None, None, None, None
 
-    if output_format == "input":
-        if noisy_image is None:
-            output_format = "png"
-        else:
-            output_format = input_format
-    print("final output_format: " + str(output_format))
+    output_format = "png"
 
     if prompt is None:
         prompt = ""
@@ -241,17 +224,9 @@ def restore_in_Xmin(
         a_prompt = prompt + a_prompt
     print("Final prompt: " + str(a_prompt))
 
-    denoise_image = np.array(Image.open(noisy_image if denoise_image is None else denoise_image))
-
-    if rotation == 90:
-        denoise_image = np.array(list(zip(*denoise_image[::-1])))
-    elif rotation == 180:
-        denoise_image = np.array(list(zip(*denoise_image[::-1])))
-        denoise_image = np.array(list(zip(*denoise_image[::-1])))
-    elif rotation == -90:
-        denoise_image = np.array(list(zip(*denoise_image))[::-1])
+    denoise_image = np.array(Image.open(input_image_path))
 
-    if 1 < downscale:
+    if downscale > 1:
         input_height, input_width, input_channel = denoise_image.shape
         denoise_image = np.array(Image.fromarray(denoise_image).resize((input_width // downscale, input_height // downscale), Image.LANCZOS))
 
@@ -259,10 +234,10 @@ def restore_in_Xmin(
 
     if torch.cuda.device_count() == 0:
         gr.Warning('Set this space to GPU config to make it work.')
-        return [noisy_image, denoise_image], gr.update(label="Downloadable results in *." + output_format + " format", format = output_format, value = [denoise_image]), None, gr.update(visible=True)
+        return [input_image_path, denoise_image], gr.update(label="Downloadable results", format=output_format, value=[denoise_image]), None, gr.update(visible=True)
 
     if model_select != model.current_model:
-        print('load ' + model_select)
+        print('Loading model: ' + model_select)
         if model_select == 'v0-Q':
             model.load_state_dict(ckpt_Q, strict=False)
         elif model_select == 'v0-F':
@@ -273,46 +248,26 @@ def restore_in_Xmin(
     model.model.dtype = convert_dtype(diff_dtype)
 
     # Allocation
-    if allocation == 1:
-        return restore_in_1min(
-            noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
-        )
-    if allocation == 2:
-        return restore_in_2min(
-            noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
-        )
-    if allocation == 3:
-        return restore_in_3min(
-            noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
-        )
-    if allocation == 4:
-        return restore_in_4min(
-            noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
-        )
-    if allocation == 5:
-        return restore_in_5min(
-            noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
-        )
-    if allocation == 7:
-        return restore_in_7min(
-            noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
-        )
-    if allocation == 8:
-        return restore_in_8min(
-            noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
-        )
-    if allocation == 9:
-        return restore_in_9min(
-            noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
-        )
-    if allocation == 10:
-        return restore_in_10min(
-            noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
-        )
-    else:
-        return restore_in_6min(
-            noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
-        )
+    allocation_functions = {
+        1: restore_in_1min,
+        2: restore_in_2min,
+        3: restore_in_3min,
+        4: restore_in_4min,
+        5: restore_in_5min,
+        6: restore_in_6min,
+        7: restore_in_7min,
+        8: restore_in_8min,
+        9: restore_in_9min,
+        10: restore_in_10min,
+    }
+
+    restore_function = allocation_functions.get(allocation, restore_in_4min)
+    return restore_function(
+        input_image_path, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale,
+        edm_steps, s_stage1, s_stage2, s_cfg, seed, s_churn, s_noise, color_fix_type,
+        diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG,
+        spt_linear_s_stage2, model_select, allocation
+    )
 
 @spaces.GPU(duration=59)
 def restore_in_1min(*args, **kwargs):
@@ -355,8 +310,7 @@ def restore_in_10min(*args, **kwargs):
     return restore_on_gpu(*args, **kwargs)
 
 def restore_on_gpu(
-    noisy_image,
-    input_image,
+    input_image_path,
     prompt,
     a_prompt,
     n_prompt,
@@ -368,7 +322,6 @@ def restore_on_gpu(
     s_stage1,
     s_stage2,
     s_cfg,
-    randomize_seed,
     seed,
     s_churn,
     s_noise,
@@ -381,15 +334,17 @@ def restore_on_gpu(
     spt_linear_CFG,
     spt_linear_s_stage2,
     model_select,
-    output_format,
     allocation
 ):
     start = time.time()
-    print('restore ==>>')
+    print('Starting GPU restoration...')
+
+    output_format = "png"
 
     torch.cuda.set_device(SUPIR_device)
 
     with torch.no_grad():
+        input_image = Image.open(input_image_path)
         input_image = upscale_image(input_image, upscale, unit_resolution=32, min_size=min_size)
         LQ = np.array(input_image) / 255.0
         LQ = np.power(LQ, gamma_correction)
@@ -399,57 +354,40 @@ def restore_on_gpu(
         LQ = torch.tensor(LQ, dtype=torch.float32).permute(2, 0, 1).unsqueeze(0).to(SUPIR_device)[:, :3, :, :]
         captions = ['']
 
-        samples = model.batchify_sample(LQ, captions, num_steps=edm_steps, restoration_scale=s_stage1, s_churn=s_churn,
-                                    s_noise=s_noise, cfg_scale=s_cfg, control_scale=s_stage2, seed=seed,
-                                    num_samples=num_samples, p_p=a_prompt, n_p=n_prompt, color_fix_type=color_fix_type,
-                                    use_linear_CFG=linear_CFG, use_linear_control_scale=linear_s_stage2,
-                                    cfg_scale_start=spt_linear_CFG, control_scale_start=spt_linear_s_stage2)
+        samples = model.batchify_sample(
+            LQ, captions, num_steps=edm_steps, restoration_scale=s_stage1, s_churn=s_churn,
+            s_noise=s_noise, cfg_scale=s_cfg, control_scale=s_stage2, seed=seed,
+            num_samples=num_samples, p_p=a_prompt, n_p=n_prompt, color_fix_type=color_fix_type,
+            use_linear_CFG=linear_CFG, use_linear_control_scale=linear_s_stage2,
+            cfg_scale_start=spt_linear_CFG, control_scale_start=spt_linear_s_stage2
+        )
 
         x_samples = (einops.rearrange(samples, 'b c h w -> b h w c') * 127.5 + 127.5).cpu().numpy().round().clip(
             0, 255).astype(np.uint8)
         results = [x_samples[i] for i in range(num_samples)]
     torch.cuda.empty_cache()
 
-    # All the results have the same size
     input_height, input_width, input_channel = np.array(input_image).shape
     result_height, result_width, result_channel = np.array(results[0]).shape
 
-    print('<<== restore')
+    print('Restoration completed.')
     end = time.time()
     secondes = int(end - start)
     minutes = math.floor(secondes / 60)
     secondes = secondes - (minutes * 60)
     hours = math.floor(minutes / 60)
     minutes = minutes - (hours * 60)
-    information = ("Start the process again if you want a different result. " if randomize_seed else "") + \
-    "If you don't get the image you wanted, add more details in the « Image description ». " + \
-    "Wait " + str(allocation) + " min before a new run to avoid quota penalty or use another computer. " + \
-    "The image" + (" has" if len(results) == 1 else "s have") + " been generated in " + \
-    ((str(hours) + " h, ") if hours != 0 else "") + \
-    ((str(minutes) + " min, ") if hours != 0 or minutes != 0 else "") + \
-    str(secondes) + " sec. " + \
-    "The new image resolution is " + str(result_width) + \
-    " pixels large and " + str(result_height) + \
-    " pixels high, so a resolution of " + f'{result_width * result_height:,}' + " pixels."
-    print(information)
-    try:
-        print("Initial resolution: " + f'{input_width * input_height:,}')
-        print("Final resolution: " + f'{result_width * result_height:,}')
-        print("edm_steps: " + str(edm_steps))
-        print("num_samples: " + str(num_samples))
-        print("downscale: " + str(downscale))
-        print("Estimated minutes: " + f'{(((result_width * result_height**(1/1.75)) * input_width * input_height * (edm_steps**(1/2)) * (num_samples**(1/2.5)))**(1/2.5)) / 25000:,}')
-    except Exception as e:
-        print('Exception of Estimation')
+    information = ("Start the process again if you want a different result. " if seed is not None else "") + \
+        "The image has been enhanced successfully."
 
     # Only one image can be shown in the slider
-    return [noisy_image] + [results[0]], gr.update(label="Downloadable results in *." + output_format + " format", format = output_format, value = results), gr.update(value = information, visible = True), gr.update(visible=True)
+    return [input_image_path] + [results[0]], gr.update(label="Downloadable results", format=output_format, value=results), gr.update(value=information, visible=True), gr.update(visible=True)
 
 def load_and_reset(param_setting):
-    print('load_and_reset ==>>')
+    print('Resetting parameters...')
     if torch.cuda.device_count() == 0:
         gr.Warning('Set this space to GPU config to make it work.')
-        return None, None, None, None, None, None, None, None, None, None, None, None, None, None
+        return None, None, None, None, None, None, None, None, None, None, None, None, None
     edm_steps = default_setting.edm_steps
     s_stage2 = 1.0
     s_stage1 = -1.0
@@ -476,277 +414,281 @@ def load_and_reset(param_setting):
     else:
         raise NotImplementedError
     gr.Info('The parameters are reset.')
-    print('<<== load_and_reset')
+    print('Parameters reset completed.')
     return edm_steps, s_cfg, s_stage2, s_stage1, s_churn, s_noise, a_prompt, n_prompt, color_fix_type, linear_CFG, \
         linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select
 
 def log_information(result_gallery):
-    print('log_information')
+    print('Logging information...')
     if result_gallery is not None:
         for i, result in enumerate(result_gallery):
             print(result[0])
 
 def on_select_result(result_slider, result_gallery, evt: gr.SelectData):
-    print('on_select_result')
+    print('Result selected.')
     if result_gallery is not None:
         for i, result in enumerate(result_gallery):
             print(result[0])
     return [result_slider[0], result_gallery[evt.index][0]]
 
 title_html = """
-    <h1><center>SUPIR</center></h1>
-    <big><center>Upscale your images up to x10 freely, without account, without watermark and download it</center></big>
-    <center><big><big>🤸<big><big><big><big><big><big>🤸</big></big></big></big></big></big></big></big></center>
-    
-    <p>This is an online demo of SUPIR, a practicing model scaling for photo-realistic image restoration.
-    The content added by SUPIR is <b><u>imagination, not real-world information</u></b>.
-    SUPIR is for beauty and illustration only.
-    Most of the processes last few minutes.
-    If you want to upscale AI-generated images, be noticed that <i>PixArt Sigma</i> space can directly generate 5984x5984 images.
-    Due to Gradio issues, the generated image is slightly less satured than the original.
-    Please leave a <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR/discussions/new">message in discussion</a> if you encounter issues.
-    You can also use <a href="https://huggingface.co/spaces/gokaygokay/AuraSR">AuraSR</a> to upscale x4.
-    
-    <p><center><a href="https://arxiv.org/abs/2401.13627">Paper</a> &emsp; <a href="http://supir.xpixel.group/">Project Page</a> &emsp; <a href="https://huggingface.co/blog/MonsterMMORPG/supir-sota-image-upscale-better-than-magnific-ai">Local Install Guide</a></center></p>
-    <p><center><a style="display:inline-block" href='https://github.com/Fanghua-Yu/SUPIR'><img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/Fanghua-Yu/SUPIR?style=social"></a></center></p>
+    <h1><center>Maree's Magical Photo Tool</center></h1>
     """
 
-
-claim_md = """
-## **Piracy**
-The images are not stored but the logs are saved during a month.
-## **How to get SUPIR**
-You can get SUPIR on HuggingFace by [duplicating this space](https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR?duplicate=true) and set GPU.
-You can also install SUPIR on your computer following [this tutorial](https://huggingface.co/blog/MonsterMMORPG/supir-sota-image-upscale-better-than-magnific-ai).
-You can install _Pinokio_ on your computer and then install _SUPIR_ into it. It should be quite easy if you have an Nvidia GPU.
-## **Terms of use**
-By using this service, users are required to agree to the following terms: The service is a research preview intended for non-commercial use only. It only provides limited safety measures and may generate offensive content. It must not be used for any illegal, harmful, violent, racist, or sexual purposes. The service may collect user dialogue data for future research. Please submit a feedback to us if you get any inappropriate answer! We will collect those to keep improving our models. For an optimal experience, please use desktop computers for this demo, as mobile devices may compromise its quality.
-## **License**
-The service is a research preview intended for non-commercial use only, subject to the model [License](https://github.com/Fanghua-Yu/SUPIR) of SUPIR.
-"""
-
 # Gradio interface
 with gr.Blocks() as interface:
     if torch.cuda.device_count() == 0:
         with gr.Row():
             gr.HTML("""
-    <p style="background-color: red;"><big><big><big><b>⚠️To use SUPIR, <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR?duplicate=true">duplicate this space</a> and set a GPU with 30 GB VRAM.</b>
-    
-    You can't use SUPIR directly here because this space runs on a CPU, which is not enough for SUPIR. Please provide <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR/discussions/new">feedback</a> if you have issues.
-    </big></big></big></p>
+    <p style="background-color: red;"><big><big><big><b>⚠️To use this tool, set a GPU with sufficient VRAM.</b></big></big></big></p>
     """)
     gr.HTML(title_html)
 
-    input_image = gr.Image(label="Input (*.png, *.webp, *.jpeg, *.jpg, *.gif, *.bmp, *.heic)", show_label=True, type="filepath", height=600, elem_id="image-input")
-    rotation = gr.Radio([["No rotation", 0], ["⤵ Rotate +90°", 90], ["↩ Return 180°", 180], ["⤴ Rotate -90°", -90]], label="Orientation correction", info="Will apply the following rotation before restoring the image; the AI needs a good orientation to understand the content", value=0, interactive=True, visible=False)
+    input_image = gr.Image(label="Upload your photo", show_label=True, type="filepath", height=400, elem_id="image-input")
     with gr.Group():
-        prompt = gr.Textbox(label="Image description", info="Help the AI understand what the image represents; describe as much as possible, especially the details we can't see on the original image; you can write in any language", value="", placeholder="A 33 years old man, walking, in the street, Santiago, morning, Summer, photorealistic", lines=3)
-        prompt_hint = gr.HTML("You can use a <a href='"'https://huggingface.co/spaces/MaziyarPanahi/llava-llama-3-8b'"'>LlaVa space</a> to auto-generate the description of your image.")
-        upscale = gr.Radio([["x1", 1], ["x2", 2], ["x3", 3], ["x4", 4], ["x5", 5], ["x6", 6], ["x7", 7], ["x8", 8], ["x9", 9], ["x10", 10]], label="Upscale factor", info="Resolution x1 to x10", value=2, interactive=True)
-        output_format = gr.Radio([["As input", "input"], ["*.png", "png"], ["*.webp", "webp"], ["*.jpeg", "jpeg"], ["*.gif", "gif"], ["*.bmp", "bmp"]], label="Image format for result", info="File extention", value="input", interactive=True)
-        allocation = gr.Radio([["1 min", 1], ["2 min", 2], ["3 min", 3], ["4 min", 4], ["5 min", 5]], label="GPU allocation time", info="lower=May abort run, higher=Quota penalty for next runs", value=5, interactive=True)
-
-    with gr.Accordion("Pre-denoising (optional)", open=False):
-        gamma_correction = gr.Slider(label="Gamma Correction", info = "lower=lighter, higher=darker", minimum=0.1, maximum=2.0, value=1.0, step=0.1)
-        denoise_button = gr.Button(value="Pre-denoise")
-        denoise_image = gr.Image(label="Denoised image", show_label=True, type="filepath", sources=[], interactive = False, height=600, elem_id="image-s1")
-        denoise_information = gr.HTML(value="If present, the denoised image will be used for the restoration instead of the input image.", visible=False)
+        prompt = gr.Textbox(
+            label="Describe your photo",
+            info="Tell me about your photo so I can make it better.",
+            value="",
+            placeholder="Type a description...",
+            lines=3
+        )
+        upscale = gr.Radio(
+            [["x1", 1], ["x2", 2], ["x3", 3], ["x4", 4]],
+            label="Upscale factor",
+            info="Choose how much to enlarge the photo",
+            value=2,
+            interactive=True
+        )
+        allocation = gr.Radio(
+            [["1 min", 1], ["2 min", 2], ["3 min", 3], ["4 min", 4], ["5 min", 5]],
+            label="GPU allocation time (for Jon)",
+            info="You can ignore this setting",
+            value=4,
+            interactive=True
+        )
+
+    gamma_correction = gr.Number(value=1.0, visible=False)  # Hidden component with default value 1.0
 
     with gr.Accordion("Advanced options", open=False):
-        a_prompt = gr.Textbox(label="Additional image description",
-                              info="Completes the main image description",
-                              value='Cinematic, High Contrast, highly detailed, taken using a Canon EOS R '
-                                    'camera, hyper detailed photo - realistic maximum detail, 32k, Color '
-                                    'Grading, ultra HD, extreme meticulous detailing, skin pore detailing, '
-                                    'hyper sharpness, perfect without deformations.',
-                              lines=3)
-        n_prompt = gr.Textbox(label="Negative image description",
-                              info="Disambiguate by listing what the image does NOT represent",
-                              value='painting, oil painting, illustration, drawing, art, sketch, anime, '
-                                    'cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, unsharp, weird textures, ugly, dirty, messy, '
-                                    'worst quality, low quality, frames, watermark, signature, jpeg artifacts, '
-                                    'deformed, lowres, over-smooth',
-                              lines=3)
-        edm_steps = gr.Slider(label="Steps", info="lower=faster, higher=more details", minimum=1, maximum=200, value=default_setting.edm_steps if torch.cuda.device_count() > 0 else 1, step=1)
-        num_samples = gr.Slider(label="Num Samples", info="Number of generated results", minimum=1, maximum=4 if not args.use_image_slider else 1
-                                , value=1, step=1)
-        min_size = gr.Slider(label="Minimum size", info="Minimum height, minimum width of the result", minimum=32, maximum=4096, value=1024, step=32)
-        downscale = gr.Radio([["/1", 1], ["/2", 2], ["/3", 3], ["/4", 4], ["/5", 5], ["/6", 6], ["/7", 7], ["/8", 8], ["/9", 9], ["/10", 10]], label="Pre-downscale factor", info="Reducing blurred image reduce the process time", value=1, interactive=True)
+        a_prompt = gr.Textbox(
+            label="Additional image description",
+            info="Completes the main image description",
+            value='Cinematic, High Contrast, highly detailed, taken using a Canon EOS R '
+                  'camera, hyper detailed photo - realistic maximum detail, 32k, Color '
+                  'Grading, ultra HD, extreme meticulous detailing, skin pore detailing, '
+                  'hyper sharpness, perfect without deformations.',
+            lines=3
+        )
+        n_prompt = gr.Textbox(
+            label="Negative image description",
+            info="Disambiguate by listing what the image does NOT represent",
+            value='painting, oil painting, illustration, drawing, art, sketch, anime, '
+                  'cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, unsharp, weird textures, ugly, dirty, messy, '
+                  'worst quality, low quality, frames, watermark, signature, jpeg artifacts, '
+                  'deformed, lowres, over-smooth',
+            lines=3
+        )
+        edm_steps = gr.Slider(
+            label="Steps",
+            info="Lower=faster, higher=more details",
+            minimum=1,
+            maximum=200,
+            value=default_setting.edm_steps if torch.cuda.device_count() > 0 else 1,
+            step=1
+        )
+        num_samples = gr.Slider(
+            label="Num Samples",
+            info="Number of generated results",
+            minimum=1,
+            maximum=4 if not args.use_image_slider else 1,
+            value=1,
+            step=1
+        )
+        min_size = gr.Slider(
+            label="Minimum size",
+            info="Minimum height, minimum width of the result",
+            minimum=32,
+            maximum=4096,
+            value=1024,
+            step=32
+        )
+        downscale = gr.Radio(
+            [["/1", 1], ["/2", 2], ["/3", 3], ["/4", 4]],
+            label="Pre-downscale factor",
+            info="Reducing blurred image reduces the process time",
+            value=1,
+            interactive=True
+        )
         with gr.Row():
             with gr.Column():
-                model_select = gr.Radio([["💃 Quality (v0-Q)", "v0-Q"], ["🎯 Fidelity (v0-F)", "v0-F"]], label="Model Selection", info="Pretrained model", value="v0-Q",
-                                        interactive=True)
+                model_select = gr.Radio(
+                    [["💃 Quality (v0-Q)", "v0-Q"], ["🎯 Fidelity (v0-F)", "v0-F"]],
+                    label="Model Selection",
+                    info="Pretrained model",
+                    value="v0-Q",
+                    interactive=True
+                )
             with gr.Column():
-                color_fix_type = gr.Radio([["None", "None"], ["AdaIn (improve as a photo)", "AdaIn"], ["Wavelet (for JPEG artifacts)", "Wavelet"]], label="Color-Fix Type", info="AdaIn=Improve following a style, Wavelet=For JPEG artifacts", value="AdaIn",
-                                          interactive=True)
-        s_cfg = gr.Slider(label="Text Guidance Scale", info="lower=follow the image, higher=follow the prompt", minimum=1.0, maximum=15.0,
-                          value=default_setting.s_cfg_Quality if torch.cuda.device_count() > 0 else 1.0, step=0.1)
-        s_stage2 = gr.Slider(label="Restoring Guidance Strength", minimum=0., maximum=1., value=1., step=0.05)
-        s_stage1 = gr.Slider(label="Pre-denoising Guidance Strength", minimum=-1.0, maximum=6.0, value=-1.0, step=1.0)
-        s_churn = gr.Slider(label="S-Churn", minimum=0, maximum=40, value=5, step=1)
-        s_noise = gr.Slider(label="S-Noise", minimum=1.0, maximum=1.1, value=1.003, step=0.001)
+                color_fix_type = gr.Radio(
+                    [["None", "None"], ["AdaIn (improve as a photo)", "AdaIn"], ["Wavelet (for JPEG artifacts)", "Wavelet"]],
+                    label="Color-Fix Type",
+                    info="AdaIn=Improve following a style, Wavelet=For JPEG artifacts",
+                    value="AdaIn",
+                    interactive=True
+                )
+        s_cfg = gr.Slider(
+            label="Text Guidance Scale",
+            info="Lower=follow the image, higher=follow the prompt",
+            minimum=1.0,
+            maximum=15.0,
+            value=default_setting.s_cfg_Quality if torch.cuda.device_count() > 0 else 1.0,
+            step=0.1
+        )
+        s_stage2 = gr.Slider(
+            label="Restoring Guidance Strength",
+            minimum=0.,
+            maximum=1.,
+            value=1.,
+            step=0.05
+        )
+        s_stage1 = gr.Slider(
+            label="Pre-denoising Guidance Strength",
+            minimum=-1.0,
+            maximum=6.0,
+            value=-1.0,
+            step=1.0
+        )
+        s_churn = gr.Slider(
+            label="S-Churn",
+            minimum=0,
+            maximum=40,
+            value=5,
+            step=1
+        )
+        s_noise = gr.Slider(
+            label="S-Noise",
+            minimum=1.0,
+            maximum=1.1,
+            value=1.003,
+            step=0.001
+        )
         with gr.Row():
             with gr.Column():
                 linear_CFG = gr.Checkbox(label="Linear CFG", value=True)
-                spt_linear_CFG = gr.Slider(label="CFG Start", minimum=1.0,
-                                                maximum=9.0, value=default_setting.spt_linear_CFG_Quality if torch.cuda.device_count() > 0 else 1.0, step=0.5)
+                spt_linear_CFG = gr.Slider(
+                    label="CFG Start",
+                    minimum=1.0,
+                    maximum=9.0,
+                    value=default_setting.spt_linear_CFG_Quality if torch.cuda.device_count() > 0 else 1.0,
+                    step=0.5
+                )
             with gr.Column():
                 linear_s_stage2 = gr.Checkbox(label="Linear Restoring Guidance", value=False)
-                spt_linear_s_stage2 = gr.Slider(label="Guidance Start", minimum=0.,
-                                                maximum=1., value=0., step=0.05)
+                spt_linear_s_stage2 = gr.Slider(
+                    label="Guidance Start",
+                    minimum=0.,
+                    maximum=1.,
+                    value=0.,
+                    step=0.05
+                )
             with gr.Column():
-                diff_dtype = gr.Radio([["fp32 (precision)", "fp32"], ["fp16 (medium)", "fp16"], ["bf16 (speed)", "bf16"]], label="Diffusion Data Type", value="fp32",
-                                      interactive=True)
+                diff_dtype = gr.Radio(
+                    [["fp32 (precision)", "fp32"], ["fp16 (medium)", "fp16"], ["bf16 (speed)", "bf16"]],
+                    label="Diffusion Data Type",
+                    value="fp32",
+                    interactive=True
+                )
             with gr.Column():
-                ae_dtype = gr.Radio([["fp32 (precision)", "fp32"], ["bf16 (speed)", "bf16"]], label="Auto-Encoder Data Type", value="fp32",
-                                    interactive=True)
-        randomize_seed = gr.Checkbox(label = "\U0001F3B2 Randomize seed", value = True, info = "If checked, result is always different")
-        seed = gr.Slider(label="Seed", minimum=0, maximum=max_64_bit_int, step=1, randomize=True)
+                ae_dtype = gr.Radio(
+                    [["fp32 (precision)", "fp32"], ["bf16 (speed)", "bf16"]],
+                    label="Auto-Encoder Data Type",
+                    value="fp32",
+                    interactive=True
+                )
+        randomize_seed = gr.Checkbox(
+            label="\U0001F3B2 Randomize seed",
+            value=True,
+            info="If checked, result is always different"
+        )
+        seed = gr.Slider(
+            label="Seed",
+            minimum=0,
+            maximum=max_64_bit_int,
+            step=1,
+            randomize=True
+        )
         with gr.Group():
-            param_setting = gr.Radio(["Quality", "Fidelity"], interactive=True, label="Presetting", value = "Quality")
+            param_setting = gr.Radio(
+                ["Quality", "Fidelity"],
+                interactive=True,
+                label="Presetting",
+                value="Quality"
+            )
             restart_button = gr.Button(value="Apply presetting")
 
     with gr.Column():
-        diffusion_button = gr.Button(value="🚀 Upscale/Restore", variant = "primary", elem_id = "process_button")
-        reset_btn = gr.Button(value="🧹 Reinit page", variant="stop", elem_id="reset_button", visible = False)
-
-        restore_information = gr.HTML(value = "Restart the process to get another result.", visible = False)
-        result_slider = ImageSlider(label = 'Comparator', show_label = False, interactive = False, elem_id = "slider1", show_download_button = False)
-        result_gallery = gr.Gallery(label = 'Downloadable results', show_label = True, interactive = False, elem_id = "gallery1")
-
-    gr.Examples(
-        examples = [
-                [
-                    "./Examples/Example1.png",
-                    0,
-                    None,
-                    "Group of people, walking, happy, in the street, photorealistic, 8k, extremely detailled",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    2,
-                    1024,
-                    1,
-                    8,
-                    200,
-                    -1,
-                    1,
-                    7.5,
-                    False,
-                    42,
-                    5,
-                    1.003,
-                    "AdaIn",
-                    "fp16",
-                    "bf16",
-                    1.0,
-                    True,
-                    4,
-                    False,
-                    0.,
-                    "v0-Q",
-                    "input",
-                    5
-                ],
-                [
-                    "./Examples/Example2.jpeg",
-                    0,
-                    None,
-                    "La cabeza de un gato atigrado, en una casa, fotorrealista, 8k, extremadamente detallada",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    1,
-                    1024,
-                    1,
-                    1,
-                    200,
-                    -1,
-                    1,
-                    7.5,
-                    False,
-                    42,
-                    5,
-                    1.003,
-                    "Wavelet",
-                    "fp16",
-                    "bf16",
-                    1.0,
-                    True,
-                    4,
-                    False,
-                    0.,
-                    "v0-Q",
-                    "input",
-                    4
-                ],
-                [
-                    "./Examples/Example3.webp",
-                    0,
-                    None,
-                    "A red apple",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    1,
-                    1024,
-                    1,
-                    1,
-                    200,
-                    -1,
-                    1,
-                    7.5,
-                    False,
-                    42,
-                    5,
-                    1.003,
-                    "Wavelet",
-                    "fp16",
-                    "bf16",
-                    1.0,
-                    True,
-                    4,
-                    False,
-                    0.,
-                    "v0-Q",
-                    "input",
-                    4
-                ],
-                [
-                    "./Examples/Example3.webp",
-                    0,
-                    None,
-                    "A red marble",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    1,
-                    1024,
-                    1,
-                    1,
-                    200,
-                    -1,
-                    1,
-                    7.5,
-                    False,
-                    42,
-                    5,
-                    1.003,
-                    "Wavelet",
-                    "fp16",
-                    "bf16",
-                    1.0,
-                    True,
-                    4,
-                    False,
-                    0.,
-                    "v0-Q",
-                    "input",
-                    4
-                ],
-            ],
-        run_on_click = True,
-        fn = stage2_process,
-	    inputs = [
+        diffusion_button = gr.Button(
+            value="🚀 Enhance Photo",
+            variant="primary",
+            elem_id="process_button"
+        )
+        reset_btn = gr.Button(
+            value="🧹 Reset",
+            variant="stop",
+            elem_id="reset_button",
+            visible=False
+        )
+
+        restore_information = gr.HTML(
+            value="Start the process again if you want a different result.",
+            visible=False
+        )
+        result_slider = ImageSlider(
+            label='Comparator',
+            show_label=False,
+            interactive=False,
+            elem_id="slider1",
+            show_download_button=False
+        )
+        result_gallery = gr.Gallery(
+            label='Downloadable results',
+            show_label=True,
+            interactive=False,
+            elem_id="gallery1"
+        )
+
+    input_image.upload(
+        fn=process_uploaded_image,
+        inputs=input_image,
+        outputs=input_image,
+        queue=False
+    )
+
+    input_image.upload(
+        fn=check_upload,
+        inputs=input_image,
+        outputs=[],
+        queue=False,
+        show_progress=False
+    )
+
+    diffusion_button.click(
+        fn=update_seed,
+        inputs=[randomize_seed, seed],
+        outputs=[seed],
+        queue=False,
+        show_progress=False
+    ).then(
+        fn=check,
+        inputs=[input_image],
+        outputs=[],
+        queue=False,
+        show_progress=False
+    ).success(
+        fn=stage2_process,
+        inputs=[
             input_image,
-            rotation,
-            denoise_image,
             prompt,
             a_prompt,
             n_prompt,
@@ -758,124 +700,63 @@ with gr.Blocks() as interface:
             s_stage1,
             s_stage2,
             s_cfg,
-            randomize_seed,
             seed,
             s_churn,
             s_noise,
             color_fix_type,
             diff_dtype,
             ae_dtype,
-            gamma_correction,
+            gamma_correction,  # Use the hidden gamma_correction component
             linear_CFG,
             linear_s_stage2,
             spt_linear_CFG,
             spt_linear_s_stage2,
             model_select,
-            output_format,
             allocation
         ],
-	    outputs = [
+        outputs=[
             result_slider,
             result_gallery,
             restore_information,
             reset_btn
-        ],
-        cache_examples = False,
+        ]
+    ).success(
+        fn=log_information,
+        inputs=[result_gallery],
+        outputs=[],
+        queue=False,
+        show_progress=False
     )
 
-    with gr.Row():
-        gr.Markdown(claim_md)
-    
-    input_image.upload(fn = check_upload, inputs = [
-        input_image
-    ], outputs = [
-        rotation
-    ], queue = False, show_progress = False)
-
-    denoise_button.click(fn = check, inputs = [
-        input_image
-    ], outputs = [], queue = False, show_progress = False).success(fn = stage1_process, inputs = [
-        input_image,
-        gamma_correction,
-        diff_dtype,
-        ae_dtype
-    ], outputs=[
-        denoise_image,
-        denoise_information
-    ])
-
-    diffusion_button.click(fn = update_seed, inputs = [
-        randomize_seed,
-        seed
-    ], outputs = [
-        seed
-    ], queue = False, show_progress = False).then(fn = check, inputs = [
-        input_image
-    ], outputs = [], queue = False, show_progress = False).success(fn=stage2_process, inputs = [
-        input_image,
-        rotation,
-        denoise_image,
-        prompt,
-        a_prompt,
-        n_prompt,
-        num_samples,
-        min_size,
-        downscale,
-        upscale,
-        edm_steps,
-        s_stage1,
-        s_stage2,
-        s_cfg,
-        randomize_seed,
-        seed,
-        s_churn,
-        s_noise,
-        color_fix_type,
-        diff_dtype,
-        ae_dtype,
-        gamma_correction,
-        linear_CFG,
-        linear_s_stage2,
-        spt_linear_CFG,
-        spt_linear_s_stage2,
-        model_select,
-        output_format,
-        allocation
-    ], outputs = [
-        result_slider,
-        result_gallery,
-        restore_information,
-        reset_btn
-    ]).success(fn = log_information, inputs = [
-        result_gallery
-    ], outputs = [], queue = False, show_progress = False)
-
     result_gallery.change(on_select_result, [result_slider, result_gallery], result_slider)
     result_gallery.select(on_select_result, [result_slider, result_gallery], result_slider)
 
-    restart_button.click(fn = load_and_reset, inputs = [
-        param_setting
-    ], outputs = [
-        edm_steps,
-        s_cfg,
-        s_stage2,
-        s_stage1,
-        s_churn,
-        s_noise,
-        a_prompt,
-        n_prompt,
-        color_fix_type,
-        linear_CFG,
-        linear_s_stage2,
-        spt_linear_CFG,
-        spt_linear_s_stage2,
-        model_select
-    ])
-
-    reset_btn.click(fn = reset, inputs = [], outputs = [
+    restart_button.click(
+        fn=load_and_reset,
+        inputs=[param_setting],
+        outputs=[
+            edm_steps,
+            s_cfg,
+            s_stage2,
+            s_stage1,
+            s_churn,
+            s_noise,
+            a_prompt,
+            n_prompt,
+            color_fix_type,
+            linear_CFG,
+            linear_s_stage2,
+            spt_linear_CFG,
+            spt_linear_s_stage2,
+            model_select
+        ]
+    )
+
+    reset_btn.click(
+        fn=reset,
+        inputs=[],
+        outputs=[
             input_image,
-            rotation,
-            denoise_image,
             prompt,
             a_prompt,
             n_prompt,
@@ -887,21 +768,22 @@ with gr.Blocks() as interface:
             s_stage1,
             s_stage2,
             s_cfg,
-            randomize_seed,
             seed,
             s_churn,
             s_noise,
             color_fix_type,
             diff_dtype,
             ae_dtype,
-            gamma_correction,
+            gamma_correction,  # Use the hidden gamma_correction component
             linear_CFG,
             linear_s_stage2,
             spt_linear_CFG,
             spt_linear_s_stage2,
             model_select,
-            output_format,
             allocation
-        ], queue = False, show_progress = False)
-        
+        ],
+        queue=False,
+        show_progress=False
+    )
+
     interface.queue(10).launch()