Upload custom-hires-fix-for-automatic1111 using SD-Hub

custom-hires-fix-for-automatic1111/README.md

@@ -0,0 +1,29 @@
+# Custom Hires Fix (webui Extension)
+## Webui Extension for customizing highres fix and improve details (currently separated from original highres fix)
+
+
+#### Update 16.10.23:
+- added ControlNet support: choose preprocessor/model in CN settings, but don't enable unit
+- added Lora support: put Lora in extension prompt to enable Lora only for upscaling, put Lora in negative prompt to disable active Lora
+
+#### Update 02.07.23:
+- code rewritten again
+- simplified settings
+- fixed batch generation and image saving
+
+#### Update 13.06.23:
+- added gaussian noise instead of random
+
+#### Update 29.05.23:
+- added ToMe optomization in second pass, latest Auto1111 update required, controlled via "Token merging ratio for high-res pass" in settings
+- added "Sharp" setting, should be used only with "Smoothness" if image is too blurry
+
+#### Update 12.05.23:
+- added smoothness for negative, completely fix ghosting/smears/dirt on flat colors with high denoising
+
+#### Update 02.04.23:
+ ###### Don't forget to clear ui-config.json!
+- upscale separated from original high-res fix
+- now works with img2img
+- many fixes
+

custom-hires-fix-for-automatic1111/config.yaml

@@ -0,0 +1,17 @@
+width: 1536
+height: 0
+prompt: ''
+negative_prompt: ''
+steps: 15
+first_upscaler: R-ESRGAN 4x+ Anime6B
+second_upscaler: R-ESRGAN 4x+ Anime6B
+first_latent: 0.3
+second_latent: 0.1
+strength: 1.25
+filter: Noise sync (sharp)
+filter_offset: 0
+denoise_offset: 0.05
+clip_skip: 0
+sampler: Euler Dy
+cn_ref: false
+start_control_at: 0

custom-hires-fix-for-automatic1111/scripts/custom_hires_fix.py

