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

custom-hires-fix-mod-for-automatic1111-2.2/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-mod-for-automatic1111-2.2/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-mod-for-automatic1111-2.2/scripts/custom_hires_fix.py

@@ -0,0 +1,1656 @@
+import math
+import json
+import hashlib
+from pathlib import Path
+from collections import OrderedDict
+
+import gradio as gr
+import numpy as np
+import torch
+from PIL import Image, ImageFilter
+
+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")
+_safe_import("skimage")
+_safe_import("cv2")
+
+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
+
+# skimage helpers (optional)
+try:
+    from skimage.exposure import match_histograms, equalize_adapthist  # type: ignore
+    from skimage import color as skcolor  # type: ignore
+    _SKIMAGE_OK = True
+except Exception:
+    _SKIMAGE_OK = False
+
+# OpenCV (optional)
+try:
+    import cv2  # type: ignore
+    _CV2_OK = True
+except Exception:
+    _CV2_OK = False
+
+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.
+
+    Features:
+    - Ratio/width/height or Megapixels target (+ quick MP buttons)
+    - Compact preset panel (global presets)
+    - Separate steps for 1st/2nd pass
+    - Per-pass sampler + scheduler
+    - CFG base + optional delta on 2nd pass
+    - Reuse seed/noise on 2nd pass
+    - Conditioning cache (LRU) with capacity
+    - Second-pass prompt (append/replace)
+    - Per-pass LoRA weight scaling
+    - Seamless tiling (+ overlap)
+    - VAE tiling toggle (low VRAM)
+    - Color match to original (strength) with presets
+    - Post-FX presets: CLAHE (local contrast), Unsharp Mask
+    - PNG-info serialization + paste support
+    - Final ×4 upscale (optional), with its own upscaler and tiling overlap for seam-safe stitching.
+    """
+    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.cond = None
+        self.uncond = None
+        self.width = None
+        self.height = None
+        self._orig_clip_skip = None
+        self._cn_units = []
+        self._use_cn = False
+
+        # Reuse state
+        self._saved_seeds = None
+        # subseeds may not exist in all pipelines; keep best-effort
+        self._saved_subseeds = None
+        self._saved_subseed_strength = None
+        self._saved_seed_resize_from_h = None
+        self._saved_seed_resize_from_w = None
+        self._first_noise = None
+        self._first_noise_shape = None
+
+        # Conditioning cache (LRU)
+        self._cond_cache: OrderedDict[str, tuple] = OrderedDict()
+
+        # VAE tiling state restore
+        self._orig_opt_vae_tiling = None
+
+        # Seamless tiling restore
+        self._orig_tiling = None
+        self._orig_tile_overlap = None
+
+        # Prompt override for second pass
+        self._override_prompt_second = None
+
+        # LoRA scaling factor per pass (used during _prepare_conditioning by pass context)
+        self._current_lora_factor = 1.0
+        # Scheduler restore state
+        self._orig_scheduler = None
+        self._orig_size = (None, None)
+ 
+    # ---- A1111 Script API ----
+    def title(self):
+        return "Custom Hires Fix"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        visible_names = [x.name for x in sd_samplers.visible_samplers()]
+        sampler_names = ["Restart + DPM++ 3M SDE"] + visible_names
+        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)))
+
+            # ---------- Compact preset panel ----------
+            with gr.Row():
+                quick_preset = gr.Dropdown(
+                    ["None", "Hi-Res Portrait", "Hi-Res Texture", "Hi-Res Illustration", "Hi-Res Product Shot"],
+                    label="Quick preset",
+                    value="None"
+                )
+                btn_apply_preset = gr.Button(value="Apply preset", variant="primary")
+
+                btn_mp_1 = gr.Button(value="MP 1.0")
+                btn_mp_2 = gr.Button(value="MP 2.0")
+                btn_mp_4 = gr.Button(value="MP 4.0")
+                btn_mp_8 = gr.Button(value="MP 8.0")
+
+            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=4096, step=8, label="Resize width to",
+                                  value=int(self.config.get("width", 0)))
+                height = gr.Slider(minimum=0, maximum=4096, step=8, label="Resize height to",
+                                   value=int(self.config.get("height", 0)))
+            # --------- Size helpers ---------
+            with gr.Row():
+                long_edge = gr.Slider(minimum=0, maximum=8192, step=8,
+                                      label="Resize by long edge (0 = off)",
+                                      value=int(self.config.get("long_edge", 0)))
+                btn_swap_wh = gr.Button(value="Swap W↔H")
+
+            with gr.Row():
+                steps_first = gr.Slider(minimum=1, maximum=100, step=1, label="Hires steps — 1st pass",
+                                        value=int(self.config.get("steps_first", max(1, int(self.config.get("steps", 20))))))
+                steps_second = gr.Slider(minimum=1, maximum=100, step=1, label="Hires steps — 2nd pass",
+                                         value=int(self.config.get("steps_second", int(self.config.get("steps", 20)))))
+
+            # --------- Per-pass denoising ---------
+            with gr.Row():
+                denoise_first = gr.Slider(minimum=0.0, maximum=1.0, step=0.01,
+                                          label="Denoising strength — 1st pass",
+                                          value=float(self.config.get("denoise_first", 0.33)))
+                denoise_second = gr.Slider(minimum=0.0, maximum=1.0, step=0.01,
+                                           label="Denoising strength — 2nd pass",
+                                           value=float(self.config.get("denoise_second", 0.45)))
+            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)))
+                # NEW: чекбокс включения адаптивной формы сигм
+                adaptive_sigma_enable = gr.Checkbox(label="Adaptive denoiser shaping (uses Filter/Strength)",
+                                                    value=bool(self.config.get("adaptive_sigma_enable", False)))
+
+            with gr.Row():
+                prompt = gr.Textbox(label="Prompt override (1st pass)", 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.Row():
+                second_pass_prompt = gr.Textbox(label="Second-pass prompt", placeholder="Append or replace on 2nd pass",
+                                                value=self.config.get("second_pass_prompt", ""))
+                second_pass_prompt_append = gr.Checkbox(label="Append instead of replace",
+                                                        value=bool(self.config.get("second_pass_prompt_append", True)))
+
+            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)))
+
+                # Per-pass sampler/scheduler
+                with gr.Row():
+                    sampler_first = gr.Dropdown(sampler_names, label="Sampler — 1st pass",
+                                                value=self.config.get("sampler_first", sampler_names[0]))
+                    sampler_second = gr.Dropdown(sampler_names, label="Sampler — 2nd pass",
+                                                 value=self.config.get("sampler_second", self.config.get("sampler", sampler_names[0])))
+                with gr.Row():
+                    scheduler_first = gr.Dropdown(
+                        choices=scheduler_names, label="Schedule type — 1st pass",
+                        value=self.config.get("scheduler_first", self.config.get("scheduler", scheduler_names[0]))
+                    )
+                    scheduler_second = gr.Dropdown(
+                        choices=scheduler_names, label="Schedule type — 2nd pass",
+                        value=self.config.get("scheduler_second", self.config.get("scheduler", scheduler_names[0]))
+                    )
+
+                # Restore scheduler toggle
+                restore_scheduler_after = gr.Checkbox(
+                    label="Restore scheduler after run",
+                    value=bool(self.config.get("restore_scheduler_after", True))
+                )
+ 
+                with gr.Row():
+                    cfg = gr.Slider(minimum=0, maximum=30, step=0.5, label="CFG Scale (base)",
+                                    value=float(self.config.get("cfg", 7.0)))
+                    cfg_second_pass_boost = gr.Checkbox(label="Enable CFG delta on 2nd pass",
+                                                        value=bool(self.config.get("cfg_second_pass_boost", True)))
+                    cfg_second_pass_delta = gr.Slider(minimum=-5.0, maximum=5.0, step=0.5, label="CFG delta (2nd pass)",
+                                                      value=float(self.config.get("cfg_second_pass_delta", 3.0)))
+
+                # Reuse seed/noise + Megapixels target
+                with gr.Row():
+                    reuse_seed_noise = gr.Checkbox(label="Reuse seed/noise on 2nd pass",
+                                                   value=bool(self.config.get("reuse_seed_noise", False)))
+                    mp_target_enabled = gr.Checkbox(label="Enable Megapixels target",
+                                                    value=bool(self.config.get("mp_target_enabled", False)))
+                    mp_target = gr.Slider(minimum=0.3, maximum=16.0, step=0.1, label="Megapixels",
+                                          value=float(self.config.get("mp_target", 2.0)))
+
+                # Conditioning cache controls
+                with gr.Row():
+                    cond_cache_enabled = gr.Checkbox(label="Enable conditioning cache (LRU)",
+                                                     value=bool(self.config.get("cond_cache_enabled", True)))
+                    cond_cache_max = gr.Slider(minimum=8, maximum=256, step=8, label="Conditioning cache size",
+                                               value=int(self.config.get("cond_cache_max", 64)))
+
+                # VAE tiling
+                with gr.Row():
+                    vae_tiling_enabled = gr.Checkbox(label="Enable VAE tiling (low VRAM)",
+                                                     value=bool(self.config.get("vae_tiling_enabled", False)))
+
+                # Seamless tiling
+                with gr.Row():
+                    seamless_tiling_enabled = gr.Checkbox(label="Seamless tiling (texture)",
+                                                          value=bool(self.config.get("seamless_tiling_enabled", False)))
+                    tile_overlap = gr.Slider(minimum=0, maximum=64, step=1, label="Tile overlap (px)",
+                                             value=int(self.config.get("tile_overlap", 12)))
+
+                # LoRA scaling
+                with gr.Row():
+                    lora_weight_first_factor = gr.Slider(minimum=0.0, maximum=2.0, step=0.05, label="LoRA weight × (1st pass)",
+                                                         value=float(self.config.get("lora_weight_first_factor", 1.0)))
+                    lora_weight_second_factor = gr.Slider(minimum=0.0, maximum=2.0, step=0.05, label="LoRA weight × (2nd pass)",
+                                                          value=float(self.config.get("lora_weight_second_factor", 1.0)))
+
+                # Match colors presets & controls
+                with gr.Row():
+                    match_colors_preset = gr.Dropdown(
+                        ["Off", "Subtle (0.3)", "Natural (0.5)", "Strong (0.8)"],
+                        label="Match colors preset",
+                        value=self.config.get("match_colors_preset", "Off")
+                    )
+                    match_colors_enabled = gr.Checkbox(label="Match colors to original",
+                                                       value=bool(self.config.get("match_colors_enabled", False)))
+                    match_colors_strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, label="Match strength",
+                                                      value=float(self.config.get("match_colors_strength", 0.5)))
+
+                # Post-processing presets & controls
+                with gr.Row():
+                    postfx_preset = gr.Dropdown(
+                        ["Off", "Soft clarity", "Portrait safe", "Texture boost", "Crisp detail"],
+                        label="Post-FX preset",
+                        value=self.config.get("postfx_preset", "Off")
+                    )
+                    clahe_enabled = gr.Checkbox(label="CLAHE (local contrast)",
+                                                value=bool(self.config.get("clahe_enabled", False)))
+                    clahe_clip = gr.Slider(minimum=1.0, maximum=5.0, step=0.1, label="CLAHE clip limit",
+                                           value=float(self.config.get("clahe_clip", 2.0)))
+                    clahe_tile_grid = gr.Slider(minimum=4, maximum=16, step=2, label="CLAHE tile grid",
+                                                value=int(self.config.get("clahe_tile_grid", 8)))
+
+                with gr.Row():
+                    unsharp_enabled = gr.Checkbox(label="Unsharp Mask (sharpen)",
+                                                  value=bool(self.config.get("unsharp_enabled", False)))
+                    unsharp_radius = gr.Slider(minimum=0.5, maximum=5.0, step=0.1, label="Unsharp radius",
+                                               value=float(self.config.get("unsharp_radius", 1.5)))
+                    unsharp_amount = gr.Slider(minimum=0.0, maximum=2.0, step=0.05, label="Unsharp amount",
+                                               value=float(self.config.get("unsharp_amount", 0.75)))
+                    unsharp_threshold = gr.Slider(minimum=0, maximum=10, step=1, label="Unsharp threshold",
+                                                  value=int(self.config.get("unsharp_threshold", 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)))
+
+                # --- Final ×4 upscale controls ---
+                with gr.Row():
+                    final_upscale_enable = gr.Checkbox(label="Final ×4 upscale (after 2nd pass)",
+                                                       value=bool(self.config.get("final_upscale_enable", False)))
+                    final_upscaler = gr.Dropdown([x.name for x in shared.sd_upscalers],
+                                                 label="Final upscaler", value=self.config.get("final_upscaler", "R-ESRGAN 4x+"))
+                with gr.Row():
+                    final_tile = gr.Slider(minimum=128, maximum=1024, step=32, label="Final tile size (px, pre-scale)",
+                                           value=int(self.config.get("final_tile", 512)))
+                    final_tile_overlap = gr.Slider(minimum=0, maximum=64, step=2, label="Final tile overlap (px, pre-scale)",
+                                                   value=int(self.config.get("final_tile_overlap", 16)))
+
+            # ---------- Preset logic (UI events) ----------
+            def _apply_match_preset(preset_name):
+                if preset_name == "Off":
+                    return (gr.update(value=False), gr.update(value=0.5))
+                if preset_name == "Subtle (0.3)":
+                    return (gr.update(value=True), gr.update(value=0.3))
+                if preset_name == "Natural (0.5)":
+                    return (gr.update(value=True), gr.update(value=0.5))
+                if preset_name == "Strong (0.8)":
+                    return (gr.update(value=True), gr.update(value=0.8))
+                return (gr.update(), gr.update())
+
+            def _apply_postfx_preset(preset_name):
+                # Returns: clahe_enabled, clahe_clip, clahe_tile_grid, unsharp_enabled, unsharp_radius, unsharp_amount, unsharp_threshold
+                if preset_name == "Off":
+                    return (gr.update(value=False), gr.update(value=2.0), gr.update(value=8),
+                            gr.update(value=False), gr.update(value=1.5), gr.update(value=0.75), gr.update(value=0))
+                if preset_name == "Soft clarity":
+                    return (gr.update(value=True), gr.update(value=1.8), gr.update(value=8),
+                            gr.update(value=True), gr.update(value=1.2), gr.update(value=0.6), gr.update(value=0))
+                if preset_name == "Portrait safe":
+                    return (gr.update(value=True), gr.update(value=1.6), gr.update(value=8),
+                            gr.update(value=True), gr.update(value=1.4), gr.update(value=0.8), gr.update(value=2))
+                if preset_name == "Texture boost":
+                    return (gr.update(value=True), gr.update(value=2.4), gr.update(value=8),
+                            gr.update(value=True), gr.update(value=1.6), gr.update(value=1.0), gr.update(value=0))
+                if preset_name == "Crisp detail":
+                    return (gr.update(value=True), gr.update(value=2.1), gr.update(value=8),
+                            gr.update(value=True), gr.update(value=1.3), gr.update(value=0.9), gr.update(value=0))
+                return (gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update())
+
+            def _apply_quick_preset(name):
+                # Returns a large tuple of updates for several controls
+                out = [
+                    gr.update(),  # steps_first
+                    gr.update(),  # steps_second
+                    gr.update(),  # cfg_second_pass_boost
+                    gr.update(),  # cfg_second_pass_delta
+                    gr.update(),  # sampler_first
+                    gr.update(),  # sampler_second
+                    gr.update(),  # scheduler_first
+                    gr.update(),  # scheduler_second
+                    gr.update(),  # vae_tiling_enabled
+                    gr.update(),  # seamless_tiling_enabled
+                    gr.update(),  # tile_overlap
+                    gr.update(),  # match_colors_preset
+                    gr.update(),  # match_colors_enabled
+                    gr.update(),  # match_colors_strength
+                    gr.update(),  # postfx_preset
+                    gr.update(),  # clahe_enabled
+                    gr.update(),  # clahe_clip
+                    gr.update(),  # clahe_tile_grid
+                    gr.update(),  # unsharp_enabled
+                    gr.update(),  # unsharp_radius
+                    gr.update(),  # unsharp_amount
+                    gr.update(),  # unsharp_threshold
+                    gr.update(),  # reuse_seed_noise
+                    gr.update(),  # cond_cache_max
+                    gr.update(),  # lora_weight_first_factor
+                    gr.update(),  # lora_weight_second_factor
+                    gr.update(),  # mp_target_enabled
+                    gr.update(),  # mp_target
+                ]
+                if name == "Hi-Res Portrait":
+                    out = [
+                        gr.update(value=18), gr.update(value=28),
+                        gr.update(value=True), gr.update(value=2.5),
+                        gr.update(value="DPM++ 2M Karras"), gr.update(value="DPM++ 3M SDE"),
+                        gr.update(value="Use same scheduler"), gr.update(value="Use same scheduler"),
+                        gr.update(value=True), gr.update(value=False), gr.update(value=12),
+                        gr.update(value="Subtle (0.3)"), gr.update(value=True), gr.update(value=0.3),
+                        gr.update(value="Portrait safe"), gr.update(value=True), gr.update(value=1.6), gr.update(value=8),
+                        gr.update(value=True), gr.update(value=1.4), gr.update(value=0.8), gr.update(value=2),
+                        gr.update(value=True), gr.update(value=64),
+                        gr.update(value=1.0), gr.update(value=1.1),
+                        gr.update(value=True), gr.update(value=2.0),
+                    ]
+                elif name == "Hi-Res Texture":
+                    out = [
+                        gr.update(value=14), gr.update(value=22),
+                        gr.update(value=True), gr.update(value=3.0),
+                        gr.update(value="DPM++ 2M Karras"), gr.update(value="DPM++ SDE Karras"),
+                        gr.update(value="Use same scheduler"), gr.update(value="Use same scheduler"),
+                        gr.update(value=True), gr.update(value=True), gr.update(value=12),
+                        gr.update(value="Off"), gr.update(value=False), gr.update(value=0.5),
+                        gr.update(value="Texture boost"), gr.update(value=True), gr.update(value=2.2), gr.update(value=8),
+                        gr.update(value=True), gr.update(value=1.6), gr.update(value=1.0), gr.update(value=0),
+                        gr.update(value=True), gr.update(value=128),
+                        gr.update(value=0.9), gr.update(value=1.25),
+                        gr.update(value=True), gr.update(value=4.0),
+                    ]
+                elif name == "Hi-Res Illustration":
+                    out = [
+                        gr.update(value=16), gr.update(value=24),
+                        gr.update(value=True), gr.update(value=2.0),
+                        gr.update(value="DPM++ 2M Karras"), gr.update(value="DPM++ 3M SDE"),
+                        gr.update(value="Use same scheduler"), gr.update(value="Use same scheduler"),
+                        gr.update(value=True), gr.update(value=False), gr.update(value=8),
+                        gr.update(value="Off"), gr.update(value=False), gr.update(value=0.5),
+                        gr.update(value="Crisp detail"), gr.update(value=True), gr.update(value=2.0), gr.update(value=8),
+                        gr.update(value=True), gr.update(value=1.2), gr.update(value=0.9), gr.update(value=0),
+                        gr.update(value=True), gr.update(value=64),
+                        gr.update(value=0.85), gr.update(value=1.2),
+                        gr.update(value=True), gr.update(value=2.0),
+                    ]
+                elif name == "Hi-Res Product Shot":
+                    out = [
+                        gr.update(value=18), gr.update(value=26),
+                        gr.update(value=True), gr.update(value=2.0),
+                        gr.update(value="DPM++ 2M Karras"), gr.update(value="DPM++ SDE Karras"),
+                        gr.update(value="Use same scheduler"), gr.update(value="Use same scheduler"),
+                        gr.update(value=True), gr.update(value=False), gr.update(value=8),
+                        gr.update(value="Natural (0.5)"), gr.update(value=True), gr.update(value=0.5),
+                        gr.update(value="Crisp detail"), gr.update(value=True), gr.update(value=2.1), gr.update(value=8),
+                        gr.update(value=True), gr.update(value=1.3), gr.update(value=0.9), gr.update(value=0),
+                        gr.update(value=True), gr.update(value=96),
+                        gr.update(value=1.0), gr.update(value=1.15),
+                        gr.update(value=True), gr.update(value=2.0),
+                    ]
+                return tuple(out)
+                
+            # --- Привязка событий пресетов ---
+            match_colors_preset.change(
+                fn=_apply_match_preset,
+                inputs=[match_colors_preset],
+                outputs=[match_colors_enabled, match_colors_strength]
+            )
+            postfx_preset.change(
+                fn=_apply_postfx_preset,
+                inputs=[postfx_preset],
+                outputs=[clahe_enabled, clahe_clip, clahe_tile_grid, unsharp_enabled, unsharp_radius, unsharp_amount, unsharp_threshold]
+            )
+            btn_apply_preset.click(
+                fn=_apply_quick_preset,
+                inputs=[quick_preset],
+                outputs=[
+                    steps_first, steps_second,
+                    cfg_second_pass_boost, cfg_second_pass_delta,
+                    sampler_first, sampler_second,
+                    scheduler_first, scheduler_second,
+                    vae_tiling_enabled, seamless_tiling_enabled, tile_overlap,
+                    match_colors_preset, match_colors_enabled, match_colors_strength,
+                    postfx_preset, clahe_enabled, clahe_clip, clahe_tile_grid,
+                    unsharp_enabled, unsharp_radius, unsharp_amount, unsharp_threshold,
+                    reuse_seed_noise, cond_cache_max,
+                    lora_weight_first_factor, lora_weight_second_factor,
+                    mp_target_enabled, mp_target
+                ]
+            )
+            # MP buttons
+            btn_mp_1.click(fn=lambda: (gr.update(value=True), gr.update(value=1.0)), inputs=[], outputs=[mp_target_enabled, mp_target])
+            btn_mp_2.click(fn=lambda: (gr.update(value=True), gr.update(value=2.0)), inputs=[], outputs=[mp_target_enabled, mp_target])
+            btn_mp_4.click(fn=lambda: (gr.update(value=True), gr.update(value=4.0)), inputs=[], outputs=[mp_target_enabled, mp_target])
+            btn_mp_8.click(fn=lambda: (gr.update(value=True), gr.update(value=8.0)), inputs=[], outputs=[mp_target_enabled, mp_target])
+
+        # 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])
+        # Long edge excludes ratio and explicit W/H
+        long_edge.change(fn=lambda _: (gr.update(value=0), gr.update(value=0), gr.update(value=0.0)),
+                         inputs=long_edge, outputs=[width, height, ratio])
+        # Swap button
+        btn_swap_wh.click(fn=lambda w, h: (h, w), inputs=[width, height], 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)),
+            (long_edge, lambda d: read_params(d, "long_edge", 0)),
+            (steps_first, lambda d: read_params(d, "steps_first", read_params(d, "steps", 20))),
+            (steps_second, lambda d: read_params(d, "steps_second", read_params(d, "steps", 20))),
+            (denoise_first, lambda d: read_params(d, "denoise_first", 0.33)),
+            (denoise_second, lambda d: read_params(d, "denoise_second", 0.45)),
+            (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", "")),
+            (second_pass_prompt, lambda d: read_params(d, "second_pass_prompt", "")),
+            (second_pass_prompt_append, lambda d: read_params(d, "second_pass_prompt_append", True)),
+            (strength, lambda d: read_params(d, "strength", 0.0)),
+            (filter_mode, lambda d: read_params(d, "filter_mode")),
+            (denoise_offset, lambda d: read_params(d, "denoise_offset", 0.0)),
+            (filter_offset, lambda d: read_params(d, "filter_offset", 0.0)),
+            (adaptive_sigma_enable, lambda d: read_params(d, "adaptive_sigma_enable", False)),
+            (clip_skip, lambda d: read_params(d, "clip_skip", 0)),
+            # per-pass samplers/schedulers + legacy fallbacks
+            (sampler_first, lambda d: read_params(d, "sampler_first", read_params(d, "sampler", sampler_names[0]))),
+            (sampler_second, lambda d: read_params(d, "sampler_second", read_params(d, "sampler", sampler_names[0]))),
+            (scheduler_first, lambda d: read_params(d, "scheduler_first", read_params(d, "scheduler", scheduler_names[0]))),
+            (scheduler_second, lambda d: read_params(d, "scheduler_second", read_params(d, "scheduler", scheduler_names[0]))),
+            (restore_scheduler_after, lambda d: read_params(d, "restore_scheduler_after", True)),
+            # cfg/delta
+            (cfg, lambda d: read_params(d, "cfg", 7.0)),
+            (cfg_second_pass_boost, lambda d: read_params(d, "cfg_second_pass_boost", True)),
+            (cfg_second_pass_delta, lambda d: read_params(d, "cfg_second_pass_delta", 3.0)),
+            # flags
+            (reuse_seed_noise, lambda d: read_params(d, "reuse_seed_noise", False)),
+            (mp_target_enabled, lambda d: read_params(d, "mp_target_enabled", False)),
+            (mp_target, lambda d: read_params(d, "mp_target", 2.0)),
+            (cond_cache_enabled, lambda d: read_params(d, "cond_cache_enabled", True)),
+            (cond_cache_max, lambda d: read_params(d, "cond_cache_max", 64)),
+            (vae_tiling_enabled, lambda d: read_params(d, "vae_tiling_enabled", False)),
+            (seamless_tiling_enabled, lambda d: read_params(d, "seamless_tiling_enabled", False)),
+            (tile_overlap, lambda d: read_params(d, "tile_overlap", 12)),
+            (lora_weight_first_factor, lambda d: read_params(d, "lora_weight_first_factor", 1.0)),
+            (lora_weight_second_factor, lambda d: read_params(d, "lora_weight_second_factor", 1.0)),
+            (match_colors_preset, lambda d: read_params(d, "match_colors_preset", "Off")),
+            (match_colors_enabled, lambda d: read_params(d, "match_colors_enabled", False)),
+            (match_colors_strength, lambda d: read_params(d, "match_colors_strength", 0.5)),
+            (postfx_preset, lambda d: read_params(d, "postfx_preset", "Off")),
+            (clahe_enabled, lambda d: read_params(d, "clahe_enabled", False)),
+            (clahe_clip, lambda d: read_params(d, "clahe_clip", 2.0)),
+            (clahe_tile_grid, lambda d: read_params(d, "clahe_tile_grid", 8)),
+            (unsharp_enabled, lambda d: read_params(d, "unsharp_enabled", False)),
+            (unsharp_radius, lambda d: read_params(d, "unsharp_radius", 1.5)),
+            (unsharp_amount, lambda d: read_params(d, "unsharp_amount", 0.75)),
+            (unsharp_threshold, lambda d: read_params(d, "unsharp_threshold", 0)),
+            (cn_ref, lambda d: read_params(d, "cn_ref", False)),
+            (start_control_at, lambda d: read_params(d, "start_control_at", 0.0)),
+            # final upscale
+            (final_upscale_enable, lambda d: read_params(d, "final_upscale_enable", False)),
+            (final_upscaler, lambda d: read_params(d, "final_upscaler", "R-ESRGAN 4x+")),
+            (final_tile, lambda d: read_params(d, "final_tile", 512)),
+            (final_tile_overlap, lambda d: read_params(d, "final_tile_overlap", 16)),
+        ]
+
+        return [
+            enable, quick_preset,
+            ratio, width, height, long_edge,
+            steps_first, steps_second, denoise_first, denoise_second,
+            first_upscaler, second_upscaler, first_latent, second_latent,
+            prompt, negative_prompt, second_pass_prompt, second_pass_prompt_append,
+            strength, filter_mode, filter_offset, denoise_offset, adaptive_sigma_enable,
+            sampler_first, sampler_second, scheduler_first, scheduler_second,
+            restore_scheduler_after,
+            cfg, cfg_second_pass_boost, cfg_second_pass_delta,
+            reuse_seed_noise, mp_target_enabled, mp_target,
+            cond_cache_enabled, cond_cache_max,
+            vae_tiling_enabled,
+            seamless_tiling_enabled, tile_overlap,
+            lora_weight_first_factor, lora_weight_second_factor,
+            match_colors_preset, match_colors_enabled, match_colors_strength,
+            postfx_preset, clahe_enabled, clahe_clip, clahe_tile_grid,
+            unsharp_enabled, unsharp_radius, unsharp_amount, unsharp_threshold,
+            cn_ref, start_control_at,
+            # final upscale
+            final_upscale_enable, final_upscaler, final_tile, final_tile_overlap
+        ]
+
+    # Capture base processing object and optional ControlNet state
+    def process(self, p, *args, **kwargs):
+        self.p = p
+        # Запомним исходные W/H, если есть
+        self._orig_size = (getattr(p, "width", None), getattr(p, "height", None))
+        self._cn_units = []
+        self._use_cn = False
+        self._first_noise = None
+        self._first_noise_shape = None
+        self._saved_seeds = None
+        self._saved_subseeds = None
+        self._saved_subseed_strength = None
+        self._saved_seed_resize_from_h = None
+        self._saved_seed_resize_from_w = None
+        self._override_prompt_second = None
+
+        # 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 bool(self.config.get("enable", False)):
+            return
+        p.extra_generation_params["Custom Hires Fix"] = self.create_infotext(p)
+
+    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),
+            "long_edge": int(self.config.get("long_edge", 0)),
+            "denoise_first": float(self.config.get("denoise_first", 0.33)),
+            "denoise_second": float(self.config.get("denoise_second", 0.45)),
+
+            "steps_first": int(self.config.get("steps_first", int(self.config.get("steps", 20)))),
+            "steps_second": int(self.config.get("steps_second", int(self.config.get("steps", 20)))),
+            "steps": int(self.config.get("steps", int(self.config.get("steps_first", 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", ""),
+            "second_pass_prompt": self.config.get("second_pass_prompt", ""),
+            "second_pass_prompt_append": bool(self.config.get("second_pass_prompt_append", True)),
+            "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)),
+            "adaptive_sigma_enable": bool(self.config.get("adaptive_sigma_enable", False)),
+            "clip_skip": int(self.config.get("clip_skip", 0)),
+            # per-pass sampler/scheduler (include legacy for context)
+            "sampler_first": self.config.get("sampler_first", ""),
+            "sampler_second": self.config.get("sampler_second", self.config.get("sampler", "")),
+            "scheduler_first": self.config.get("scheduler_first", self.config.get("scheduler", "")),
+            "scheduler_second": self.config.get("scheduler_second", self.config.get("scheduler", "")),
+            "restore_scheduler_after": bool(self.config.get("restore_scheduler_after", True)),
+            # cfg
+            "cfg": float(getattr(p, "cfg_scale", self.cfg)),
+            "cfg_second_pass_boost": bool(self.config.get("cfg_second_pass_boost", True)),
+            "cfg_second_pass_delta": float(self.config.get("cfg_second_pass_delta", 3.0)),
+            # flags
+            "reuse_seed_noise": bool(self.config.get("reuse_seed_noise", False)),
+            "mp_target_enabled": bool(self.config.get("mp_target_enabled", False)),
+            "mp_target": float(self.config.get("mp_target", 2.0)),
+            "cond_cache_enabled": bool(self.config.get("cond_cache_enabled", True)),
+            "cond_cache_max": int(self.config.get("cond_cache_max", 64)),
+            "vae_tiling_enabled": bool(self.config.get("vae_tiling_enabled", False)),
+            "seamless_tiling_enabled": bool(self.config.get("seamless_tiling_enabled", False)),
+            "tile_overlap": int(self.config.get("tile_overlap", 12)),
+            "lora_weight_first_factor": float(self.config.get("lora_weight_first_factor", 1.0)),
+            "lora_weight_second_factor": float(self.config.get("lora_weight_second_factor", 1.0)),
+            "match_colors_preset": self.config.get("match_colors_preset", "Off"),
+            "match_colors_enabled": bool(self.config.get("match_colors_enabled", False)),
+            "match_colors_strength": float(self.config.get("match_colors_strength", 0.5)),
+            "postfx_preset": self.config.get("postfx_preset", "Off"),
+            "clahe_enabled": bool(self.config.get("clahe_enabled", False)),
+            "clahe_clip": float(self.config.get("clahe_clip", 2.0)),
+            "clahe_tile_grid": int(self.config.get("clahe_tile_grid", 8)),
+            "unsharp_enabled": bool(self.config.get("unsharp_enabled", False)),
+            "unsharp_radius": float(self.config.get("unsharp_radius", 1.5)),
+            "unsharp_amount": float(self.config.get("unsharp_amount", 0.75)),
+            "unsharp_threshold": int(self.config.get("unsharp_threshold", 0)),
+            "cn_ref": bool(self.config.get("cn_ref", False)),
+            "start_control_at": float(self.config.get("start_control_at", 0.0)),
+            # final upscale
+            "final_upscale_enable": bool(self.config.get("final_upscale_enable", False)),
+            "final_upscaler": self.config.get("final_upscaler", "R-ESRGAN 4x+"),
+            "final_tile": int(self.config.get("final_tile", 512)),
+            "final_tile_overlap": int(self.config.get("final_tile_overlap", 16)),
+        }
+        return json.dumps(payload, ensure_ascii=False).translate(quote_swap)
+
+    # --- Main postprocess hook ---
+    def postprocess_image(self, p, pp,
+                          enable, quick_preset,
+                          ratio, width, height, long_edge,
+                          steps_first, steps_second, denoise_first, denoise_second,
+                          first_upscaler, second_upscaler, first_latent, second_latent,
+                          prompt, negative_prompt, second_pass_prompt, second_pass_prompt_append,
+                          strength, filter_mode, filter_offset, denoise_offset, adaptive_sigma_enable,
+                          sampler_first, sampler_second, scheduler_first, scheduler_second,
+                          restore_scheduler_after,
+                          cfg, cfg_second_pass_boost, cfg_second_pass_delta,
+                          reuse_seed_noise, mp_target_enabled, mp_target,
+                          cond_cache_enabled, cond_cache_max,
+                          vae_tiling_enabled,
+                          seamless_tiling_enabled, tile_overlap,
+                          lora_weight_first_factor, lora_weight_second_factor,
+                          match_colors_preset, match_colors_enabled, match_colors_strength,
+                          postfx_preset, clahe_enabled, clahe_clip, clahe_tile_grid,
+                          unsharp_enabled, unsharp_radius, unsharp_amount, unsharp_threshold,
+                          cn_ref, start_control_at,
+                          final_upscale_enable, final_upscaler, final_tile, final_tile_overlap):
+        if not enable:
+            return
+
+        # 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["long_edge"] = int(long_edge)
+        self.config["steps_first"] = int(steps_first)
+        self.config["steps_second"] = int(steps_second)
+        self.config["denoise_first"] = float(denoise_first)
+        self.config["denoise_second"] = float(denoise_second)
+        self.config["steps"] = int(steps_second)  # legacy aggregate
+        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["second_pass_prompt"] = second_pass_prompt.strip()
+        self.config["second_pass_prompt_append"] = bool(second_pass_prompt_append)
+        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["adaptive_sigma_enable"] = bool(adaptive_sigma_enable)
+        # per-pass sampler/scheduler
+        self.config["sampler_first"] = sampler_first
+        self.config["sampler_second"] = sampler_second
+        self.config["scheduler_first"] = scheduler_first
+        self.config["scheduler_second"] = scheduler_second
+        self.config["restore_scheduler_after"] = bool(restore_scheduler_after)
+        # cfg/delta
+        self.config["cfg"] = float(cfg)
+        self.config["cfg_second_pass_boost"] = bool(cfg_second_pass_boost)
+        self.config["cfg_second_pass_delta"] = float(cfg_second_pass_delta)
+        # flags & extras
+        self.config["reuse_seed_noise"] = bool(reuse_seed_noise)
+        self.config["mp_target_enabled"] = bool(mp_target_enabled)
+        self.config["mp_target"] = float(mp_target)
+        self.config["cond_cache_enabled"] = bool(cond_cache_enabled)
+        self.config["cond_cache_max"] = int(cond_cache_max)
+        self.config["vae_tiling_enabled"] = bool(vae_tiling_enabled)
+        self.config["seamless_tiling_enabled"] = bool(seamless_tiling_enabled)
+        self.config["tile_overlap"] = int(tile_overlap)
+        self.config["lora_weight_first_factor"] = float(lora_weight_first_factor)
+        self.config["lora_weight_second_factor"] = float(lora_weight_second_factor)
+        self.config["match_colors_preset"] = match_colors_preset
+        self.config["match_colors_enabled"] = bool(match_colors_enabled)
+        self.config["match_colors_strength"] = float(match_colors_strength)
+        self.config["postfx_preset"] = postfx_preset
+        self.config["clahe_enabled"] = bool(clahe_enabled)
+        self.config["clahe_clip"] = float(clahe_clip)
+        self.config["clahe_tile_grid"] = int(clahe_tile_grid)
+        self.config["unsharp_enabled"] = bool(unsharp_enabled)
+        self.config["unsharp_radius"] = float(unsharp_radius)
+        self.config["unsharp_amount"] = float(unsharp_amount)
+        self.config["unsharp_threshold"] = int(unsharp_threshold)
+        self.config["cn_ref"] = bool(cn_ref)
+        self.config["start_control_at"] = float(start_control_at)
+        # final upscale
+        self.config["final_upscale_enable"] = bool(final_upscale_enable)
+        self.config["final_upscaler"] = final_upscaler
+        self.config["final_tile"] = int(final_tile)
+        self.config["final_tile_overlap"] = int(final_tile_overlap)
+        self.cfg = float(cfg) if cfg else float(p.cfg_scale)
+        # Обновить PNG-info уже с актуальным self.config
+        p.extra_generation_params["Custom Hires Fix"] = self.create_infotext(p)
+
+        # Validate sizing rules if MP target is off; if MP is on, sizing will be computed
+        if not self.config["mp_target_enabled"]:
+            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."
+
+        # Track extras activated during conditioning
+        self._activated_extras = []
+
+        # Preserve original batch size
+        self._orig_batch_size = getattr(self.p, 'batch_size', None)
+
+        # Apply CLIP skip for the run
+        self._orig_clip_skip = shared.opts.CLIP_stop_at_last_layers
+        if int(self.config.get("clip_skip", 0)) > 0:
+            shared.opts.CLIP_stop_at_last_layers = int(self.config.get("clip_skip", 0))
+
+        # Toggle VAE tiling for the run
+        self._set_vae_tiling(self.config["vae_tiling_enabled"])
+
+        # Toggle seamless tiling
+        # Save original scheduler (before first/second pass may change it)
+        self._orig_scheduler = getattr(self.p, "scheduler", None)
+
+        self._orig_tiling = getattr(self.p, "tiling", None)
+        self._orig_tile_overlap = getattr(self.p, "tile_overlap", None)
+        if bool(self.config.get("seamless_tiling_enabled", False)):
+            try:
+                self.p.tiling = True
+                if hasattr(self.p, "tile_overlap"):
+                    self.p.tile_overlap = int(self.config.get("tile_overlap", 12))
+            except Exception:
+                pass
+        try:
+            with devices.autocast():
+                shared.state.nextjob()
+                x = self._first_pass(pp.image)
+                shared.state.nextjob()
+                x = self._second_pass(x)
+                # Final ×4 upscale (optional)
+                if bool(self.config.get("final_upscale_enable", False)):
+                    x = self._final_upscale_4x(x)
+            sd_models.apply_token_merging(p.sd_model, p.get_token_merging_ratio())
+            # Post-FX chain is inside _second_pass; final upscale is pure upscaler
+            pp.image = x
+        finally:
+            # Restore options
+            shared.opts.CLIP_stop_at_last_layers = self._orig_clip_skip
+            self._restore_vae_tiling()
+            # Restore scheduler if requested (independent of tiling)
+            try:
+                if bool(self.config.get("restore_scheduler_after", True)) and getattr(self, "_orig_scheduler", None) is not None:
+                    self.p.scheduler = self._orig_scheduler
+            except Exception:
+                pass
+            finally:
+                self._orig_scheduler = None
+
+            # Restore tiling if it existed
+            if self._orig_tiling is not None:
+                try:
+                    self.p.tiling = self._orig_tiling
+                    if hasattr(self.p, "tile_overlap") and self._orig_tile_overlap is not None:
+                        self.p.tile_overlap = self._orig_tile_overlap
+                except Exception:
+                    pass
+            try:
+                if getattr(self, "_orig_batch_size", None) is not None:
+                    self.p.batch_size = self._orig_batch_size
+            except Exception:
+                pass
+            try:
+                # Deactivate any extras we activated during conditioning
+                for _extra in getattr(self, "_activated_extras", []) or []:
+                    try:
+                        extra_networks.deactivate(self.p, _extra)
+                    except Exception:
+                        pass
+            finally:
+                self._activated_extras = []
+            try:
+                # Сбросить override сигм для последующих шагов
+                self.p.sampler_noise_scheduler_override = None
+            except Exception:
+                pass
+            # Восстановить исходные размеры после возможного _enable_controlnet
+            try:
+                ow, oh = getattr(self, "_orig_size", (None, None))
+                if ow is not None:
+                    self.p.width = ow
+                if oh is not None:
+                    self.p.height = oh
+            except Exception:
+                pass
+            self._orig_size = (None, None)
+    # ---- Helpers ----
+    def _maybe_mp_resize(self, base_w, base_h, target_mp: float):
+        """Compute size from megapixels while keeping aspect ratio; quantize to multiple of 8."""
+        aspect = base_w / base_h if base_h else 1.0
+        total_px = max(0.01, target_mp) * 1_000_000.0
+        w_float = math.sqrt(total_px * aspect)
+        h_float = w_float / aspect
+        w = max(8, int(round(w_float / 8) * 8))
+        h = max(8, int(round(h_float / 8) * 8))
+        return w, h
+
+    def _compute_denoise(self, base_key: str) -> float:
+        """
+        Returns clamped denoising strength in [0,1] as (config[base_key] + denoise_offset).
+        Keeps backwards-compatibility with the previous "denoise_offset" knob.
+        """
+        try:
+            base = float(self.config.get(base_key, 0.5))
+        except Exception:
+            base = 0.5
+        try:
+            off = float(self.config.get("denoise_offset", 0.0))
+        except Exception:
+            off = 0.0
+        val = max(0.0, min(1.0, base + off))
+        return val
+
+    def _model_hash_for_cache(self):
+        # best-effort model hash for cache key
+        try:
+            return getattr(shared.sd_model, "sd_model_hash", None) or getattr(shared.sd_model, "hash", None) or str(id(shared.sd_model))
+        except Exception:
+            return str(id(shared.sd_model))
+
+    def _cond_key(self, width, height, steps_for_cond, prompt: str, negative: str, clip_skip: int):
+        h = hashlib.sha256()
+        h.update((prompt or "").encode("utf-8"))
+        h.update(b"::")
+        h.update((negative or "").encode("utf-8"))
+        key = f"{self._model_hash_for_cache()}|{width}x{height}|{steps_for_cond}|cs={clip_skip}|{h.hexdigest()}"
+        return key
+
+    def _cond_cache_get(self, key: str):
+        if not bool(self.config.get("cond_cache_enabled", True)):
+            return None
+        item = self._cond_cache.get(key)
+        if item is not None:
+            self._cond_cache.move_to_end(key)
+        return item
+
+    def _cond_cache_put(self, key: str, value: tuple):
+        if not bool(self.config.get("cond_cache_enabled", True)):
+            return
+        self._cond_cache[key] = value
+        self._cond_cache.move_to_end(key)
+        max_items = int(self.config.get("cond_cache_max", 64))
+        while len(self._cond_cache) > max_items:
+            self._cond_cache.popitem(last=False)
+
+    def _set_vae_tiling(self, enabled: bool):
+        # Save original state if we have not yet
+        if self._orig_opt_vae_tiling is None and hasattr(shared.opts, "sd_vae_tiling"):
+            self._orig_opt_vae_tiling = bool(shared.opts.sd_vae_tiling)
+        # Toggle option
+        if hasattr(shared.opts, "sd_vae_tiling"):
+            shared.opts.sd_vae_tiling = bool(enabled)
+        # Try model-level toggle
+        vae = getattr(shared.sd_model, "first_stage_model", None)
+        if vae is not None:
+            try:
+                if enabled and hasattr(vae, "enable_tiling"):
+                    vae.enable_tiling()
+                if not enabled and hasattr(vae, "disable_tiling"):
+                    vae.disable_tiling()
+            except Exception:
+                pass
+
+    def _restore_vae_tiling(self):
+        if self._orig_opt_vae_tiling is not None and hasattr(shared.opts, "sd_vae_tiling"):
+            shared.opts.sd_vae_tiling = self._orig_opt_vae_tiling
+        vae = getattr(shared.sd_model, "first_stage_model", None)
+        if vae is not None:
+            try:
+                if self._orig_opt_vae_tiling and hasattr(vae, "enable_tiling"):
+                    vae.enable_tiling()
+                elif not self._orig_opt_vae_tiling and hasattr(vae, "disable_tiling"):
+                    vae.disable_tiling()
+            except Exception:
+                pass
+        self._orig_opt_vae_tiling = None
+
+    def _scale_lora_in_prompt(self, text: str, factor: float) -> str:
+        # Multiply existing <lora:name:weight>, or append weight if missing
+        # Very lightweight parser to keep prompt untouched otherwise
+        if factor is None or abs(factor - 1.0) < 1e-6:
+            return text
+        out = []
+        i = 0
+        while i < len(text):
+            start = text.find("<lora:", i)
+            if start == -1:
+                out.append(text[i:])
+                break
+            out.append(text[i:start])
+            end = text.find(">", start)
+            if end == -1:
+                out.append(text[start:])
+                break
+            token = text[start:end+1]
+            parts = token[1:-1].split(":")  # lora,name,weight?
+            if len(parts) >= 2 and parts[0] == "lora":
+                name = parts[1]
+                if len(parts) >= 3:
+                    try:
+                        w = float(parts[2])
+                    except Exception:
+                        w = 1.0
+                    new_w = max(0.0, w * factor)
+                    new_token = f"<lora:{name}:{new_w:.4g}>"
+                else:
+                    new_token = f"<lora:{name}:{factor:.4g}>"
+                out.append(new_token)
+            else:
+                out.append(token)
+            i = end + 1
+        return "".join(out)
+
+    def _prepare_conditioning(self, width, height, steps_for_cond: int, prompt_override: str = None):
+        """Build (cond, uncond) with optional LRU caching and LoRA scaling."""
+        base_prompt = self.config.get("prompt", "").strip() or self.p.prompt.strip()
+        negative_base = self.config.get("negative_prompt", "").strip() or (getattr(self.p, "negative_prompt", "") or "").strip()
+
+        if prompt_override:
+            base_prompt = prompt_override.strip()
+
+        # Apply LoRA scaling for this pass
+        scaled_prompt = self._scale_lora_in_prompt(base_prompt, self._current_lora_factor)
+
+        clip_skip = int(self.config.get("clip_skip", 0))
+
+        # Cache lookup
+        cache_key = self._cond_key(width, height, steps_for_cond, scaled_prompt, negative_base, clip_skip)
+        cached = self._cond_cache_get(cache_key)
+        if cached is not None:
+            self.cond, self.uncond = cached
+            return
+
+        # Parse extra networks and build cond
+        prompt_text = scaled_prompt
+        if not getattr(self.p, "disable_extra_networks", False):
+            try:
+                prompt_text, extra = extra_networks.parse_prompt(prompt_text)
+                if extra:
+                    extra_networks.activate(self.p, extra)
+                    try:
+                        self._activated_extras.append(extra)
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+
+        if width and height and hasattr(prompt_parser, "SdConditioning"):
+            c = prompt_parser.SdConditioning([prompt_text], False, width, height)
+            uc = prompt_parser.SdConditioning([negative_base], False, width, height)
+        else:
+            c, uc = [prompt_text], [negative_base]
+
+        cond = prompt_parser.get_multicond_learned_conditioning(shared.sd_model, c, steps_for_cond)
+        uncond = prompt_parser.get_learned_conditioning(shared.sd_model, uc, steps_for_cond)
+        self.cond, self.uncond = cond, uncond
+
+        # Store in cache
+        self._cond_cache_put(cache_key, (cond, uncond))
+
+    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 _create_sampler(self, sampler_name: str):
+        if "Restart" in sampler_name:
+            try:
+                return sd_samplers.create_sampler("Restart", shared.sd_model)
+            except Exception:
+                return sd_samplers.create_sampler("DPM++ 2M Karras", shared.sd_model)
+        return sd_samplers.create_sampler(sampler_name, shared.sd_model)
+
+    def _apply_clahe(self, img: Image.Image) -> Image.Image:
+        if not bool(self.config.get("clahe_enabled", False)):
+            return img
+        np_img = np.array(img)
+        if _CV2_OK:
+            lab = cv2.cvtColor(np_img, cv2.COLOR_RGB2LAB)
+            l, a, b = cv2.split(lab)
+            clip = float(self.config.get("clahe_clip", 2.0))
+            tiles = int(self.config.get("clahe_tile_grid", 8))
+            clahe = cv2.createCLAHE(clipLimit=max(0.1, clip), tileGridSize=(tiles, tiles))
+            l2 = clahe.apply(l)
+            lab2 = cv2.merge((l2, a, b))
+            rgb = cv2.cvtColor(lab2, cv2.COLOR_LAB2RGB)
+            return Image.fromarray(rgb)
+        if _SKIMAGE_OK:
+            # skimage fallback on L channel in LAB
+            lab = skcolor.rgb2lab(np_img / 255.0)
+            l = lab[..., 0] / 100.0
+            l2 = equalize_adapthist(l, clip_limit=float(self.config.get("clahe_clip", 2.0)))
+            lab[..., 0] = np.clip(l2 * 100.0, 0, 100.0)
+            rgb = skcolor.lab2rgb(lab)
+            rgb8 = np.clip(rgb * 255.0, 0, 255).astype(np.uint8)
+            return Image.fromarray(rgb8)
+        # No-op fallback
+        return img
+
+    def _apply_unsharp(self, img: Image.Image) -> Image.Image:
+        if not bool(self.config.get("unsharp_enabled", False)):
+            return img
+        radius = float(self.config.get("unsharp_radius", 1.5))
+        amount = float(self.config.get("unsharp_amount", 0.75))
+        threshold = int(self.config.get("unsharp_threshold", 0))
+        return img.filter(ImageFilter.UnsharpMask(radius=radius, percent=int(amount * 100), threshold=threshold))
+
+    def _apply_match_colors(self, img: Image.Image, ref: Image.Image) -> Image.Image:
+        if not bool(self.config.get("match_colors_enabled", False)):
+            return img
+        strength = float(self.config.get("match_colors_strength", 0.5))
+        strength = max(0.0, min(1.0, strength))
+        if strength <= 0.0:
+            return img
+
+        arr = np.array(img).astype(np.float32)
+        ref_arr = np.array(ref).astype(np.float32)
+
+        matched = None
+        if _SKIMAGE_OK:
+            try:
+                matched = match_histograms(arr, ref_arr, channel_axis=-1).astype(np.float32)
+            except TypeError:
+                # older skimage
+                matched = match_histograms(arr, ref_arr, multichannel=True).astype(np.float32)
+        else:
+            # simple mean-std per channel fallback
+            eps = 1e-6
+            for c in range(arr.shape[2]):
+                src = arr[..., c]
+                dst = ref_arr[..., c]
+                src_m, src_s = src.mean(), src.std() + eps
+                dst_m, dst_s = dst.mean(), dst.std() + eps
+                arr[..., c] = np.clip((src - src_m) * (dst_s / src_s) + dst_m, 0, 255)
+            matched = arr
+
+        out = (1.0 - strength) * arr + strength * matched
+        out = np.clip(out, 0, 255).astype(np.uint8)
+        return Image.fromarray(out)
+
+    # ----- Adaptive sigma shaping (override builder) -----
+    def _build_sigma_override(self, which_pass: str):
+        """
+        Возвращает функцию p.sampler_noise_scheduler_override, которая
+        формирует сигмы polyexponential с лёгкой коррекцией по filter_mode/strength.
+        which_pass: "first" | "second"
+        """
+        # База по умолчанию (как было раньше)
+        if which_pass == "first":
+            base_min, base_max, base_rho = 0.005, 20.0, 0.6
+        else:
+            base_min, base_max, base_rho = 0.01, 15.0, 0.5
+
+        if not bool(self.config.get("adaptive_sigma_enable", False)):
+            # Без адаптации — возвращаем исходные «фиксированные» параметры
+            def _no_adapt(n):
+                return K.sampling.get_sigmas_polyexponential(n, base_min, base_max, base_rho, devices.device)  # type: ignore
+            return _no_adapt
+
+        # Нормируем strength в 0..1 (ползунок 0.5..4.0)
+        raw_strength = float(self.config.get("strength", 2.0))
+        s = (raw_strength - 0.5) / 3.5
+        s = max(0.0, min(1.0, s))
+
+        filt = self.config.get("filter_mode", "Noise sync (sharp)") or "Noise sync (sharp)"
+        f_off = float(self.config.get("filter_offset", 0.0))  # -1..1 мягкий сдвиг
+
+        # Лёгкие корректировки: clamp-им и не даём sigma_min >= sigma_max
+        if "Morphological" in filt:
+            sigma_min = base_min * (1.0 + 0.5 * s + 0.25 * f_off)
+            sigma_max = base_max * (1.0 - 0.2 * s)
+            rho = base_rho - 0.2 * s
+        elif "Combined" in filt:
+            sigma_min = base_min * (1.0 + 0.20 * (0.5 - s) + 0.10 * f_off)
+            sigma_max = base_max
+            rho = base_rho
+        else:  # "Noise sync (sharp)"
+            sigma_min = base_min * (1.0 - 0.5 * s - 0.25 * f_off)
+            sigma_max = base_max * (1.0 + 0.10 * s)
+            rho = base_rho + 0.20 * s
+
+        sigma_min = max(1e-4, sigma_min)
+        sigma_max = max(sigma_min * 1.01, sigma_max)  # гарантируем > sigma_min
+        rho = max(0.1, min(1.5, rho))
+
+        def _adapt(n):
+            return K.sampling.get_sigmas_polyexponential(n, sigma_min, sigma_max, rho, devices.device)  # type: ignore
+
+        return _adapt
+
+    def _first_pass(self, x: Image.Image) -> Image.Image:
+        # Determine target size
+        if bool(self.config.get("mp_target_enabled", False)):
+            w, h = self._maybe_mp_resize(x.width, x.height, float(self.config.get("mp_target", 2.0)))
+        else:
+            ratio = x.width / x.height if x.height else 1.0
+
+            le = int(self.config.get("long_edge", 0))
+            if le > 0:
+                if x.width >= x.height:
+                    w = int(max(8, round(le / 8) * 8))
+                    h = int(max(8, round((le / ratio) / 8) * 8))
+                else:
+                    h = int(max(8, round(le / 8) * 8))
+                    w = int(max(8, round((le * ratio) / 8) * 8))
+            elif int(self.config.get("width", 0)) == 0 and int(self.config.get("height", 0)) == 0 and float(self.config.get("ratio", 0)) > 0:
+                w = int(max(8, round(x.width * float(self.config["ratio"]) / 8) * 8))
+                h = 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:
+                    w, h = int(self.config["width"]), int(self.config["height"])
+                elif int(self.config.get("width", 0)) > 0:
+                    w = int(self.config["width"])
+                    h = int(round(w / ratio / 8) * 8)
+                elif int(self.config.get("height", 0)) > 0:
+                    h = int(self.config["height"])
+                    w = int(round(h * ratio / 8) * 8)
+                else:
+                    w, h = x.width, x.height
+
+        self.width, self.height = w, h
+
+        sd_models.apply_token_merging(self.p.sd_model, self.p.get_token_merging_ratio(for_hr=True) / 2)
+
+        # Per-pass scheduler
+        sched_first = self.config.get("scheduler_first", self.config.get("scheduler", "Use same scheduler"))
+        self.p.scheduler = self.p.scheduler if sched_first == "Use same scheduler" else sched_first
+
+        # Optional ControlNet
+        if self._use_cn:
+            try:
+                cn_np = np.array(x.resize((self.width, self.height)))
+                self._enable_controlnet(cn_np)
+            except Exception:
+                pass
+
+        # Build override prompt for first pass (none; base prompt)
+        self._current_lora_factor = float(self.config.get("lora_weight_first_factor", 1.0))
+        with devices.autocast(), torch.inference_mode():
+            self._prepare_conditioning(self.width, self.height, int(self.config.get("steps_first", 20)))
+
+        # 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)
+        # Латент из исходника (до апскейла) для осмысленного смешивания
+        _, sample_orig = self._to_sample(x)
+        x_latent = torch.nn.functional.interpolate(sample_orig, (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 = sample * first_latent + x_latent * (1.0 - first_latent)
+
+        image_conditioning = self.p.img2img_image_conditioning(decoded, sample)
+
+        # RNG setup
+        self._saved_seeds = list(getattr(self.p, "seeds", [])) or None
+        self._saved_subseeds = list(getattr(self.p, "subseeds", [])) or None
+        self._saved_subseed_strength = getattr(self.p, "subseed_strength", None)
+        self._saved_seed_resize_from_h = getattr(self.p, "seed_resize_from_h", None)
+        self._saved_seed_resize_from_w = getattr(self.p, "seed_resize_from_w", None)
+
+        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)
+
+        # Denoise config for first pass
+        steps = int(self.config.get("steps_first", int(self.config.get("steps", 20))))
+        noise = torch.randn_like(sample)
+        if bool(self.config.get("reuse_seed_noise", False)):
+            self._first_noise = noise.detach().clone()
+            self._first_noise_shape = tuple(sample.shape)
+
+        self.p.denoising_strength = self._compute_denoise("denoise_first")
+        self.p.cfg_scale = float(self.cfg)
+
+        # --- sigma schedule override (с адаптацией или без) ---
+        self.p.sampler_noise_scheduler_override = self._build_sigma_override("first")
+        self.p.batch_size = 1
+
+        # Per-pass sampler
+        sampler_first = self.config.get("sampler_first", self.config.get("sampler", "DPM++ 2M Karras"))
+        sampler = self._create_sampler(sampler_first)
+
+        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 torch.isnan(decoded_sample).any().item():
+            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:
+        # Determine target size for second pass
+        if bool(self.config.get("mp_target_enabled", False)):
+            w, h = self._maybe_mp_resize(x.width, x.height, float(self.config.get("mp_target", 2.0)))
+        else:
+            le = int(self.config.get("long_edge", 0))
+            if le > 0:
+                aspect = x.width / x.height if x.height else 1.0
+                if x.width >= x.height:
+                    w = int(max(8, round(le / 8) * 8))
+                    h = int(max(8, round((le / aspect) / 8) * 8))
+                else:
+                    h = int(max(8, round(le / 8) * 8))
+                    w = int(max(8, round((le * aspect) / 8) * 8))
+            elif (int(self.config.get("width", 0)) == 0 and int(self.config.get("height", 0)) == 0 and
+                    float(self.config.get("ratio", 0)) > 0):
+                w = int(max(8, round(x.width * float(self.config["ratio"]) / 8) * 8))
+                h = 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:
+                    w, h = int(self.config["width"]), int(self.config["height"])
+                elif int(self.config.get("width", 0)) > 0:
+                    w = int(self.config["width"])
+                    h = int(round(w / aspect / 8) * 8)
+                elif int(self.config.get("height", 0)) > 0:
+                    h = int(self.config["height"])
+                    w = int(round(h * aspect / 8) * 8)
+                else:
+                    w, h = x.width, x.height
+
+        sd_models.apply_token_merging(self.p.sd_model, self.p.get_token_merging_ratio(for_hr=True))
+
+        # Per-pass scheduler
+        sched_second = self.config.get("scheduler_second", self.config.get("scheduler", "Use same scheduler"))
+        self.p.scheduler = self.p.scheduler if sched_second == "Use same scheduler" else sched_second
+
+        if self._use_cn:
+            cn_img = x if bool(self.config.get("cn_ref", False)) else self.pp.image
+            try:
+                self._enable_controlnet(np.array(cn_img.resize((w, h))))
+            except Exception:
+                pass
+
+        # Build override prompt for second pass
+        base_prompt = self.config.get("prompt", "").strip() or self.p.prompt.strip()
+        p2 = (self.config.get("second_pass_prompt", "") or "").strip()
+        if p2:
+            if bool(self.config.get("second_pass_prompt_append", True)):
+                prompt_override = (base_prompt + ", " + p2) if base_prompt else p2
+            else:
+                prompt_override = p2
+        else:
+            prompt_override = None
+
+        # Apply LoRA scaling for second pass
+        self._current_lora_factor = float(self.config.get("lora_weight_second_factor", 1.0))
+        with devices.autocast(), torch.inference_mode():
+            self._prepare_conditioning(w, h, int(self.config.get("steps_second", 20)), prompt_override=prompt_override)
+
+        # 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, (h // 8, w // 8), mode="nearest")
+
+        # Upscale to target and encode
+        if second_latent < 1.0:
+            x_up = images.resize_image(0, x, w, h, upscaler_name=self.config.get("second_upscaler", "R-ESRGAN 4x+"))
+            decoded, sample = self._to_sample(x_up)
+        else:
+            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)
+
+        # RNG: optionally reuse seed/noise
+        if bool(self.config.get("reuse_seed_noise", False)) and self._saved_seeds is not None:
+            try:
+                self.p.seeds = list(self._saved_seeds)
+                self.p.subseeds = list(self._saved_subseeds) if self._saved_subseeds is not None else self.p.subseeds
+                self.p.subseed_strength = self._saved_subseed_strength if self._saved_subseed_strength is not None else self.p.subseed_strength
+                self.p.seed_resize_from_h = self._saved_seed_resize_from_h if self._saved_seed_resize_from_h is not None else self.p.seed_resize_from_h
+                self.p.seed_resize_from_w = self._saved_seed_resize_from_w if self._saved_seed_resize_from_w is not None else self.p.seed_resize_from_w
+            except Exception:
+                pass
+
+        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)
+
+        # Denoise config for second pass
+        steps = int(self.config.get("steps_second", int(self.config.get("steps", 20))))
+        if bool(self.config.get("cfg_second_pass_boost", True)):
+            self.p.cfg_scale = float(self.cfg) + float(self.config.get("cfg_second_pass_delta", 3.0))
+        else:
+            self.p.cfg_scale = float(self.cfg)
+        self.p.denoising_strength = self._compute_denoise("denoise_second")
+
+        # Noise: reuse tensor if shapes match, else fresh noise
+        if bool(self.config.get("reuse_seed_noise", False)) and self._first_noise is not None:
+            if tuple(sample.shape) == tuple(self._first_noise_shape or ()):
+                noise = self._first_noise.to(sample.device, dtype=sample.dtype)
+            else:
+                noise = torch.randn_like(sample)
+        else:
+            noise = torch.randn_like(sample)
+
+        # --- sigma schedule override (с адаптацией или без) ---
+        self.p.sampler_noise_scheduler_override = self._build_sigma_override("second")
+        self.p.batch_size = 1
+
+        # Per-pass sampler
+        sampler_second = self.config.get("sampler_second", self.config.get("sampler", "DPM++ 2M Karras"))
+        sampler = self._create_sampler(sampler_second)
+
+        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 torch.isnan(decoded_sample).any().item():
+            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)
+        out_img = Image.fromarray(x_np.astype(np.uint8))
+
+        # Post-FX: CLAHE -> Unsharp -> Color match
+        out_img = self._apply_clahe(out_img)
+        out_img = self._apply_unsharp(out_img)
+        if bool(self.config.get("match_colors_enabled", False)):
+            # match to original input
+            out_img = self._apply_match_colors(out_img, self.pp.image)
+
+        return out_img
+
+    def _final_upscale_4x(self, img: Image.Image) -> Image.Image:
+        """
+        Final ×4 upscale with tiling + linear feathering over overlaps.
+        - tile: pre-scale size on the *input* image
+        - overlap: pre-scale overlap on the *input* image
+        Note: each tile is upscaled via images.resize_image using chosen upscaler.
+        """
+        upscaler_name = self.config.get("final_upscaler", "R-ESRGAN 4x+")
+        tile = int(self.config.get("final_tile", 512))
+        overlap = int(self.config.get("final_tile_overlap", 16))
+        tile = max(64, tile)
+        overlap = max(0, min(overlap, tile // 2))
+
+        scale = 4
+        W, H = img.width, img.height
+        TW, TH = W * scale, H * scale
+
+        # Accumulator buffers for blending
+        accum = np.zeros((TH, TW, 3), dtype=np.float32)
+        weight = np.zeros((TH, TW), dtype=np.float32)
+
+        def ramp(length, left_ovl, right_ovl):
+            # 1D feathering: 0..1 over left overlap, 1 in center, 1..0 over right overlap
+            arr = np.ones(length, dtype=np.float32)
+            if left_ovl > 0:
+                arr[:left_ovl] = np.linspace(0.0, 1.0, left_ovl, endpoint=False, dtype=np.float32)
+            if right_ovl > 0:
+                arr[-right_ovl:] = np.minimum(arr[-right_ovl:], np.linspace(1.0, 0.0, right_ovl, endpoint=False, dtype=np.float32))
+            return arr
+
+        step = tile - overlap
+        if step <= 0:
+            step = tile  # degenerate: no overlap
+
+        for y in range(0, H, step):
+            for x in range(0, W, step):
+                x0 = max(0, x - overlap)
+                y0 = max(0, y - overlap)
+                x1 = min(W, x + tile)
+                y1 = min(H, y + tile)
+
+                crop = img.crop((x0, y0, x1, y1))
+                up = images.resize_image(0, crop, (x1 - x0) * scale, (y1 - y0) * scale, upscaler_name=upscaler_name)
+                up_np = np.array(up).astype(np.float32)
+
+                ox = x0 * scale
+                oy = y0 * scale
+                uh, uw = up_np.shape[0], up_np.shape[1]
+
+                # Feather mask
+                left_ovl = (x - x0) * scale
+                top_ovl = (y - y0) * scale
+                right_ovl = (x1 - x) * scale - (tile - overlap) * scale if (x + step) < W else 0
+                bottom_ovl = (y1 - y) * scale - (tile - overlap) * scale if (y + step) < H else 0
+                left_ovl = max(0, min(left_ovl, uw // 2))
+                right_ovl = max(0, min(int(right_ovl), uw // 2))
+                top_ovl = max(0, min(top_ovl, uh // 2))
+                bottom_ovl = max(0, min(int(bottom_ovl), uh // 2))
+
+                wx = ramp(uw, left_ovl, right_ovl)
+                wy = ramp(uh, top_ovl, bottom_ovl)
+                w2d = (wy[:, None] * wx[None, :]).astype(np.float32)
+                # Accumulate
+                accum[oy:oy+uh, ox:ox+uw, :] += up_np * w2d[..., None]
+                weight[oy:oy+uh, ox:ox+uw] += w2d
+
+        weight = np.clip(weight, 1e-6, None)
+        out = (accum / weight[..., None]).astype(np.uint8)
+        return Image.fromarray(out, mode="RGB")
+
+    def _enable_controlnet(self, image_np: np.ndarray):
+        if not getattr(self, "_cn_ext", None):
+            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 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)
+
+        # Defaults for new/legacy fields
+        if "steps_first" not in data:
+            data["steps_first"] = int(data.get("steps", 20))
+        if "steps_second" not in data:
+            data["steps_second"] = int(data.get("steps", 20))
+
+        # per-pass sampler/scheduler defaults from legacy single values
+        data.setdefault("sampler_first", data.get("sampler", ""))
+        data.setdefault("sampler_second", data.get("sampler", ""))
+        data.setdefault("scheduler_first", data.get("scheduler", "Use same scheduler"))
+        data.setdefault("scheduler_second", data.get("scheduler", "Use same scheduler"))
+
+        # CFG delta defaults
+        data.setdefault("cfg_second_pass_boost", True)
+        data.setdefault("cfg_second_pass_delta", 3.0)
+
+        # Flags defaults
+        data.setdefault("reuse_seed_noise", False)
+        data.setdefault("mp_target_enabled", False)
+        data.setdefault("mp_target", 2.0)
+        data.setdefault("cond_cache_enabled", True)
+        data.setdefault("cond_cache_max", 64)
+        data.setdefault("vae_tiling_enabled", False)
+        data.setdefault("seamless_tiling_enabled", False)
+        data.setdefault("tile_overlap", 12)
+        data.setdefault("lora_weight_first_factor", 1.0)
+        data.setdefault("lora_weight_second_factor", 1.0)
+        data.setdefault("match_colors_preset", "Off")
+        data.setdefault("match_colors_enabled", False)
+        data.setdefault("match_colors_strength", 0.5)
+        data.setdefault("postfx_preset", "Off")
+        data.setdefault("clahe_enabled", False)
+        data.setdefault("clahe_clip", 2.0)
+        data.setdefault("clahe_tile_grid", 8)
+        data.setdefault("unsharp_enabled", False)
+        data.setdefault("unsharp_radius", 1.5)
+        data.setdefault("unsharp_amount", 0.75)
+        data.setdefault("unsharp_threshold", 0)
+        data.setdefault("second_pass_prompt", "")
+        data.setdefault("second_pass_prompt_append", True)
+
+        # final upscale defaults
+        data.setdefault("final_upscale_enable", False)
+        data.setdefault("final_upscaler", "R-ESRGAN 4x+")
+        data.setdefault("final_tile", 512)
+        data.setdefault("final_tile_overlap", 16)
+
+        # Новое поле по умолчанию — добавляем внутри try
+        data.setdefault("adaptive_sigma_enable", False)
+        data.setdefault("restore_scheduler_after", True)
+
+    except Exception:
+        return
+
+# Register paste-params hook
+script_callbacks.on_infotext_pasted(parse_infotext)