@@ -0,0 +1,572 @@
+
+import math
+import json
+from copy import copy
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import torch
+from PIL import Image
+
+from modules import scripts, shared, processing, sd_schedulers, sd_samplers, script_callbacks, rng
+from modules import images, devices, prompt_parser, sd_models, extra_networks
+
+# Optional deps (best-effort)
+def _safe_import(modname, pipname=None):
+    try:
+        __import__(modname)
+        return True
+    except Exception:
+        try:
+            import pip
+            if hasattr(pip, "main"):
+                pip.main(["install", pipname or modname])
+            else:
+                pip._internal.main(["install", pipname or modname])
+            __import__(modname)
+            return True
+        except Exception:
+            return False
+
+_safe_import("omegaconf")
+_safe_import("kornia")
+_safe_import("k_diffusion", "k-diffusion")
+
+try:
+    from omegaconf import OmegaConf, DictConfig  # type: ignore
+except Exception:  # graceful fallback if OmegaConf not available
+    class DictConfig(dict):  # minimal stub
+        pass
+    class OmegaConf:  # minimal stub
+        @staticmethod
+        def load(path):
+            return DictConfig()
+        @staticmethod
+        def create(obj):
+            return DictConfig(obj)
+
+import kornia  # type: ignore
+import k_diffusion as K  # type: ignore
+
+quote_swap = str.maketrans("\'\"", "\"\'")
+config_path = (Path(__file__).parent.resolve() / "../config.yaml").resolve()
+
+
+class CustomHiresFix(scripts.Script):
+    """Two-stage img2img upscaling with optional latent mixing and prompt overrides.
+    Adds: ratio-scaling, sampler/scheduler wiring, PNG-info logging, and a UI flag
+    to add +3 CFG only on the second pass.
+    """
+    def __init__(self):
+        super().__init__()
+        # Load or init config
+        if config_path.exists():
+            try:
+                self.config: DictConfig = OmegaConf.load(str(config_path)) or OmegaConf.create({})  # type: ignore
+            except Exception:
+                self.config = OmegaConf.create({})  # type: ignore
+        else:
+            self.config = OmegaConf.create({})  # type: ignore
+
+        # Runtime state
+        self.p = None
+        self.pp = None
+        self.cfg = 0.0
+        self.sampler = None
+        self.cond = None
+        self.uncond = None
+        self.width = None
+        self.height = None
+        self._callback_set = False
+        self._orig_clip_skip = None
+        self._cn_units = []
+        self._use_cn = False
+
+    # ---- A1111 Script API ----
+    def title(self):
+        return "Custom Hires Fix"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        sampler_names = ["Restart + DPM++ 3M SDE"] + [x.name for x in sd_samplers.visible_samplers()]
+        scheduler_names = ["Use same scheduler"] + [x.label for x in sd_schedulers.schedulers]
+
+        with gr.Accordion(label="Custom Hires Fix", open=False) as enable_box:
+            enable = gr.Checkbox(label="Enable extension", value=bool(self.config.get("enable", False)))
+
+            with gr.Row():
+                ratio = gr.Slider(minimum=0.0, maximum=4.0, step=0.05, label="Upscale by (ratio)",
+                                  value=float(self.config.get("ratio", 0.0)))
+                width = gr.Slider(minimum=0, maximum=2048, step=8, label="Resize width to",
+                                  value=int(self.config.get("width", 0)))
+                height = gr.Slider(minimum=0, maximum=2048, step=8, label="Resize height to",
+                                   value=int(self.config.get("height", 0)))
+                steps = gr.Slider(minimum=1, maximum=50, step=1, label="Hires steps",
+                                  value=int(self.config.get("steps", 20)))
+
+            with gr.Row():
+                first_upscaler = gr.Dropdown([x.name for x in shared.sd_upscalers],
+                                             label="First upscaler", value=self.config.get("first_upscaler", "R-ESRGAN 4x+"))
+                second_upscaler = gr.Dropdown([x.name for x in shared.sd_upscalers],
+                                              label="Second upscaler", value=self.config.get("second_upscaler", "R-ESRGAN 4x+"))
+
+            with gr.Row():
+                first_latent = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Latent mix (first stage)",
+                                         value=float(self.config.get("first_latent", 0.3)))
+                second_latent = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Latent mix (second stage)",
+                                          value=float(self.config.get("second_latent", 0.1)))
+
+            with gr.Row():
+                filter_mode = gr.Dropdown(["Noise sync (sharp)", "Morphological (smooth)", "Combined (balanced)"],
+                                          label="Filter mode", value=self.config.get("filter_mode", "Noise sync (sharp)"))
+                strength = gr.Slider(minimum=0.5, maximum=4.0, step=0.1, label="Generation strength",
+                                     value=float(self.config.get("strength", 2.0)))
+                denoise_offset = gr.Slider(minimum=-0.1, maximum=0.2, step=0.01, label="Denoise offset",
+                                           value=float(self.config.get("denoise_offset", 0.05)))
+
+            with gr.Row():
+                prompt = gr.Textbox(label="Prompt override", placeholder="Leave empty to use main UI prompt",
+                                    value=self.config.get("prompt", ""))
+                negative_prompt = gr.Textbox(label="Negative prompt override", placeholder="Leave empty to use main UI negative prompt",
+                                             value=self.config.get("negative_prompt", ""))
+
+            with gr.Accordion(label="Extra", open=False):
+                with gr.Row():
+                    filter_offset = gr.Slider(minimum=-1.0, maximum=1.0, step=0.1, label="Filter offset",
+                                              value=float(self.config.get("filter_offset", 0.0)))
+                    clip_skip = gr.Slider(minimum=0, maximum=12, step=1, label="CLIP skip (0 = keep)",
+                                          value=int(self.config.get("clip_skip", 0)))
+                with gr.Row():
+                    sampler = gr.Dropdown(sampler_names, label="Sampler", value=self.config.get("sampler", sampler_names[0]))
+                    cfg = gr.Slider(minimum=0, maximum=30, step=0.5, label="CFG Scale",
+                                    value=float(self.config.get("cfg", 7.0)))
+                    # NEW: checkbox to add +3 CFG on second pass
+                    cfg_second_pass_boost = gr.Checkbox(label="+3 CFG на втором проходе",
+                                                        value=bool(self.config.get("cfg_second_pass_boost", True)))
+                    scheduler = gr.Dropdown(choices=scheduler_names, label="Schedule type",
+                                            value=self.config.get("scheduler", scheduler_names[0]))
+                with gr.Row():
+                    cn_ref = gr.Checkbox(label="Use last image as ControlNet reference", value=bool(self.config.get("cn_ref", False)))
+                    start_control_at = gr.Slider(minimum=0.0, maximum=0.7, step=0.01, label="CN start (enabled units)",
+                                                 value=float(self.config.get("start_control_at", 0.0)))
+
+        # Mutual exclusivity helpers
+        width.change(fn=lambda x: gr.update(value=0), inputs=width, outputs=height)
+        height.change(fn=lambda x: gr.update(value=0), inputs=height, outputs=width)
+        ratio.change(fn=lambda x: (gr.update(value=0), gr.update(value=0)), inputs=ratio, outputs=[width, height])
+
+        # infotext paste support
+        def read_params(d, key, default=None):
+            try:
+                return d["Custom Hires Fix"].get(key, default)
+            except Exception:
+                return default
+
+        self.infotext_fields = [
+            (enable, lambda d: "Custom Hires Fix" in d),
+            (ratio, lambda d: read_params(d, "ratio", 0.0)),
+            (width, lambda d: read_params(d, "width", 0)),
+            (height, lambda d: read_params(d, "height", 0)),
+            (steps, lambda d: read_params(d, "steps", 0)),
+            (first_upscaler, lambda d: read_params(d, "first_upscaler")),
+            (second_upscaler, lambda d: read_params(d, "second_upscaler")),
+            (first_latent, lambda d: read_params(d, "first_latent", 0.0)),
+            (second_latent, lambda d: read_params(d, "second_latent", 0.0)),
+            (prompt, lambda d: read_params(d, "prompt", "")),
+            (negative_prompt, lambda d: read_params(d, "negative_prompt", "")),
+            (strength, lambda d: read_params(d, "strength", 0.0)),
+            (filter_mode, lambda d: read_params(d, "filter_mode")),
+            (filter_offset, lambda d: read_params(d, "filter_offset", 0.0)),
+            (denoise_offset, lambda d: read_params(d, "denoise_offset", 0.0)),
+            (clip_skip, lambda d: read_params(d, "clip_skip", 0)),
+            (sampler, lambda d: read_params(d, "sampler", sampler_names[0])),
+            (cfg, lambda d: read_params(d, "cfg", 7.0)),
+            (cfg_second_pass_boost, lambda d: read_params(d, "cfg_second_pass_boost", True)),
+            (scheduler, lambda d: read_params(d, "scheduler", scheduler_names[0])),
+            (cn_ref, lambda d: read_params(d, "cn_ref", False)),
+            (start_control_at, lambda d: read_params(d, "start_control_at", 0.0)),
+        ]
+
+        return [
+            enable, ratio, width, height, steps,
+            first_upscaler, second_upscaler, first_latent, second_latent,
+            prompt, negative_prompt,
+            strength, filter_mode, filter_offset, denoise_offset,
+            clip_skip, sampler, cfg, cfg_second_pass_boost, scheduler,
+            cn_ref, start_control_at
+        ]
+
+    # Capture base processing object and optional ControlNet state
+    def process(self, p, *args, **kwargs):
+        self.p = p
+        self._cn_units = []
+        self._use_cn = False
+        # Try detect ControlNet (best-effort; path may vary across installs)
+        ext_candidates = [
+            "extensions.sd_webui_controlnet.scripts.external_code",
+            "extensions.sd-webui-controlnet.scripts.external_code",
+            "extensions-builtin.sd-webui-controlnet.scripts.external_code",
+        ]
+        self._cn_ext = None
+        for mod in ext_candidates:
+            try:
+                self._cn_ext = __import__(mod, fromlist=["external_code"])
+                break
+            except Exception:
+                continue
+        if self._cn_ext:
+            try:
+                units = self._cn_ext.get_all_units_in_processing(p)
+                self._cn_units = list(units) if units else []
+                self._use_cn = len(self._cn_units) > 0
+            except Exception:
+                self._use_cn = False
+
+    # Log settings into PNG-info (single JSON block)
+    def before_process_batch(self, p, *args, **kwargs):
+        if not getattr(self.config, "enable", False):
+            return
+        p.extra_generation_params["Custom Hires Fix"] = self.create_infotext
+
+    def create_infotext(self, p, *args, **kwargs):
+        scale_val = 0
+        if int(self.config.get("width", 0)) and int(self.config.get("height", 0)):
+            scale_val = f"{int(self.config.get('width'))}x{int(self.config.get('height'))}"
+        elif float(self.config.get("ratio", 0)):
+            scale_val = float(self.config.get("ratio"))
+
+        payload = {
+            "scale": scale_val,
+            "ratio": float(self.config.get("ratio", 0.0)),
+            "width": int(self.config.get("width", 0) or 0),
+            "height": int(self.config.get("height", 0) or 0),
+            "steps": int(self.config.get("steps", 20)),
+            "first_upscaler": self.config.get("first_upscaler", ""),
+            "second_upscaler": self.config.get("second_upscaler", ""),
+            "first_latent": float(self.config.get("first_latent", 0.3)),
+            "second_latent": float(self.config.get("second_latent", 0.1)),
+            "prompt": self.config.get("prompt", ""),
+            "negative_prompt": self.config.get("negative_prompt", ""),
+            "strength": float(self.config.get("strength", 2.0)),
+            "filter_mode": self.config.get("filter_mode", ""),
+            "filter_offset": float(self.config.get("filter_offset", 0.0)),
+            "denoise_offset": float(self.config.get("denoise_offset", 0.05)),
+            "clip_skip": int(self.config.get("clip_skip", 0)),
+            "sampler": self.config.get("sampler", ""),
+            "cfg": float(self.cfg),
+            "cfg_second_pass_boost": bool(self.config.get("cfg_second_pass_boost", True)),
+            "scheduler": self.config.get("scheduler", ""),
+            "cn_ref": bool(self.config.get("cn_ref", False)),
+            "start_control_at": float(self.config.get("start_control_at", 0.0)),
+        }
+        return json.dumps(payload, ensure_ascii=False).translate(quote_swap)
+
+    # --- Main postprocess hook ---
+    def postprocess_image(self, p, pp,
+                          enable, ratio, width, height, steps,
+                          first_upscaler, second_upscaler, first_latent, second_latent,
+                          prompt, negative_prompt,
+                          strength, filter_mode, filter_offset, denoise_offset,
+                          clip_skip, sampler, cfg, cfg_second_pass_boost, scheduler,
+                          cn_ref, start_control_at):
+        if not enable:
+            return
+
+        # Validate sizing: either both width&height, or both 0 + ratio>0, or single side for aspect fit
+        assert ((width and height) or
+                ((width == 0 and height == 0) and (ratio and ratio > 0)) or
+                (width > 0) or (height > 0)),             "Set width+height, or set both to 0 and ratio>0, or provide at least one dimension."
+
+        # Save config chosen in UI
+        self.pp = pp
+        self.config["enable"] = bool(enable)
+        self.config["ratio"] = float(ratio)
+        self.config["width"] = int(width)
+        self.config["height"] = int(height)
+        self.config["steps"] = int(steps)
+        self.config["first_upscaler"] = first_upscaler
+        self.config["second_upscaler"] = second_upscaler
+        self.config["first_latent"] = float(first_latent)
+        self.config["second_latent"] = float(second_latent)
+        self.config["prompt"] = prompt.strip()
+        self.config["negative_prompt"] = negative_prompt.strip()
+        self.config["strength"] = float(strength)
+        self.config["filter_mode"] = filter_mode
+        self.config["filter_offset"] = float(filter_offset)
+        self.config["denoise_offset"] = float(denoise_offset)
+        self.config["clip_skip"] = int(clip_skip)
+        self.config["sampler"] = sampler
+        self.config["cfg"] = float(cfg)
+        self.config["cfg_second_pass_boost"] = bool(cfg_second_pass_boost)
+        self.config["scheduler"] = scheduler
+        self.config["cn_ref"] = bool(cn_ref)
+        self.config["start_control_at"] = float(start_control_at)
+        self.cfg = float(cfg) if cfg else float(p.cfg_scale)
+
+        # Apply CLIP-skip temporarily for the two-pass run
+        self._orig_clip_skip = shared.opts.CLIP_stop_at_last_layers
+        if int(clip_skip) > 0:
+            shared.opts.CLIP_stop_at_last_layers = int(clip_skip)
+
+        # Make the sampler from selection
+        if "Restart" in sampler:
+            self.sampler = sd_samplers.create_sampler("Restart", p.sd_model)
+        else:
+            self.sampler = sd_samplers.create_sampler(sampler, p.sd_model)
+
+        # Respect scheduler selection
+        p.scheduler = p.scheduler if scheduler == "Use same scheduler" else scheduler
+
+        # Activate extra networks from prompts
+        _, loras_act = extra_networks.parse_prompt(self.config["prompt"])
+        extra_networks.activate(p, loras_act)
+        _, loras_deact = extra_networks.parse_prompt(self.config["negative_prompt"])
+        extra_networks.deactivate(p, loras_deact)
+
+        try:
+            with devices.autocast():
+                shared.state.nextjob()
+                x = self._first_pass(pp.image)
+                shared.state.nextjob()
+                x = self._second_pass(x)
+            sd_models.apply_token_merging(p.sd_model, p.get_token_merging_ratio())
+            pp.image = x
+        finally:
+            shared.opts.CLIP_stop_at_last_layers = self._orig_clip_skip
+            extra_networks.deactivate(p, loras_act)
+
+    # ---- Helpers ----
+    def _enable_controlnet(self, image_np: np.ndarray):
+        if not self._cn_ext:
+            return
+        for unit in self._cn_units:
+            try:
+                if getattr(unit, "model", "None") != "None":
+                    if getattr(unit, "enabled", True):
+                        unit.guidance_start = float(self.config.get("start_control_at", 0.0))
+                    unit.processor_res = min(image_np.shape[0], image_np.shape[1])
+                    unit.enabled = True
+                    if getattr(unit, "image", None) is None:
+                        unit.image = image_np
+                self.p.width = image_np.shape[1]
+                self.p.height = image_np.shape[0]
+            except Exception:
+                continue
+        try:
+            self._cn_ext.update_cn_script_in_processing(self.p, self._cn_units)
+            for script in self.p.scripts.alwayson_scripts:
+                if script.title().lower() == "controlnet":
+                    script.controlnet_hack(self.p)
+        except Exception:
+            pass
+
+    def _prepare_conditioning(self, width, height):
+        prompt = self.config.get("prompt", "").strip() or self.p.prompt.strip()
+        negative = self.config.get("negative_prompt", "").strip() or self.p.negative_prompt.strip()
+
+        # Parse extra networks and build cond
+        if not getattr(self.p, "disable_extra_networks", False):
+            try:
+                prompt, extra = extra_networks.parse_prompt(prompt)
+                if extra:
+                    extra_networks.activate(self.p, extra)
+            except Exception:
+                pass
+
+        if width and height and hasattr(prompt_parser, "SdConditioning"):
+            c = prompt_parser.SdConditioning([prompt], False, width, height)
+            uc = prompt_parser.SdConditioning([negative], False, width, height)
+        else:
+            c, uc = [prompt], [negative]
+        self.cond = prompt_parser.get_multicond_learned_conditioning(shared.sd_model, c, int(self.config.get("steps", 20)))
+        self.uncond = prompt_parser.get_learned_conditioning(shared.sd_model, uc, int(self.config.get("steps", 20)))
+
+    def _to_sample(self, x_img: Image.Image):
+        image = np.array(x_img).astype(np.float32) / 255.0
+        image = np.moveaxis(image, 2, 0)
+        decoded = torch.from_numpy(image).to(shared.device).to(devices.dtype_vae)
+        decoded = 2.0 * decoded - 1.0
+        encoded = shared.sd_model.encode_first_stage(decoded.unsqueeze(0).to(devices.dtype_vae))
+        sample = shared.sd_model.get_first_stage_encoding(encoded)
+        return decoded, sample
+
+    def _first_pass(self, x: Image.Image) -> Image.Image:
+        # Determine target size for first stage
+        ratio = x.width / x.height if x.height else 1.0
+        if int(self.config.get("width", 0)) == 0 and int(self.config.get("height", 0)) == 0 and float(self.config.get("ratio", 0)) > 0:
+            self.width = int(max(8, round(x.width * float(self.config["ratio"]) / 8) * 8))
+            self.height = int(max(8, round(x.height * float(self.config["ratio"]) / 8) * 8))
+        else:
+            if int(self.config.get("width", 0)) > 0 and int(self.config.get("height", 0)) > 0:
+                self.width, self.height = int(self.config["width"]), int(self.config["height"])
+            elif int(self.config.get("width", 0)) > 0:
+                self.width = int(self.config["width"])
+                self.height = int(round(self.width / ratio / 8) * 8)
+            elif int(self.config.get("height", 0)) > 0:
+                self.height = int(self.config["height"])
+                self.width = int(round(self.height * ratio / 8) * 8)
+            else:
+                self.width, self.height = x.width, x.height
+
+        sd_models.apply_token_merging(self.p.sd_model, self.p.get_token_merging_ratio(for_hr=True) / 2)
+
+        # Optional ControlNet
+        if self._use_cn:
+            self._enable_controlnet(np.array(x.resize((self.width, self.height))))
+
+        with devices.autocast(), torch.inference_mode():
+            self._prepare_conditioning(self.width, self.height)
+
+        # Upscale (image domain) then (optionally) blend latent
+        x_img = images.resize_image(0, x, self.width, self.height, upscaler_name=self.config.get("first_upscaler", "R-ESRGAN 4x+"))
+        decoded, sample = self._to_sample(x_img)
+        x_latent = torch.nn.functional.interpolate(sample, (self.height // 8, self.width // 8), mode="nearest")
+
+        first_latent = float(self.config.get("first_latent", 0.3))
+        if 0.0 <= first_latent <= 1.0:
+            sample = (x_latent * (1.0 - first_latent)) + (sample * first_latent)
+
+        image_conditioning = self.p.img2img_image_conditioning(decoded, sample)
+
+        # Denoise config for first pass
+        noise = torch.randn_like(sample)
+        steps = int(max(((self.p.steps - int(self.config.get("steps", 20))) / 2) + int(self.config.get("steps", 20)),
+                        int(self.config.get("steps", 20))))
+        self.p.denoising_strength = 0.33 + float(self.config.get("denoise_offset", 0.05)) * 0.2
+        self.p.cfg_scale = float(self.cfg)
+        # Simple polyexponential schedule override (optional)
+        def denoiser_override(n):
+            return K.sampling.get_sigmas_polyexponential(n, 0.005, 20, 0.6, devices.device)  # type: ignore
+
+        self.p.rng = rng.ImageRNG(sample.shape[1:], self.p.seeds, subseeds=self.p.subseeds,
+                                  subseed_strength=self.p.subseed_strength,
+                                  seed_resize_from_h=self.p.seed_resize_from_h, seed_resize_from_w=self.p.seed_resize_from_w)
+        self.p.sampler_noise_scheduler_override = denoiser_override
+        self.p.batch_size = 1
+
+        sampler = sd_samplers.create_sampler("Restart", shared.sd_model) if "Restart" in self.config.get("sampler", "")             else sd_samplers.create_sampler(self.config.get("sampler", "DPM++ 2M Karras"), shared.sd_model)
+
+        samples = sampler.sample_img2img(self.p, sample.to(devices.dtype), noise, self.cond, self.uncond,
+                                         steps=steps, image_conditioning=image_conditioning).to(devices.dtype_vae)
+
+        devices.torch_gc()
+        decoded_sample = processing.decode_first_stage(shared.sd_model, samples)
+        if math.isnan(decoded_sample.min() if hasattr(decoded_sample, "min") else 0):
+            devices.torch_gc()
+            samples = torch.clamp(samples, -3, 3)
+            decoded_sample = processing.decode_first_stage(shared.sd_model, samples)
+
+        decoded_sample = torch.clamp((decoded_sample + 1.0) / 2.0, min=0.0, max=1.0).squeeze()
+        x_np = 255.0 * np.moveaxis(decoded_sample.to(torch.float32).cpu().numpy(), 0, 2)
+        return Image.fromarray(x_np.astype(np.uint8))
+
+    def _second_pass(self, x: Image.Image) -> Image.Image:
+        # Target size for second stage (respect ratio if both dims are 0)
+        if (int(self.config.get("width", 0)) == 0 and int(self.config.get("height", 0)) == 0 and
+                float(self.config.get("ratio", 0)) > 0):
+            width = int(max(8, round(x.width * float(self.config["ratio"]) / 8) * 8))
+            height = int(max(8, round(x.height * float(self.config["ratio"]) / 8) * 8))
+        else:
+            aspect = x.width / x.height if x.height else 1.0
+            if int(self.config.get("width", 0)) > 0 and int(self.config.get("height", 0)) > 0:
+                width, height = int(self.config["width"]), int(self.config["height"])
+            elif int(self.config.get("width", 0)) > 0:
+                width = int(self.config["width"])
+                height = int(round(width / aspect / 8) * 8)
+            elif int(self.config.get("height", 0)) > 0:
+                height = int(self.config["height"])
+                width = int(round(height * aspect / 8) * 8)
+            else:
+                width, height = x.width, x.height
+
+        sd_models.apply_token_merging(self.p.sd_model, self.p.get_token_merging_ratio(for_hr=True))
+
+        if self._use_cn:
+            cn_img = x if bool(self.config.get("cn_ref", False)) else self.pp.image
+            self._enable_controlnet(np.array(cn_img.resize((width, height))))
+
+        with devices.autocast(), torch.inference_mode():
+            self._prepare_conditioning(width, height)
+
+        # Optional latent mix
+        x_latent = None
+        second_latent = float(self.config.get("second_latent", 0.1))
+        if second_latent > 0:
+            _, sample_from_img = self._to_sample(x)
+            x_latent = torch.nn.functional.interpolate(sample_from_img, (height // 8, width // 8), mode="nearest")
+
+        # Upscale to target and encode
+        if second_latent < 1.0:
+            x_up = images.resize_image(0, x, width, height, upscaler_name=self.config.get("second_upscaler", "R-ESRGAN 4x+"))
+            decoded, sample = self._to_sample(x_up)
+        else:
+            # Take from original x
+            decoded, sample = self._to_sample(x)
+
+        if x_latent is not None and 0.0 <= second_latent <= 1.0:
+            sample = (sample * (1.0 - second_latent)) + (x_latent * second_latent)
+
+        image_conditioning = self.p.img2img_image_conditioning(decoded, sample)
+
+        # Denoise config for second pass
+        noise = torch.randn_like(sample)
+        steps = int(self.config.get("steps", 20))
+        # NEW: checkbox controls +3 CFG on second pass
+        self.p.cfg_scale = (float(self.cfg) + 3.0) if bool(self.config.get("cfg_second_pass_boost", True)) else float(self.cfg)
+        self.p.denoising_strength = 0.45 + float(self.config.get("denoise_offset", 0.05)) * 0.2
+
+        def denoiser_override(n):
+            return K.sampling.get_sigmas_polyexponential(n, 0.01, 15, 0.5, devices.device)  # type: ignore
+
+        self.p.rng = rng.ImageRNG(sample.shape[1:], self.p.seeds, subseeds=self.p.subseeds,
+                                  subseed_strength=self.p.subseed_strength,
+                                  seed_resize_from_h=self.p.seed_resize_from_h, seed_resize_from_w=self.p.seed_resize_from_w)
+        self.p.sampler_noise_scheduler_override = denoiser_override
+        self.p.batch_size = 1
+
+        sampler = sd_samplers.create_sampler("Restart", shared.sd_model) if "Restart" in self.config.get("sampler", "")             else sd_samplers.create_sampler(self.config.get("sampler", "DPM++ 2M Karras"), shared.sd_model)
+
+        samples = sampler.sample_img2img(self.p, sample.to(devices.dtype), noise, self.cond, self.uncond,
+                                         steps=steps, image_conditioning=image_conditioning).to(devices.dtype_vae)
+
+        devices.torch_gc()
+        decoded_sample = processing.decode_first_stage(shared.sd_model, samples)
+        if math.isnan(decoded_sample.min() if hasattr(decoded_sample, "min") else 0):
+            devices.torch_gc()
+            samples = torch.clamp(samples, -3, 3)
+            decoded_sample = processing.decode_first_stage(shared.sd_model, samples)
+
+        decoded_sample = torch.clamp((decoded_sample + 1.0) / 2.0, min=0.0, max=1.0).squeeze()
+        x_np = 255.0 * np.moveaxis(decoded_sample.to(torch.float32).cpu().numpy(), 0, 2)
+        return Image.fromarray(x_np.astype(np.uint8))
+
+
+def parse_infotext(infotext, params):
+    try:
+        block = params.get("Custom Hires Fix")
+        if not block:
+            return
+        data = json.loads(block.translate(quote_swap)) if isinstance(block, str) else block
+        params["Custom Hires Fix"] = data
+        scale = data.get("scale", 0)
+        if isinstance(scale, str) and "x" in scale:
+            w, _, h = scale.partition("x")
+            data["ratio"] = 0.0
+            data["width"] = int(w)
+            data["height"] = int(h)
+        else:
+            try:
+                r = float(scale)
+            except Exception:
+                r = 0.0
+            data["ratio"] = r
+            data["width"] = int(data.get("width", 0) or 0)
+            data["height"] = int(data.get("height", 0) or 0)
+    except Exception:
+        pass
+
+# Register paste-params hook
+script_callbacks.on_infotext_pasted(parse_infotext)