diff --git "a/asds/scripts/asymmetric_tiling_UNIFIED (69).py" "b/asds/scripts/asymmetric_tiling_UNIFIED (69).py"
new file mode 100644--- /dev/null
+++ "b/asds/scripts/asymmetric_tiling_UNIFIED (69).py"
@@ -0,0 +1,6828 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import gradio as gr
+from modules import scripts, shared, sd_samplers, sd_samplers_common, sd_samplers_kdiffusion
+from modules.script_callbacks import on_cfg_denoiser
+import k_diffusion.sampling
+from k_diffusion.sampling import to_d, default_noise_sampler, get_ancestral_step
+from tqdm.auto import trange
+import math
+import numpy as np
+from collections import OrderedDict
+import os
+import sys
+
+from PIL import Image
+
+# === ИМПОРТ HELPER-МОДУЛЕЙ: fallback на scripts/ и libs/ ===
+# Поддерживает обе раскладки файлов:
+# A) helper'ы лежат рядом со скриптом (.../scripts/) ← текущая раскладка
+# B) helper'ы лежат в .../libs/ ← будущая раскладка
+current_script_path = os.path.abspath(__file__)
+_scripts_dir = os.path.dirname(current_script_path) # .../scripts
+_extension_root = os.path.dirname(_scripts_dir) # .../extensions/asd
+_libs_dir = os.path.join(_extension_root, "libs") # .../extensions/asd/libs
+
+for _candidate in (_scripts_dir, _libs_dir):
+ if os.path.isdir(_candidate) and _candidate not in sys.path:
+ sys.path.append(_candidate)
+# ============================================================
+
+# Теперь импорты заработают корректно из папки libs
+from improved_tiling_functions import (
+ compute_advanced_blend_padding,
+ compute_blend_fade_to_black,
+ apply_multires_blend,
+ validate_blend_params,
+ validate_multires_params,
+ BlendStrategy,
+ MultiResStrategy
+)
+from advanced_zoom_extension import (
+ validate_zoom_params,
+)
+# ========================================================================
+# КОНСТАНТЫ И КОНФИГУРАЦИЯ
+# ========================================================================
+MODE_OFF = "Default (Off)"
+MODE_CIRCULAR = "Circular"
+MODE_MIRROR = "Mirror (Reflect)"
+MODE_HEXAGONAL = "Hexagonal (Staggered)"
+MODE_PANORAMA = "Panorama 360°"
+MODE_CUBEMAP = "Cubemap (3D)"
+MODE_BLEND = "Soft Blend Edges" # legacy / unused as a mode value;
+ # blend logic is driven by use_blend checkbox, not this constant
+MODE_ANISOTROPIC = "Anisotropic (Directional)"
+MODE_POLAR = "Polar (Sphere Correct)"
+
+# NEW MODES - Advanced Features from ENHANCED
+MODE_VORONOI = "Voronoi (Organic)"
+MODE_PERLIN = "Perlin Noise Distortion"
+MODE_FRACTAL = "Fractal Recursive"
+MODE_ADAPTIVE = "Adaptive Smart"
+
+# Глобальное хранилище
+_ORIGINAL_METHODS_CACHE = {}
+_MASK_CACHE = {}
+_CUBEMAP_GRID_CACHE = {}
+_SAMPLER_REGISTERED = False
+
+
+# Panorama Live caches
+_PANO_GRID_CACHE = {}
+_BLUR_KERNEL_CACHE = {}
+# ========================================================================
+# KOHAKU LONYU YOG SAMPLER IMPLEMENTATION
+# ========================================================================
+# ИСПРАВЛЕННАЯ ВЕРСИЯ — вставить вместо обоих дублей
+def get_safe_epsilon(tensor_or_dtype):
+ """Float16-safe epsilon"""
+ if isinstance(tensor_or_dtype, torch.Tensor):
+ dtype = tensor_or_dtype.dtype
+ else:
+ dtype = tensor_or_dtype
+
+ if dtype in (torch.float16, torch.bfloat16):
+ return 1e-3 # безопасно для half precision
+ elif dtype == torch.float32:
+ return 1e-6 # ← ИСПРАВЛЕНО: прямое значение, не рекурсивный вызов
+ else:
+ return 1e-12 # float64
+
+
+# ========================================================================
+# LATENT NOISE INIT — Calibrated Gaussian Noise (F13/F14)
+# Источник: SD-Advanced-Noise-main/latent_noise_generator.py
+# ========================================================================
+
+LATENT_RANGES = {
+ "v1": { # SD 1.5 — диапазоны откалиброваны на реальных VAE экспериментах
+ "min": [-5.5618, -17.1368, -10.3445, -8.6218],
+ "max": [13.5369, 11.1997, 16.3043, 10.6343],
+ "null": [-5.3870, -14.2931, 6.2738, 7.1220], # закодированное чёрное
+ },
+ "xl": { # SDXL
+ "min": [-22.2127, -20.0131, -17.7673, -14.9434],
+ "max": [ 17.9334, 26.3043, 33.1648, 8.9380],
+ "null": [-21.9287, 3.8783, 2.5879, 2.5435], # закодированное чёрное
+ },
+}
+
+
+@torch.no_grad()
+def gaussian_latent_noise(h, w, ver="v1", fac=0.6, nul=0.0,
+ srnd=True, seed=-1, device="cpu", dtype=None):
+ """
+ Генерирует шум в реальных диапазонах латентного пространства.
+
+ srnd=True — shared random: все 4 канала из одного rand тензора → coherent
+ nul=0.25 — 25% смешивания с null-латентом → нейтральный серый ст��рт.
+ Рекомендуется для panorama init: предотвращает цветовые пятна.
+
+ Источник: SD-Advanced-Noise-main/latent_noise_generator.py
+ """
+ # BUG FIX 9: use a local Generator so we never mutate the global RNG
+ # state; other parts of the pipeline (samplers, etc.) keep their own
+ # reproducible sequences regardless of whether this feature is on.
+ gen = None
+ if seed >= 0:
+ gen = torch.Generator(device=device)
+ gen.manual_seed(int(seed))
+ ver = ver if ver in LATENT_RANGES else "v1"
+ lims = LATENT_RANGES[ver]
+ mn, mx, nl = lims["min"], lims["max"], lims["null"]
+
+ if srnd:
+ rand = torch.rand([h, w], device=device, generator=gen)
+ lat = torch.stack([
+ rand.clone() * (mx[i] - mn[i]) + mn[i]
+ for i in range(4)
+ ])
+ else:
+ lat = torch.stack([
+ torch.rand([h, w], device=device, generator=gen) * (mx[i] - mn[i]) + mn[i]
+ for i in range(4)
+ ])
+
+ null_lat = torch.stack([
+ torch.ones([h, w], device=device) * nl[i]
+ for i in range(4)
+ ])
+
+ result = ((lat * fac) * (1.0 - nul) + null_lat * nul) / 2.0
+ if dtype is not None:
+ result = result.to(dtype=dtype)
+ return result
+
+
+# ========================================================================
+# DIFFUSION CG — Color Grading / Recenter / Normalize
+# Источник: sdsw/diffusion_cg.py + sdsw/sdxl_latent_tweak.py
+# ========================================================================
+
+@torch.no_grad()
+def center_tensor(x, per_channel_shift=1.0, full_tensor_shift=1.0, channels=None):
+ """
+ Вычитает среднее по цветовым каналам и всему тензору.
+ Убирает цветовой дрейф (bias к красному/зелёному и т.д.)
+ Источник: sdxl_latent_tweak.py / Timothy Alexis Vass
+ """
+ if channels is None:
+ channels = [1, 2] # ch1=G, ch2=R для SD1.5 (цветовые каналы)
+ for c in channels:
+ x[:, c] -= x[:, c].mean() * per_channel_shift
+ return x - x.mean() * full_tensor_shift
+
+
+@torch.no_grad()
+def maximize_tensor_v2(x, boundary=4.0, channels=None):
+ """
+ Нормализует тензор к диапазону [-boundary, +boundary] per-batch.
+ Аналог Levels в Photoshop: сохраняет среднее, растягивает min/max.
+ Источник: sdxl_latent_tweak.py / SLAPaper
+ """
+ if channels is None:
+ channels = [0, 1, 2]
+ for i in range(x.size(0)):
+ ch = x[i, channels, :, :]
+ if torch.any(ch < 0) and torch.any(ch > 0):
+ mean = ch.mean()
+ neg_min = ch[ch < mean].min() if (ch < mean).any() else ch.new_tensor(-1.0)
+ pos_max = ch[ch > mean].max() if (ch > mean).any() else ch.new_tensor(1.0)
+ ch = torch.where(ch < mean, -boundary * (ch / neg_min), ch)
+ ch = torch.where(ch > mean, boundary * (ch / pos_max), ch)
+ else:
+ max_abs = ch.abs().max()
+ if max_abs > 0:
+ ch = boundary * ch / max_abs
+ x[i, channels, :, :] = ch
+ return x
+
+
+@torch.no_grad()
+def apply_diffusion_cg(latent, cur_step, total_steps,
+ recenter=0.0, normalization=0.0):
+ """
+ Применяет Color Grading к латенту с убывающим sin-расписанием.
+
+ Расписание: strength = 1 - sin(ratio * pi/2)
+ При ratio=0 (начало): strength=1.0 (полный эффект)
+ При ratio=1 (конец): strength=0.0 (нет эффекта)
+
+ recenter: 0.0–1.0 → балансировка цвета (убирает цветовой дрейф)
+ normalization: 0.0–1.0 → нормализация контраста (растяжка до ±boundary)
+
+ Источник: sdsw/diffusion_cg.py / DiffusionCG v2.0.0
+ """
+ if recenter <= 0.0 and normalization <= 0.0:
+ return latent
+ if total_steps <= 1:
+ return latent
+ try:
+ import math
+ ratio = cur_step / total_steps
+ strength = 1.0 - math.sin(ratio * math.pi / 2.0)
+
+ if recenter > 0.0 and strength > 0.0:
+ lat = latent.clone()
+ B, C = lat.shape[0], lat.shape[1]
+ for b in range(B):
+ _std = float(lat[b].std()) or 1.0
+ for c in range(C):
+ bias = float(lat[b][c].std()) / _std * strength
+ lat[b][c] += (0.0 - lat[b][c].mean()) * bias * recenter
+ latent = lat
+
+ if normalization > 0.0 and strength > 0.0:
+ lat = latent.clone()
+ B, C = lat.shape[0], lat.shape[1]
+ for b in range(B):
+ for c in range(C):
+ magnitude = float(lat[b][c].max() - lat[b][c].min())
+ if magnitude > 0:
+ factor = 1.0 / 0.13025
+ scale = max(factor / magnitude - 1.0, 0.0)
+ lat[b][c] *= scale * normalization * strength + 1.0
+ latent = lat
+
+ return latent
+ except Exception as e:
+ print(f"[DiffusionCG] ошибка: {e}")
+ return latent
+
+
+# ========================================================================
+# BAND-PASS GRAIN SYSTEM (F5 / F11 / F12)
+# Источник: ComfyUI-LatentDetailer-main / LatentDetailer.py
+# ========================================================================
+
+@torch.no_grad()
+def _lowpass_avgpool(x: torch.Tensor, radius: int) -> torch.Tensor:
+ """Lowpass blur via avg_pool2d (zero padding — intentionally preserved)."""
+ r = int(max(0, radius))
+ if r <= 0:
+ return x
+ k = 2 * r + 1
+ return F.avg_pool2d(x, kernel_size=k, stride=1, padding=r)
+
+
+@torch.no_grad()
+def _rms_norm_(x: torch.Tensor, eps: float = 1e-6) -> torch.Tensor:
+ """In-place RMS normalisation so noise_scale stays comparable."""
+ var = x.pow(2).mean(dim=(2, 3), keepdim=True)
+ return x.mul_(torch.rsqrt(var + eps))
+
+
+@torch.no_grad()
+def _randn_like_grain(x: torch.Tensor, seed: int) -> torch.Tensor:
+ """Seeded or fully-random noise, same shape/device/dtype as x."""
+ if seed < 0:
+ return torch.randn_like(x)
+ # BUG FIX 9 (continued): always use a local Generator; avoid the global
+ # torch.manual_seed fallback that was here before.
+ try:
+ g = torch.Generator(device=x.device)
+ g.manual_seed(int(seed))
+ return torch.randn_like(x, generator=g)
+ except Exception:
+ # CPU fallback: still use a local generator, not the global one
+ g_cpu = torch.Generator()
+ g_cpu.manual_seed(int(seed))
+ return torch.randn(x.shape, dtype=x.dtype, generator=g_cpu).to(x.device)
+
+
+@torch.no_grad()
+def _shape_noise_tail(n: torch.Tensor, noise_tail: float) -> torch.Tensor:
+ """
+ Reshape noise tails while keeping RMS comparable.
+ noise_tail 0 = Gaussian, +1 = heavier tails, -1 = lighter tails.
+ """
+ t = float(max(-1.0, min(1.0, noise_tail)))
+ if abs(t) < 1e-6:
+ return n
+ p = 2.0 ** t
+ x = torch.sign(n) * torch.pow(torch.abs(n) + 1e-12, p)
+ return _rms_norm_(x)
+
+
+@torch.no_grad()
+def _bandpass_grain(noise: torch.Tensor, r: int) -> torch.Tensor:
+ """
+ Band-pass filter on noise via double lowpass difference.
+ lp1 - lp2 = band centred around radius r.
+ r=0 → broadband (no filter), r>0 → textured mid-frequency grain.
+ """
+ r = int(max(0, r))
+ if r == 0:
+ return _rms_norm_(noise)
+ lp1 = _lowpass_avgpool(noise, r)
+ lp2 = _lowpass_avgpool(noise, r * 2)
+ band = lp1 - lp2
+ return _rms_norm_(band)
+
+
+@torch.no_grad()
+def _grain_luma_weight(x: torch.Tensor, grain_luma: float,
+ noise_radius: int) -> torch.Tensor:
+ """
+ Luma-dependent grain weight (B,1,H,W).
+ Darker regions get more grain, highlights get less.
+ grain_luma=0 → uniform; =1 → maximum shadow/highlight split.
+ """
+ gl = float(max(0.0, min(1.0, grain_luma)))
+ if gl <= 0.0 or x.ndim != 4:
+ return x.new_ones((x.shape[0], 1, x.shape[-2], x.shape[-1]))
+ c = int(min(4, x.shape[1]))
+ lum = x[:, :c].mean(dim=1, keepdim=True)
+ blur_r = int(min(24, max(2, noise_radius * 4)))
+ lum = _lowpass_avgpool(lum, blur_r)
+ mean = lum.mean(dim=(2, 3), keepdim=True)
+ std = lum.std(dim=(2, 3), keepdim=True) + 1e-6
+ z = (lum - mean) / std
+ w = torch.clamp(torch.exp(-1.75 * z), 0.25, 4.0)
+ return (1.0 - gl) + gl * w
+
+
+@torch.no_grad()
+def apply_latent_grain(x: torch.Tensor,
+ noise_scale: float = 0.02,
+ noise_radius: int = 3,
+ noise_tail: float = 0.0,
+ grain_luma: float = 0.0,
+ seed: int = -1) -> torch.Tensor:
+ """
+ Adds band-pass, RMS-normalised grain to latent tensor.
+
+ noise_scale: amplitude (0.02–0.08 рекомендуется для тайлинга)
+ noise_radius: размер зерна в латентных пикселях (1=мелкое, 8=крупное)
+ noise_tail: форма распределения (0=Гаусс, +1=тяжёлые хвосты)
+ grain_luma: bias в тёмные области (0=равномерно, 1=максимум)
+ seed: -1=случайный каждый шаг, ≥0=воспроизводимый
+ """
+ ns = float(max(0.0, noise_scale))
+ if ns <= 0.0:
+ return x
+ try:
+ n = _randn_like_grain(x, seed)
+ g = _bandpass_grain(n, int(noise_radius))
+ if abs(float(noise_tail)) > 1e-6:
+ g = _shape_noise_tail(g, float(noise_tail))
+ if float(grain_luma) > 0.0:
+ w = _grain_luma_weight(x, float(grain_luma), int(noise_radius))
+ g = g * w
+ return x + g * ns
+ except Exception as e:
+ print(f"[Grain] ошибка: {e}")
+ return x
+
+
+# ========================================================================
+# FOURIER FILTER — GAUSSIAN FFT
+# Источник: ComfyUI_FreeU_V2_advanced-main/utils.py
+# ========================================================================
+
+@torch.no_grad()
+def fourier_filter_gauss(x, radius_ratio=0.08, scale=1.0, hf_boost=1.0):
+ """
+ Gaussian FFT без артефактов Гиббса.
+ radius_ratio: доля от min(H,W), адаптируется к размеру тайла.
+ scale<1.0 ослабляет НЧ, hf_boost>1.0 усиливает ВЧ.
+ """
+ orig_dtype = x.dtype
+ x_f = torch.fft.fftn(x.float(), dim=(-2, -1))
+ x_f = torch.fft.fftshift(x_f, dim=(-2, -1))
+ _B, _C, H, W = x_f.shape
+ R = max(1, int(min(H, W) * float(radius_ratio)))
+ yy = torch.arange(H, device=x.device, dtype=torch.float32) - H // 2
+ xx = torch.arange(W, device=x.device, dtype=torch.float32) - W // 2
+ yy, xx = torch.meshgrid(yy, xx, indexing='ij')
+ sigma_f = max(1e-6, float(R ** 2) / 2.0)
+ center = torch.exp(-(yy ** 2 + xx ** 2) / sigma_f).view(1, 1, H, W)
+ mask = float(scale) * center + float(hf_boost) * (1.0 - center)
+ result = torch.fft.ifftn(
+ torch.fft.ifftshift(x_f * mask, dim=(-2, -1)), dim=(-2, -1)
+ ).real
+ return result.to(dtype=orig_dtype)
+
+
+# ========================================================================
+# ADVANCED ZOOM — двухбэкендная система
+# geometry: grid_sample warp без noise (grid_warp / spiral_zoom / convergence_shift)
+# canvas: outpaint-style latent fill с coherent noise (outpaint_zoom / blend_transition / hybrid)
+# ========================================================================
+
+ZOOM_BACKEND_GEOMETRY = "geometry"
+ZOOM_BACKEND_CANVAS = "canvas"
+GEOMETRY_ZOOM_MODES = {"grid_warp", "spiral_zoom", "convergence_shift"}
+CANVAS_ZOOM_MODES = {"outpaint_zoom", "blend_transition", "hybrid"}
+
+
+def resolve_zoom_backend(zoom_mode: str, zoom_engine: str = "auto") -> str:
+ """Определяет backend по mode и явному выбору engine.
+
+ При явном задании engine проверяет совместимость с mode:
+ - spiral_zoom в canvas-engine: нет полной реализации → принудительно geometry
+ - outpaint/blend/hybrid в geometry-engine: не будет outpaint-fill → warn + canvas
+ Логика: явный выбор пользователя уважается где это безопасно; несовместимая
+ комбинация логируется и нормализуется к рабочему backend-у.
+ """
+ zm = str(zoom_mode or "grid_warp").lower()
+ ze = str(zoom_engine or "auto").lower()
+
+ if ze == ZOOM_BACKEND_GEOMETRY:
+ if zm in CANVAS_ZOOM_MODES:
+ # outpaint/blend/hybrid требуют canvas fill; в geometry они деградируют
+ # до обычного warp без fill — предупреждаем и переключаемся
+ print(f"[Zoom] ⚠ zoom_mode='{zm}' несовместим с engine='geometry' "
+ f"(нет canvas fill). Принудительно переключаю на engine='canvas'.")
+ return ZOOM_BACKEND_CANVAS
+ return ZOOM_BACKEND_GEOMETRY
+
+ if ze == ZOOM_BACKEND_CANVAS:
+ if zm in ("spiral_zoom", "convergence_shift"):
+ # spiral_zoom реализован только в geometry;
+ # convergence_shift требует depth-curve warp, которого нет в canvas
+ print(f"[Zoom] ⚠ zoom_mode='{zm}' не реализован для engine='canvas'. "
+ f"Принудительно переключаю на engine='geometry'.")
+ return ZOOM_BACKEND_GEOMETRY
+ return ZOOM_BACKEND_CANVAS
+
+ # auto: выбираем по mode без предупреждений
+ return ZOOM_BACKEND_GEOMETRY if zm in GEOMETRY_ZOOM_MODES else ZOOM_BACKEND_CANVAS
+
+
+@torch.no_grad()
+def apply_geometry_zoom_latent(
+ x: torch.Tensor,
+ zoom_factor: float = 0.0,
+ convergence_point: float = 0.5,
+ convergence_y: float = 0.5,
+ pan_x: float = 0.0,
+ pan_y: float = 0.0,
+ interp_mode: str = "bilinear",
+ zoom_mode: str = "grid_warp",
+ spiral_rotation: float = 0.5,
+ spiral_direction: float = 1.0,
+ depth_power: float = 1.0,
+ auto_clamp_pan: bool = True,
+) -> torch.Tensor:
+ """
+ Чистый latent-space geometric warp через F.grid_sample.
+ Сохраняет форму [B,C,H,W], не добавляет шум.
+ Поддерживает: grid_warp, spiral_zoom, convergence_shift.
+ """
+ if x is None or x.ndim != 4:
+ return x
+ zf = float(zoom_factor)
+ pax = float(pan_x)
+ pay = float(pan_y)
+ zm = str(zoom_mode).lower()
+ if abs(zf) < 1e-6 and abs(pax) < 1e-6 and abs(pay) < 1e-6:
+ return x
+
+ orig_dtype = x.dtype
+ xf = x.float()
+ b, c, h, w = xf.shape
+ device = xf.device
+
+ scale = max(0.05, min(10.0, 1.0 + zf * 0.1))
+
+ if auto_clamp_pan and abs(zf) > 1e-4:
+ # Only clamp pan when zoom is active — at scale≈1.0 the formula gives
+ # max_pan≈0 which would zero out pan even though it's perfectly valid.
+ max_pan = max(0.0, 1.0 - 1.0 / scale) * 0.95
+ pax = max(-max_pan, min(max_pan, pax))
+ pay = max(-max_pan, min(max_pan, pay))
+
+ yy = torch.linspace(-1.0, 1.0, h, device=device, dtype=torch.float32)
+ xx = torch.linspace(-1.0, 1.0, w, device=device, dtype=torch.float32)
+ y_grid, x_grid = torch.meshgrid(yy, xx, indexing="ij")
+
+ cx = (float(convergence_point) - 0.5) * 2.0
+ cy = (float(convergence_y) - 0.5) * 2.0
+ ox = pax * 2.0
+ oy = pay * 2.0
+
+ if zm == "spiral_zoom":
+ dx = x_grid - cx
+ dy = y_grid - cy
+ r = torch.sqrt(dx * dx + dy * dy + 1e-6)
+ a = torch.atan2(dy, dx) + coerce_spiral_direction(spiral_direction) * float(spiral_rotation) * r
+ x_new = (r * torch.cos(a)) / scale + cx - ox
+ y_new = (r * torch.sin(a)) / scale + cy - oy
+ elif zm == "convergence_shift":
+ dp = max(0.1, float(depth_power))
+ dx = x_grid - cx
+ dy = y_grid - cy
+ r = torch.sqrt(dx * dx + dy * dy + 1e-6).clamp(0.0, 2.0)
+ w_mask = torch.pow(r / 2.0, dp)
+ x_new = cx + dx / scale * (1.0 - w_mask) + dx * w_mask - ox
+ y_new = cy + dy / scale * (1.0 - w_mask) + dy * w_mask - oy
+ else: # grid_warp (default)
+ x_new = (x_grid - cx) / scale + cx - ox
+ y_new = (y_grid - cy) / scale + cy - oy
+
+ grid = torch.stack((x_new, y_new), dim=-1).unsqueeze(0).expand(b, -1, -1, -1)
+
+ _mode = str(interp_mode).lower()
+ if _mode == "bicubic":
+ try:
+ out = F.grid_sample(xf, grid, mode="bicubic",
+ padding_mode="zeros", align_corners=True)
+ except Exception:
+ out = F.grid_sample(xf, grid, mode="bilinear",
+ padding_mode="zeros", align_corners=True)
+ elif _mode == "nearest":
+ out = F.grid_sample(xf, grid, mode="nearest",
+ padding_mode="zeros", align_corners=True)
+ else:
+ out = F.grid_sample(xf, grid, mode="bilinear",
+ padding_mode="zeros", align_corners=True)
+
+ return out.to(dtype=orig_dtype)
+
+
+@torch.no_grad()
+def _latent_valid_mask(grid: torch.Tensor) -> torch.Tensor:
+ """[B,H,W,2] grid → [B,1,H,W] float маска валидных пикселей."""
+ gx = grid[..., 0]
+ gy = grid[..., 1]
+ return ((gx >= -1.0) & (gx <= 1.0) & (gy >= -1.0) & (gy <= 1.0)).float().unsqueeze(1)
+
+
+@torch.no_grad()
+def _distance_from_valid(valid_mask: torch.Tensor, blur_r: int = 4) -> torch.Tensor:
+ """Расстояние от ближайшего валидного пикселя (0=внутри контента, 1=далеко)."""
+ inv = 1.0 - valid_mask
+ if blur_r > 0:
+ k = blur_r * 2 + 1
+ inv = F.avg_pool2d(inv, kernel_size=k, stride=1, padding=blur_r)
+ return inv.clamp(0.0, 1.0)
+
+
+@torch.no_grad()
+def _make_canvas_fill(
+ x: torch.Tensor,
+ valid_mask: torch.Tensor,
+ noise_strength: float = 1.0,
+ adaptive_noise_scale: bool = True,
+ seed: int = -1,
+) -> torch.Tensor:
+ """Coherent latent fill для пустых зон canvas zoom."""
+ b, c, h, w = x.shape
+ fills = []
+ for bi in range(b):
+ fill = gaussian_latent_noise(
+ h, w,
+ ver="xl" if (c == 4 and h >= 128) else "v1",
+ fac=max(0.05, min(2.0, float(noise_strength))),
+ nul=0.15, srnd=True,
+ seed=(seed + bi) if seed >= 0 else -1,
+ device=x.device, dtype=x.dtype,
+ ).unsqueeze(0)
+ fills.append(fill)
+ fill = torch.cat(fills, dim=0)
+ if adaptive_noise_scale:
+ dist = _distance_from_valid(valid_mask, blur_r=6)
+ fill = fill * (0.35 + 0.65 * dist)
+ return fill
+
+
+@torch.no_grad()
+def _apply_variance_correction(
+ out: torch.Tensor,
+ ref: torch.Tensor,
+ valid_mask: torch.Tensor,
+ strength: float = 1.0,
+) -> torch.Tensor:
+ """Подтягивает std выходного тензора к std оригинала — убирает серость на швах."""
+ try:
+ s = float(max(0.0, min(1.0, strength)))
+ if s < 1e-4:
+ return out
+ vm = valid_mask.expand_as(ref)
+ n = vm.sum().clamp(min=1.0)
+ ref_std = ((ref * vm).pow(2).sum() / n).sqrt()
+ out_std = ((out * vm).pow(2).sum() / n).sqrt()
+ if out_std > 1e-6:
+ scale = float((1.0 + s * (ref_std / out_std - 1.0)).clamp(0.5, 2.0))
+ return out * scale
+ except Exception:
+ pass
+ return out
+
+
+@torch.no_grad()
+def apply_canvas_zoom_latent(
+ x: torch.Tensor,
+ zoom_mode: str = "outpaint_zoom",
+ zoom_factor: float = 0.0,
+ convergence_point: float = 0.5,
+ convergence_y: float = 0.5,
+ pan_x: float = 0.0,
+ pan_y: float = 0.0,
+ interp_mode: str = "bilinear",
+ depth_power: float = 1.0,
+ blend_mode: str = "circular_reflect",
+ noise_strength: float = 1.0,
+ edge_fade: bool = True, # ранее zoom_in_fade; затухание краёв fill-зоны
+ variance_correction: bool = True,
+ auto_clamp_pan: bool = True,
+ adaptive_noise_scale: bool = True,
+ fade_to_black: bool = False,
+ fade_strength: float = 0.15,
+ # gradient_radial params — используются в blend_mode="gradient_radial"
+ gradient_center_x: float = 0.5, # центр радиального gradient [0..1]
+ gradient_center_y: float = 0.5,
+ gradient_radius: float = 1.0, # нормированный радиус (1.0 = до угла кадра)
+ # noise_blend params — используются в blend_mode="noise_blend"
+ noise_scale: float = 5.0, # частота процедурной шум-маски (1..20)
+ noise_octaves: int = 2, # количество октав шум-маски
+ seed: int = -1,
+) -> torch.Tensor:
+ """
+ Outpaint-style latent zoom: контент + coherent fill + параметрический blend.
+ Поддерживает: outpaint_zoom, blend_transition, hybrid.
+
+ blend_mode="gradient_radial": радиальный gradient с центром gradient_center_x/y
+ и радиусом gradient_radius. Центр кадра → полный контент, края → fill.
+ blend_mode="noise_blend": процедурная шум-маска с параметрами noise_scale /
+ noise_octaves. Grain-стиль смешивания контента и fill.
+
+ edge_fade: затухание fill-зоны у границ кадра (уменьшает артефакты при
+ zoom-out, где fill доходит до краёв; независимо от zoom_factor sign).
+ """
+ if x is None or x.ndim != 4:
+ return x
+
+ zf = float(zoom_factor)
+ pax = float(pan_x)
+ pay = float(pan_y)
+ zm = str(zoom_mode).lower()
+ orig_dtype = x.dtype
+ xf = x.float()
+ b, c, h, w = xf.shape
+ device = xf.device
+
+ scale = max(0.05, min(10.0, 1.0 + zf * 0.1))
+
+ if auto_clamp_pan and abs(zf) > 1e-4:
+ # Only clamp when zoom is active — at scale=1.0 max_pan=0 kills all pan.
+ max_pan = max(0.0, 1.0 - 1.0 / scale) * 0.95
+ pax = max(-max_pan, min(max_pan, pax))
+ pay = max(-max_pan, min(max_pan, pay))
+
+ cx = (float(convergence_point) - 0.5) * 2.0
+ cy = (float(convergence_y) - 0.5) * 2.0
+ ox = pax * 2.0
+ oy = pay * 2.0
+
+ yy = torch.linspace(-1.0, 1.0, h, device=device, dtype=torch.float32)
+ xx = torch.linspace(-1.0, 1.0, w, device=device, dtype=torch.float32)
+ y_grid, x_grid = torch.meshgrid(yy, xx, indexing="ij")
+
+ x_new = (x_grid - cx) / scale + cx - ox
+ y_new = (y_grid - cy) / scale + cy - oy
+ grid = torch.stack((x_new, y_new), dim=-1).unsqueeze(0).expand(b, -1, -1, -1)
+
+ # hybrid: лёгкий geometry pre-warp перед canvas fill
+ if zm == "hybrid":
+ x_src = apply_geometry_zoom_latent(
+ xf, zoom_factor=zf * 0.4,
+ convergence_point=convergence_point, convergence_y=convergence_y,
+ pan_x=pax * 0.5, pan_y=pay * 0.5,
+ interp_mode=interp_mode, zoom_mode="grid_warp",
+ depth_power=depth_power, auto_clamp_pan=False,
+ )
+ else:
+ x_src = xf
+
+ _mode = str(interp_mode).lower()
+ if _mode not in ("bilinear", "bicubic", "nearest"):
+ _mode = "bilinear"
+ try:
+ content = F.grid_sample(x_src, grid, mode=_mode,
+ padding_mode="zeros", align_corners=True)
+ except Exception:
+ content = F.grid_sample(x_src, grid, mode="bilinear",
+ padding_mode="zeros", align_corners=True)
+
+ valid_mask = _latent_valid_mask(grid)
+ ns = float(noise_strength) * (0.5 if zm == "blend_transition" else 1.0)
+
+ # depth_power: степенная кривая для fill-strength distribution.
+ # dp > 1 → fill сильнее только у дальних краёв (контент держится дольше)
+ # dp < 1 → fill равномернее по всей пустой зоне
+ # Применяем к distance map перед вычислением adaptive_noise_scale и alpha.
+ dp = max(0.1, float(depth_power))
+ if abs(dp - 1.0) > 0.05:
+ # Модифицируем valid_mask через curved distance: это влияет на
+ # adaptive fill strength и на soft-blend alpha в blend_transition.
+ dist_raw = _distance_from_valid(valid_mask, blur_r=0).clamp(1e-6, 1.0)
+ dist_curved = dist_raw.pow(dp)
+ # Пересчитываем valid_mask как 1 - dist_curved (более агрессивная/мягкая граница)
+ _vm_curved = (1.0 - dist_curved).clamp(0.0, 1.0)
+ else:
+ _vm_curved = valid_mask
+
+ fill = _make_canvas_fill(xf, _vm_curved, noise_strength=ns,
+ adaptive_noise_scale=adaptive_noise_scale, seed=seed)
+
+ # ── Build alpha (content weight) ────────────────────────────────────
+ # Все ветки используют _vm_curved, чтобы depth_power влиял на весь canvas pipeline:
+ # gradient_radial, noise_blend, blend_transition, outpaint/hybrid, edge_fade, variance.
+ bm = str(blend_mode).lower()
+
+ if bm == "gradient_radial":
+ # Радиальный gradient с настраиваемым центром и радиусом.
+ # gradient_center_x/y в [0..1] → NDC [-1..1]
+ gcx = (float(gradient_center_x) - 0.5) * 2.0
+ gcy = (float(gradient_center_y) - 0.5) * 2.0
+ gr_ = max(0.05, float(gradient_radius))
+ dx_g = x_grid - gcx
+ dy_g = y_grid - gcy
+ r_g = (dx_g.pow(2) + dy_g.pow(2)).sqrt()
+ radial = (1.0 - (r_g / gr_).clamp(0.0, 1.0)) # 1=centre, 0=edge
+ alpha = (_vm_curved * radial.unsqueeze(0).unsqueeze(0)).clamp(0.0, 1.0)
+
+ elif bm == "noise_blend":
+ # Процедурная шум-маска с noise_scale и noise_octaves.
+ # Несколько октав усредняются → grain-стиль перехода.
+ ns_k = max(1.0, min(50.0, float(noise_scale)))
+ n_oct = max(1, min(8, int(noise_octaves)))
+ g_gen = torch.Generator(device=device)
+ g_gen.manual_seed(seed if seed >= 0 else 42)
+ na_acc = torch.zeros(b, 1, h, w, device=device, dtype=torch.float32)
+ amplitude = 1.0
+ freq = 1.0
+ amp_sum = 0.0
+ for _oct in range(n_oct):
+ raw = torch.rand(b, 1, h, w, device=device, dtype=torch.float32,
+ generator=g_gen)
+ # Smooth at current frequency
+ k_size = max(3, min(h, w, int(ns_k / freq)))
+ k_size = k_size if k_size % 2 == 1 else k_size + 1
+ raw_sm = F.avg_pool2d(raw, k_size, stride=1, padding=k_size // 2)
+ na_acc += raw_sm * amplitude
+ amp_sum += amplitude
+ amplitude *= 0.5
+ freq *= 2.0
+ na_norm = (na_acc / amp_sum).clamp(0.0, 1.0)
+ alpha = (_vm_curved * na_norm).clamp(0.0, 1.0)
+
+ elif zm == "blend_transition" or bm not in (
+ "circular_reflect", "circular_constant", "reflect_constant",
+ "polar_circular", "mirror_circular", "aniso_circular", "custom",
+ ):
+ # blend_transition + любые остальные blend-моды: soft edge через distance.
+ # _vm_curved уже учитывает depth_power, так что:
+ # dp > 1 → контент "держится" дольше, soft-зона уже;
+ # dp < 1 → переход мягче, fill заходит дальше.
+ dist = _distance_from_valid(_vm_curved, blur_r=max(2, min(h, w) // 16))
+ alpha = (_vm_curved * (1.0 - dist)).clamp(0.0, 1.0)
+
+ else:
+ # outpaint_zoom + hybrid + стандартные режимы.
+ # Используем _vm_curved: при dp != 1 граница контента становится мягче/жёстче.
+ alpha = _vm_curved
+
+ # ── Mix content + fill ───────────────────────────────────────────────
+ alpha_c = alpha.expand(b, c, h, w)
+ out = content * alpha_c + fill * (1.0 - alpha_c)
+
+ # ── Edge fade: затухание fill-зоны у границ кадра ───────────────────
+ # Использует _vm_curved — depth_power влияет на форму fade-зоны так же,
+ # как и на alpha: dp > 1 → fade только у дальних краёв, dp < 1 → равномернее.
+ if edge_fade and float(fade_strength) > 0.0:
+ has_fill = (valid_mask.mean() < 0.999) # проверяем реальный valid_mask
+ if has_fill:
+ dist_edge = _distance_from_valid(_vm_curved, blur_r=4)
+ fade_w = (1.0 - dist_edge * float(fade_strength)).clamp(0.0, 1.0)
+ out = out * fade_w.expand(b, c, h, w)
+
+ # ── Fade to black ────────────────────────────────────────────────────
+ if fade_to_black and float(fade_strength) > 0.0:
+ r_ = (x_grid.pow(2) + y_grid.pow(2)).sqrt().clamp(0.0, 1.414)
+ fm = (1.0 - (r_ * float(fade_strength)).clamp(0.0, 1.0)).view(1, 1, h, w)
+ out = out * fm.expand(b, c, h, w)
+
+ # ── Variance correction ──────────────────────────────────────────────
+ # _vm_curved как reference mask: std вычисля��тся по depth-weighted content zone.
+ if variance_correction:
+ out = _apply_variance_correction(out, xf, _vm_curved)
+
+ return out.to(dtype=orig_dtype)
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# ZOOM COMPOSE HELPERS — Pinned Subject & Dual-Transform ROI
+# ═══════════════════════════════════════════════════════════════════════════════
+
+@torch.no_grad()
+def make_soft_roi_mask(
+ x,
+ cx: float = 0.5, cy: float = 0.5,
+ rx: float = 0.18, ry: float = 0.18,
+ feather: float = 0.08,
+ shape: str = "ellipse",
+) -> torch.Tensor:
+ """
+ Build a soft ROI mask in latent space [B, 1, H, W].
+ mask=1 inside ROI, mask=0 outside, smooth transition on boundary.
+ cx/cy/rx/ry are fractions [0..1] relative to spatial dims.
+ """
+ b, c, h, w = x.shape
+ device, dtype = x.device, x.dtype
+ yy = torch.linspace(0.0, 1.0, h, device=device, dtype=dtype)
+ xx = torch.linspace(0.0, 1.0, w, device=device, dtype=dtype)
+ y_grid, x_grid = torch.meshgrid(yy, xx, indexing="ij")
+ dx = (x_grid - float(cx)) / max(float(rx), 1e-6)
+ dy = (y_grid - float(cy)) / max(float(ry), 1e-6)
+ if str(shape).lower() == "box":
+ d = torch.maximum(dx.abs(), dy.abs())
+ else:
+ d = torch.sqrt(dx * dx + dy * dy + 1e-8)
+ # smoothstep from d=1.0 (inner edge) to d=1+feather (outer edge)
+ f = max(float(feather), 1e-6)
+ t = ((d - 1.0) / f).clamp(0.0, 1.0)
+ smooth = t * t * (3.0 - 2.0 * t) # smoothstep
+ mask = 1.0 - smooth # inside=1, outside=0
+ return mask.unsqueeze(0).unsqueeze(0).expand(b, 1, h, w).contiguous()
+
+
+@torch.no_grad()
+def compose_pinned_subject(
+ x_orig: torch.Tensor,
+ x_bg: torch.Tensor,
+ mask: torch.Tensor,
+ preserve_strength: float = 1.0,
+) -> torch.Tensor:
+ """
+ Pinned Subject: ROI area preserved from original, outside gets bg zoom.
+ out = x_bg * (1 - mask*s) + x_orig * (mask*s)
+ """
+ a = mask.clamp(0.0, 1.0) * float(max(0.0, min(1.0, preserve_strength)))
+ return x_bg * (1.0 - a) + x_orig * a
+
+
+@torch.no_grad()
+def apply_zoom_compose_latent(
+ src: torch.Tensor,
+ base_zoom_params: dict,
+ compose_mode: str = "Global",
+ roi_shape: str = "ellipse",
+ roi_center_x: float = 0.5,
+ roi_center_y: float = 0.5,
+ roi_radius_x: float = 0.18,
+ roi_radius_y: float = 0.18,
+ roi_feather: float = 0.08,
+ roi_preserve_strength: float = 1.0,
+ roi_fg_zoom_factor: float = 0.0,
+ roi_bg_zoom_factor: float = 0.0,
+ seed: int = -1,
+) -> torch.Tensor:
+ """
+ Zoom composition router:
+ Global → standard apply_advanced_zoom_latent (unchanged)
+ Pinned Subject → bg zooms, ROI area stays near original
+ Dual-Transform → bg and fg get independent zoom factors
+ Geometry backend is enforced for compose modes to avoid canvas fill artefacts.
+ """
+ mode = str(compose_mode or "Global")
+
+ if mode == "Global":
+ return apply_advanced_zoom_latent(src, base_zoom_params, seed=seed)
+
+ # Build ROI mask — on same device/dtype as src
+ mask = make_soft_roi_mask(
+ src,
+ cx=roi_center_x, cy=roi_center_y,
+ rx=roi_radius_x, ry=roi_radius_y,
+ feather=roi_feather,
+ shape=roi_shape,
+ )
+
+ if mode == "Pinned Subject":
+ # Force geometry backend for clean results
+ zp_bg = dict(base_zoom_params or {})
+ zp_bg["zoom_engine"] = "geometry"
+ zp_bg.setdefault("zoom_mode", "grid_warp")
+ x_bg = apply_advanced_zoom_latent(src, zp_bg, seed=seed)
+ return compose_pinned_subject(src, x_bg, mask, preserve_strength=roi_preserve_strength)
+
+ if mode == "Dual-Transform ROI":
+ zp_bg = dict(base_zoom_params or {})
+ zp_fg = dict(base_zoom_params or {})
+ # Dual mode: each gets independent zoom_factor, geometry only.
+ # NOTE: roi_bg/fg_zoom_factor are FIXED values set in UI and override
+ # any animated _zoom_factor_override from the range interpolation.
+ # This is intentional — Dual-Transform users control fg/bg zoom directly.
+ zp_bg["zoom_factor"] = float(roi_bg_zoom_factor)
+ zp_fg["zoom_factor"] = float(roi_fg_zoom_factor)
+ zp_bg["zoom_engine"] = "geometry"
+ zp_fg["zoom_engine"] = "geometry"
+ zp_bg.setdefault("zoom_mode", "grid_warp")
+ zp_fg.setdefault("zoom_mode", "grid_warp")
+ x_bg = apply_advanced_zoom_latent(src, zp_bg, seed=seed)
+ x_fg = apply_advanced_zoom_latent(src, zp_fg, seed=seed)
+ return x_fg * mask + x_bg * (1.0 - mask)
+
+ # Fallback
+ return apply_advanced_zoom_latent(src, base_zoom_params, seed=seed)
+
+
+@torch.no_grad()
+def apply_advanced_zoom_latent(
+ x: torch.Tensor,
+ zp: dict,
+ seed: int = -1,
+) -> torch.Tensor:
+ """
+ Главный роутер: geometry или canvas backend по zoom_mode / zoom_engine.
+ zp — словарь всех zoom-параметров (validate_zoom_params-compatible).
+ """
+ if x is None or x.ndim != 4:
+ return x
+
+ zm = zp.get("zoom_mode", "grid_warp")
+ if hasattr(zm, "value"):
+ zm = str(zm.value)
+ else:
+ zm = str(zm).lower()
+
+ backend = resolve_zoom_backend(zm, zp.get("zoom_engine", "auto"))
+
+ bm = zp.get("blend_mode", "circular_reflect")
+ if hasattr(bm, "value"):
+ bm = str(bm.value)
+ else:
+ bm = str(bm).lower()
+
+ edge_fade_val = bool(zp.get("edge_fade", zp.get("zoom_in_fade", True)))
+ fade_to_black_val = bool(zp.get("zoom_fade_to_black", zp.get("fade_to_black", False)))
+ fade_strength_val = float(zp.get("zoom_fade_strength", zp.get("fade_strength", 0.15)))
+
+ if backend == ZOOM_BACKEND_GEOMETRY:
+ return apply_geometry_zoom_latent(
+ x,
+ zoom_factor = float(zp.get("zoom_factor", 0.0)),
+ convergence_point = float(zp.get("convergence_point", 0.5)),
+ convergence_y = float(zp.get("convergence_y", 0.5)),
+ pan_x = float(zp.get("pan_x", 0.0)),
+ pan_y = float(zp.get("pan_y", 0.0)),
+ interp_mode = str(zp.get("interp_mode", "bilinear")),
+ zoom_mode = zm,
+ spiral_rotation = float(zp.get("spiral_rotation", 0.5)),
+ spiral_direction = coerce_spiral_direction(zp.get("spiral_direction", 1.0)),
+ depth_power = float(zp.get("depth_power", 1.0)),
+ auto_clamp_pan = bool(zp.get("auto_clamp_pan", True)),
+ )
+ return apply_canvas_zoom_latent(
+ x,
+ zoom_mode = zm,
+ zoom_factor = float(zp.get("zoom_factor", 0.0)),
+ convergence_point = float(zp.get("convergence_point", 0.5)),
+ convergence_y = float(zp.get("convergence_y", 0.5)),
+ pan_x = float(zp.get("pan_x", 0.0)),
+ pan_y = float(zp.get("pan_y", 0.0)),
+ interp_mode = str(zp.get("interp_mode", "bilinear")),
+ depth_power = float(zp.get("depth_power", 1.0)),
+ blend_mode = bm,
+ noise_strength = float(zp.get("noise_strength", 1.0)),
+ edge_fade = edge_fade_val,
+ variance_correction = bool(zp.get("variance_correction", True)),
+ auto_clamp_pan = bool(zp.get("auto_clamp_pan", True)),
+ adaptive_noise_scale= bool(zp.get("adaptive_noise_scale",True)),
+ fade_to_black = fade_to_black_val,
+ fade_strength = fade_strength_val,
+ gradient_center_x = float(zp.get("gradient_center_x", 0.5)),
+ gradient_center_y = float(zp.get("gradient_center_y", 0.5)),
+ gradient_radius = float(zp.get("gradient_radius", 1.0)),
+ noise_scale = float(zp.get("noise_scale", 5.0)),
+ noise_octaves = int(zp.get("noise_octaves", 2)),
+ seed = int(seed),
+ )
+
+
+@torch.no_grad()
+def sample_kohaku_lonyu_yog(model, x, sigmas, extra_args=None, callback=None,
+ disable=None, s_churn=0., s_tmin=0., s_tmax=float('inf'),
+ s_noise=1., noise_sampler=None, eta=1.):
+ """
+ Kohaku_LoNyu_Yog Sampler - Geometric Second-Order Method
+ """
+ extra_args = {} if extra_args is None else extra_args
+ s_in = x.new_ones([x.shape[0]])
+ noise_sampler = default_noise_sampler(x) if noise_sampler is None else noise_sampler
+
+ steps_total = len(sigmas) - 1
+ halfway_point = steps_total // 2
+
+ for i in trange(steps_total, disable=disable, desc="Kohaku Sampling"):
+ gamma = min(s_churn / steps_total, 2 ** 0.5 - 1) if s_tmin <= sigmas[i] <= s_tmax else 0.
+ sigma_hat = sigmas[i] * (gamma + 1)
+
+ if gamma > 0:
+ eps = torch.randn_like(x) * s_noise
+ x = x + eps * (sigma_hat ** 2 - sigmas[i] ** 2) ** 0.5
+
+ denoised = model(x, sigma_hat * s_in, **extra_args)
+ d = to_d(x, sigma_hat, denoised)
+
+ sigma_down, sigma_up = get_ancestral_step(sigmas[i], sigmas[i + 1], eta=eta)
+ dt = sigma_down - sigmas[i]
+
+ if i <= halfway_point:
+ x_antipode = -x
+
+ denoised2 = model(x_antipode, sigma_hat * s_in, **extra_args)
+ d2 = to_d(x_antipode, sigma_hat, denoised2)
+
+ v_down = (d + d2) / 2
+ x_closer = x + v_down * dt
+
+ denoised3 = model(x_closer, sigma_hat * s_in, **extra_args)
+ d3 = to_d(x_closer, sigma_hat, denoised3)
+
+ real_d = (d + d3) / 2
+ x = x + real_d * dt
+
+ if sigma_up > 0:
+ x = x + noise_sampler(sigmas[i], sigmas[i + 1]) * s_noise * sigma_up
+ else:
+ x = x + d * dt
+ if sigma_up > 0:
+ x = x + noise_sampler(sigmas[i], sigmas[i + 1]) * s_noise * sigma_up
+
+ if callback is not None:
+ callback({
+ 'x': x,
+ 'i': i,
+ 'sigma': sigmas[i],
+ 'sigma_hat': sigma_hat,
+ 'denoised': denoised
+ })
+
+ return x
+
+# ========================================================================
+# LRU CACHE SYSTEM - Enhanced memory management
+# ========================================================================
+
+class LRUCache:
+ """Thread-safe LRU cache with size limits and memory management"""
+ def __init__(self, max_size=50, max_memory_mb=500):
+ self.cache = OrderedDict()
+ self.max_size = max_size
+ self.max_memory_mb = max_memory_mb
+ self.current_memory_mb = 0
+
+ def _estimate_size_mb(self, tensor):
+ """Estimate tensor size in MB"""
+ if isinstance(tensor, torch.Tensor):
+ return tensor.element_size() * tensor.nelement() / (1024 * 1024)
+ return 0
+
+ def get(self, key):
+ """Get cached value, move to end (most recent)"""
+ if key in self.cache:
+ self.cache.move_to_end(key)
+ return self.cache[key]
+ return None
+
+ def set(self, key, value):
+ """Set value with automatic eviction if needed"""
+ size_mb = self._estimate_size_mb(value)
+
+ # Evict old entries if needed
+ while (len(self.cache) >= self.max_size or
+ self.current_memory_mb + size_mb > self.max_memory_mb):
+ if len(self.cache) == 0:
+ break
+ old_key, old_value = self.cache.popitem(last=False)
+ self.current_memory_mb -= self._estimate_size_mb(old_value)
+ if isinstance(old_value, torch.Tensor) and old_value.is_cuda:
+ del old_value
+
+ self.cache[key] = value
+ self.cache.move_to_end(key)
+ self.current_memory_mb += size_mb
+
+ def clear(self):
+ """Clear all cache"""
+ for value in self.cache.values():
+ if isinstance(value, torch.Tensor) and value.is_cuda:
+ del value
+ self.cache.clear()
+ self.current_memory_mb = 0
+
+# Enhanced cache instances (keep compatibility with old dict-based caches)
+_VORONOI_CACHE = LRUCache(max_size=20, max_memory_mb=100)
+
+# ========================================================================
+# ZOOM EASING HELPERS
+# ========================================================================
+
+def _zoom_easing_fn(t: float, mode: str) -> float:
+ """
+ Map t ∈ [0,1] through an easing curve.
+ instant — hard cut: 0 everywhere, 1 at t=1
+ linear — no curve
+ ease_in — starts slow, accelerates
+ ease_out — starts fast, decelerates
+ ease_in_out — S-curve (default)
+ """
+ t = max(0.0, min(1.0, t))
+ if mode == "instant":
+ return 1.0 if t >= 1.0 else 0.0
+ if mode == "linear":
+ return t
+ if mode == "ease_in":
+ return t * t
+ if mode == "ease_out":
+ return 1.0 - (1.0 - t) * (1.0 - t)
+ # ease_in_out (default / fallback)
+ if t < 0.5:
+ return 2.0 * t * t
+ return 1.0 - (-2.0 * t + 2.0) ** 2 / 2.0
+
+
+# ========================================================================
+# VALIDATION UTILITIES - Protect against NaN/Inf
+# ========================================================================
+
+def validate_float(value, min_val=None, max_val=None, default=0.0, name="parameter"):
+ """Safely validate and clamp float values"""
+ try:
+ val = float(value)
+ if math.isnan(val) or math.isinf(val):
+ print(f"⚠ Warning: {name} is NaN/Inf, using default {default}")
+ return default
+ if min_val is not None and val < min_val:
+ return min_val
+ if max_val is not None and val > max_val:
+ return max_val
+ return val
+ except (ValueError, TypeError):
+ print(f"⚠ Warning: Invalid {name}, using default {default}")
+ return default
+
+def validate_int(value, min_val=None, max_val=None, default=0, name="parameter"):
+ """Safely validate and clamp integer values"""
+ try:
+ val = int(value)
+ if min_val is not None and val < min_val:
+ return min_val
+ if max_val is not None and val > max_val:
+ return max_val
+ return val
+ except (ValueError, TypeError):
+ print(f"⚠ Warning: Invalid {name}, using default {default}")
+ return default
+
+def coerce_spiral_direction(value, default=1.0):
+ """
+ Normalise spiral_direction to ±1.0.
+ Accepts floats/ints OR the label strings that Gradio Radio may return
+ when choices are defined as (label, value) tuples.
+ """
+ if isinstance(value, str):
+ s = value.strip().lower()
+ if s in {"clockwise", "cw", "+1", "1", "1.0"}:
+ return 1.0
+ if s in {"counter-clockwise", "counterclockwise",
+ "anti-clockwise", "anticlockwise", "ccw", "-1", "-1.0"}:
+ return -1.0
+ return default
+ try:
+ v = float(value)
+ return 1.0 if v >= 0 else -1.0
+ except (TypeError, ValueError):
+ return default
+
+def validate_tensor(tensor, name="tensor"):
+ """Check tensor for NaN/Inf values"""
+ if isinstance(tensor, torch.Tensor):
+ if torch.isnan(tensor).any():
+ print(f"⚠ Warning: {name} contains NaN values!")
+ return torch.nan_to_num(tensor, nan=0.0)
+ if torch.isinf(tensor).any():
+ print(f"⚠ Warning: {name} contains Inf values!")
+ return torch.nan_to_num(tensor, posinf=1.0, neginf=-1.0)
+ return tensor
+
+# ========================================================================
+# РАСШИРЕННЫЕ ФУНКЦИИ ПАДДИНГА
+# ========================================================================
+
+def get_or_create_mask(h, w, device):
+ """Кэширование масок для оптимизации"""
+ key = (h, w, str(device))
+ if key not in _MASK_CACHE:
+ row_indices = torch.arange(h, device=device).view(1, 1, h, 1)
+ _MASK_CACHE[key] = (row_indices % 2 == 1)
+ return _MASK_CACHE[key]
+
+def compute_anisotropic_padding(input_tensor, pad_h, pad_w, angle_deg=45, angle_deg2=None, angle_mix=1.0):
+ """
+ Анизотропный паддинг - разное поведение по диагоналям.
+ Эмулирует направленные материалы (дерево, металл, волокна).
+ """
+ b, c, h, w = input_tensor.shape
+
+ # Базовые паддинги: circular и reflect
+ padded = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+ padded_reflect = _safe_pad4d(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='reflect')
+
+ # Размеры уже с учетом паддинга
+ _, H, W = padded.shape[1:]
+
+ # Преобразуем угол в радианы
+ angle_rad = math.radians(angle_deg)
+
+ # Координаты в нормализованной системе для всего padded-тензора
+ y_coords = torch.linspace(-1.0, 1.0, steps=H, device=input_tensor.device, dtype=input_tensor.dtype).view(1, 1, H, 1)
+ x_coords = torch.linspace(-1.0, 1.0, steps=W, device=input_tensor.device, dtype=input_tensor.dtype).view(1, 1, 1, W)
+
+ # Проекция на направление волокон
+ directional_component = x_coords * math.cos(angle_rad) + y_coords * math.sin(angle_rad)
+ directional_strength = directional_component.abs()
+
+ # Optional second direction (advanced): blend two angle fields
+ if angle_deg2 is not None:
+ angle_mix = float(max(0.0, min(float(angle_mix), 1.0)))
+ angle_rad2 = math.radians(float(angle_deg2))
+ directional_component2 = x_coords * math.cos(angle_rad2) + y_coords * math.sin(angle_rad2)
+ directional_strength2 = directional_component2.abs()
+ directional_strength = directional_strength * angle_mix + directional_strength2 * (1.0 - angle_mix)
+
+ # Альфа-блендинг: вдоль направления больше circular, поперек больше reflect
+ alpha = directional_strength.clamp(0.0, 1.0)
+ result = padded * alpha + padded_reflect * (1.0 - alpha)
+
+ return result
+
+def compute_polar_padding(input_tensor, pad_h, pad_w):
+ """
+ Полярный паддинг для сферических проекций.
+ """
+ b, c, h, w = input_tensor.shape
+
+ # X-axis: стандартный circular (долгота замыкается)
+ x = F.pad(input_tensor, (pad_w, pad_w, 0, 0), mode='circular')
+
+ # Y-axis: полярная коррекция (широта через полюса)
+ shift = w // 2
+
+ # Верхний паддинг (Северный полюс)
+ top_strip = x[:, :, :pad_h, :]
+ top_pad = torch.roll(top_strip, shifts=shift, dims=3)
+ top_pad = torch.flip(top_pad, dims=[2])
+
+ # Нижний паддинг (Южный полюс)
+ bot_strip = x[:, :, -pad_h:, :]
+ bot_pad = torch.roll(bot_strip, shifts=shift, dims=3)
+ bot_pad = torch.flip(bot_pad, dims=[2])
+
+ result = torch.cat([top_pad, x, bot_pad], dim=2)
+ return result
+
+
+# ========================================================================
+# NEW ENHANCED MODES - Voronoi, Perlin, Fractal, Adaptive
+# ========================================================================
+
+# ===== EDGE DETECTION for Adaptive Mode =====
+
+def detect_edges_sobel(tensor):
+ """
+ Sobel edge detection для адаптивного блендинга
+ ✅ FLOAT16 FIX: Безопасная нормализация
+ """
+ # Convert to grayscale if needed
+ if tensor.shape[1] > 1:
+ gray = tensor.mean(dim=1, keepdim=True)
+ else:
+ gray = tensor
+
+ # Sobel kernels
+ sobel_x = torch.tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]],
+ dtype=tensor.dtype, device=tensor.device).view(1, 1, 3, 3)
+ sobel_y = torch.tensor([[-1, -2, -1], [0, 0, 0], [1, 2, 1]],
+ dtype=tensor.dtype, device=tensor.device).view(1, 1, 3, 3)
+
+ # Apply Sobel
+ edge_x = F.conv2d(gray, sobel_x, padding=1)
+ edge_y = F.conv2d(gray, sobel_y, padding=1)
+
+ # ✅ FIX: Адаптивный epsilon для sqrt и нормализации
+ eps_val = get_safe_epsilon(tensor.dtype)
+
+ # Magnitude с защитой
+ edges = torch.sqrt(edge_x ** 2 + edge_y ** 2 + eps_val)
+
+ # Normalize с защитой от деления на ноль
+ edges_max = torch.clamp(edges.max(), min=eps_val)
+ edges = edges / edges_max
+
+ return edges
+
+# ===== VORONOI ORGANIC TILING =====
+
+def compute_voronoi_padding(input_tensor, pad_h, pad_w, num_cells=8, seed=42):
+ """
+ Voronoi diagram-based organic tiling
+ ✅ FLOAT16 FIX: Защищенный sqrt и деление
+ """
+ b, c, h, w = input_tensor.shape
+ device = input_tensor.device
+ dtype = input_tensor.dtype # ✅ FIX: Получаем dtype
+
+ # Validate parameters
+ num_cells = validate_int(num_cells, min_val=4, max_val=32, default=8, name="voronoi_cells")
+ seed = validate_int(seed, min_val=0, max_val=99999, default=42, name="voronoi_seed")
+
+ # ✅ FIX: Адаптивный epsilon
+ eps_val = get_safe_epsilon(dtype)
+
+ # Cache key
+ cache_key = (h, w, pad_h, pad_w, num_cells, seed, str(device))
+ cached_map = _VORONOI_CACHE.get(cache_key)
+
+ if cached_map is None:
+ # Create extended canvas
+ H_ext = h + 2 * pad_h
+ W_ext = w + 2 * pad_w
+
+ # Generate random Voronoi cell centers
+ # BUG FIX 9 (continued): local Generator keeps Voronoi reproducible
+ # without touching the global RNG state.
+ _vg = torch.Generator(device=device)
+ _vg.manual_seed(seed)
+ centers_y = torch.rand(num_cells, device=device, generator=_vg) * H_ext
+ centers_x = torch.rand(num_cells, device=device, generator=_vg) * W_ext
+
+ # Create coordinate grids
+ y_grid = torch.arange(H_ext, device=device, dtype=torch.float32).view(-1, 1)
+ x_grid = torch.arange(W_ext, device=device, dtype=torch.float32).view(1, -1)
+
+ # Compute distances to all centers
+ distances = []
+ for i in range(num_cells):
+ # ✅ FIX: Добавлен eps_val для защиты sqrt
+ dist = torch.sqrt((y_grid - centers_y[i])**2 + (x_grid - centers_x[i])**2 + eps_val)
+ distances.append(dist)
+
+ distances = torch.stack(distances, dim=0)
+
+ # Find nearest cell for each pixel
+ nearest_cell = torch.argmin(distances, dim=0)
+
+ # Create mapping from extended to source coordinates
+ voronoi_map = torch.zeros(2, H_ext, W_ext, device=device, dtype=torch.float32)
+
+ for cell_id in range(num_cells):
+ mask = (nearest_cell == cell_id)
+ # Map this region to corresponding source region (with wrapping)
+ y_offset = (centers_y[cell_id] % h) - h // 2
+ x_offset = (centers_x[cell_id] % w) - w // 2
+
+ y_coords_masked = y_grid.expand_as(mask)[mask]
+ x_coords_masked = x_grid.expand_as(mask)[mask]
+
+ voronoi_map[0][mask] = (y_coords_masked - y_offset) % h
+ voronoi_map[1][mask] = (x_coords_masked - x_offset) % w
+
+ _VORONOI_CACHE.set(cache_key, voronoi_map)
+ cached_map = voronoi_map
+
+ # Apply mapping using grid_sample
+ # Normalize coordinates to [-1, 1]
+ grid = cached_map.permute(1, 2, 0).unsqueeze(0) # [1, H_ext, W_ext, 2]
+ grid = grid.to(dtype=torch.float32) # fp16-safe: grid всегда float32
+
+ # ✅ FIX: Защита от деления на 0
+ h_safe = max(h - 1, 1)
+ w_safe = max(w - 1, 1)
+ grid[..., 0] = (grid[..., 0] / h_safe) * 2 - 1 # y
+ grid[..., 1] = (grid[..., 1] / w_safe) * 2 - 1 # x
+
+ # Sample from input
+ result = F.grid_sample(
+ input_tensor,
+ grid,
+ mode='bilinear',
+ padding_mode='border',
+ align_corners=False
+ )
+
+ return result
+
+# ===== PERLIN NOISE DISTORTION =====
+
+def generate_perlin_noise(height, width, scale=10.0, octaves=4, persistence=0.5, device='cuda'):
+ """
+ Generate Perlin-like noise using multiple octaves of smoothed noise
+ """
+ def smooth_noise(noise):
+ return F.avg_pool2d(
+ F.pad(noise, (1, 1, 1, 1), mode='reflect'),
+ kernel_size=3, stride=1, padding=0
+ )
+
+ total_noise = torch.zeros(1, 1, height, width, device=device)
+ amplitude = 1.0
+ frequency = 1.0
+ max_value = 0.0
+
+ for _ in range(octaves):
+ # Generate random noise at this frequency
+ noise_h = int(height / scale * frequency) + 1
+ noise_w = int(width / scale * frequency) + 1
+
+ noise = torch.rand(1, 1, noise_h, noise_w, device=device) * 2 - 1
+
+ # Smooth and upscale
+ for _ in range(3): # Multiple smoothing passes
+ noise = smooth_noise(noise)
+
+ # Resize to target size
+ noise = F.interpolate(noise, size=(height, width), mode='bilinear', align_corners=False)
+
+ total_noise += noise * amplitude
+ max_value += amplitude
+
+ amplitude *= persistence
+ frequency *= 2.0
+
+ # Normalize
+ total_noise /= max_value
+ return total_noise
+
+def compute_perlin_padding(input_tensor, pad_h, pad_w, strength=0.3, scale=10.0):
+ """
+ Apply Perlin noise distortion for natural-looking tiling
+ """
+ # Validate parameters
+ strength = validate_float(strength, min_val=0.0, max_val=1.0, default=0.3, name="perlin_strength")
+ scale = validate_float(scale, min_val=1.0, max_val=50.0, default=10.0, name="perlin_scale")
+
+ b, c, h, w = input_tensor.shape
+ device = input_tensor.device
+
+ # BUG FIX 8: Compute extended canvas dimensions directly instead of
+ # allocating a full padded tensor that is used only to read .shape.
+ # This saves one full-size allocation.
+ H_ext = h + 2 * pad_h
+ W_ext = w + 2 * pad_w
+
+ # Generate Perlin noise for displacement
+ noise_y = generate_perlin_noise(H_ext, W_ext, scale=scale, device=device)
+ noise_x = generate_perlin_noise(H_ext, W_ext, scale=scale * 1.3, device=device)
+
+ # Create coordinate grid
+ y_coords = torch.linspace(0, h - 1, H_ext, device=device, dtype=torch.float32).view(1, 1, H_ext, 1).expand(1, 1, H_ext, W_ext)
+ x_coords = torch.linspace(0, w - 1, W_ext, device=device, dtype=torch.float32).view(1, 1, 1, W_ext).expand(1, 1, H_ext, W_ext)
+
+ # Apply distortion
+ distortion_strength = strength * max(pad_h, pad_w)
+ y_distorted = (y_coords + noise_y * distortion_strength) % h
+ x_distorted = (x_coords + noise_x * distortion_strength) % w
+
+ # Create sampling grid
+ # FIX V3.6: Убираем лишнюю размерность канала .squeeze(1)
+ grid = torch.stack([x_distorted, y_distorted], dim=-1).squeeze(1) # Становится (1, H_ext, W_ext, 2)
+
+ # BUG FIX 7: protect against 1-pixel inputs (w-1 == 0 → div-by-zero / NaN).
+ # Voronoi already uses this pattern; apply it here consistently.
+ h_safe = max(h - 1, 1)
+ w_safe = max(w - 1, 1)
+ grid[..., 0] = (grid[..., 0] / w_safe) * 2 - 1 # Normalize x to [-1, 1]
+ grid[..., 1] = (grid[..., 1] / h_safe) * 2 - 1 # Normalize y to [-1, 1]
+
+ # Sample with distortion (from input_tensor directly, not from padded)
+ result = F.grid_sample(
+ input_tensor,
+ grid.expand(b, -1, -1, -1),
+ mode='bilinear',
+ padding_mode='border',
+ align_corners=True
+ )
+
+ return result
+
+# ===== FRACTAL RECURSIVE TILING =====
+
+def compute_fractal_padding(input_tensor, pad_h, pad_w, iterations=2, scale_factor=0.6):
+ """
+ Fractal recursive tiling - creates self-similar patterns
+ Each iteration adds scaled version of the pattern
+ """
+ iterations = validate_int(iterations, min_val=1, max_val=4, default=2, name="fractal_iterations")
+ scale_factor = validate_float(scale_factor, min_val=0.3, max_val=0.9, default=0.6, name="fractal_scale")
+
+ # Base padding
+ result = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+
+ b, c, h_ext, w_ext = result.shape
+
+ # Add fractal details
+ for i in range(1, iterations + 1):
+ scale = scale_factor ** i
+
+ # Scale down the pattern
+ scaled_h = max(8, int(h_ext * scale))
+ scaled_w = max(8, int(w_ext * scale))
+
+ scaled_pattern = F.interpolate(
+ result,
+ size=(scaled_h, scaled_w),
+ mode='bilinear',
+ align_corners=False
+ )
+
+ # Tile it across the result
+ tiles_y = (h_ext + scaled_h - 1) // scaled_h
+ tiles_x = (w_ext + scaled_w - 1) // scaled_w
+
+ tiled = scaled_pattern.repeat(1, 1, tiles_y, tiles_x)
+ tiled = tiled[:, :, :h_ext, :w_ext]
+
+ # Blend with decreasing strength
+ alpha = 0.3 / (i + 1)
+ result = result * (1 - alpha) + tiled * alpha
+
+ return result
+
+# ===== ADAPTIVE SMART MODE =====
+
+def compute_adaptive_padding(input_tensor, pad_h, pad_w, edge_threshold=0.1):
+ """
+ Adaptive padding that analyzes image content and chooses best mode
+ Uses edge detection to decide between circular, reflect, or blend
+ """
+ edge_threshold = validate_float(edge_threshold, min_val=0.0, max_val=1.0, default=0.1, name="adaptive_threshold")
+
+ # Detect edges
+ edges = detect_edges_sobel(input_tensor)
+
+ # Analyze edge intensity at borders
+ top_edge = edges[:, :, :min(pad_h, edges.shape[2]), :].mean()
+ bottom_edge = edges[:, :, -min(pad_h, edges.shape[2]):, :].mean()
+ left_edge = edges[:, :, :, :min(pad_w, edges.shape[3])].mean()
+ right_edge = edges[:, :, :, -min(pad_w, edges.shape[3]):].mean()
+
+ avg_edge = (top_edge + bottom_edge + left_edge + right_edge) / 4
+
+ # Decide mode based on edge strength
+ if avg_edge < edge_threshold:
+ # Low edge content -> circular works well
+ return F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+ elif avg_edge > 0.5:
+ # High edge content -> use blend mode
+ return compute_blend_padding(input_tensor, pad_h, pad_w, strength=0.7)
+ else:
+ # Medium edge content -> adaptive blend
+ blend_strength = float(avg_edge) * 1.5 # Scale to [0, 0.75]
+ return compute_blend_padding(input_tensor, pad_h, pad_w, strength=blend_strength)
+
+# ===== ENHANCED BLEND MODE (improved version) =====
+
+def create_edge_blend_mask(h, w, blend_width, device, dtype=torch.float32):
+ """
+ Create gradient mask for soft edge blending
+ Returns mask with smooth falloff at borders
+ """
+ mask = torch.ones(h, w, device=device, dtype=dtype)
+
+ if blend_width <= 0:
+ return mask.unsqueeze(0).unsqueeze(0)
+
+ blend_w = min(blend_width, w // 4)
+ blend_h = min(blend_width, h // 4)
+
+ # Horizontal edges (left and right)
+ for i in range(blend_w):
+ alpha = (i + 1) / (blend_w + 1)
+ alpha = alpha ** 0.5 # Gamma correction
+ mask[:, i] = alpha
+ mask[:, -(i + 1)] = alpha
+
+ # Vertical edges (top and bottom)
+ for i in range(blend_h):
+ alpha = (i + 1) / (blend_h + 1)
+ alpha = alpha ** 0.5
+ mask[i, :] = torch.minimum(mask[i, :], torch.tensor(alpha, device=device, dtype=dtype))
+ mask[-(i + 1), :] = torch.minimum(mask[-(i + 1), :], torch.tensor(alpha, device=device, dtype=dtype))
+
+ return mask.unsqueeze(0).unsqueeze(0)
+
+def compute_blend_padding(input_tensor, pad_h, pad_w, strength=0.5, blend_width=None):
+ """
+ Enhanced Soft Blend Edges implementation
+ Blends between circular and reflect padding modes at the borders
+ """
+ strength = validate_float(strength, min_val=0.0, max_val=1.0, default=0.5, name="blend_strength")
+
+ # Auto blend width if not specified
+ if blend_width is None:
+ blend_width = max(pad_h, pad_w)
+
+ # Create both padding modes
+ circular = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+ reflect = _safe_pad4d(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='reflect')
+
+ # Create blend mask
+ h, w = circular.shape[-2:]
+ mask = create_edge_blend_mask(h, w, blend_width, input_tensor.device, input_tensor.dtype)
+
+ # Apply blending with strength control
+ alpha = mask * strength + (1 - strength) * 0.5
+ alpha = alpha.expand_as(circular)
+
+ result = circular * alpha + reflect * (1 - alpha)
+ return result
+
+
+# ===================================
+# CUBEMAP (3D) — Engine A (Fast) + Engine B (Seam-Blend)
+# ===================================
+
+def _safe_pad4d(x, pad, mode='reflect', value=0.0):
+ """
+ Safe wrapper around F.pad for 4D tensors.
+ - For mode='reflect', PyTorch requires pad < input_size.
+ If invalid, we fall back to 'replicate' to avoid runtime errors.
+ pad: (left, right, top, bottom)
+ """
+ if not isinstance(pad, (tuple, list)) or len(pad) != 4:
+ return F.pad(x, pad, mode=mode, value=value) if mode == 'constant' else F.pad(x, pad, mode=mode)
+
+ l, r, t, b = pad
+ if mode == 'reflect':
+ h = int(x.shape[-2])
+ w = int(x.shape[-1])
+ if (l >= w) or (r >= w) or (t >= h) or (b >= h):
+ mode = 'replicate'
+
+ if mode == 'constant':
+ return F.pad(x, (l, r, t, b), mode=mode, value=value)
+ return F.pad(x, (l, r, t, b), mode=mode)
+
+
+def _cubemap_split_faces(x):
+ """
+ Splits a 3x2 cubemap net into faces.
+ Layout expected (top row / bottom row):
+ S | E | N
+ B | T | W
+ Returns tuple (S, E, N, B, T, W), each (B,C,h,w)
+ """
+ B, C, H, W = x.shape
+ if H % 2 != 0 or W % 3 != 0:
+ raise ValueError("Cubemap expects H%2==0 and W%3==0 (3x2 net).")
+ h, w = H // 2, W // 3
+ S = x[:, :, 0:h, 0:w]
+ E = x[:, :, 0:h, w:2*w]
+ N = x[:, :, 0:h, 2*w:3*w]
+ Bm = x[:, :, h:2*h, 0:w]
+ T = x[:, :, h:2*h, w:2*w]
+ Wf = x[:, :, h:2*h, 2*w:3*w]
+ return S, E, N, Bm, T, Wf
+
+
+def _cubemap_stitch_faces(S, E, N, Bm, T, Wf):
+ """Stitches faces back into a 3x2 net (S/E/N over B/T/W)."""
+ B, C, h, w = S.shape
+ out = torch.zeros((B, C, h * 2, w * 3), device=S.device, dtype=S.dtype)
+ out[:, :, 0:h, 0:w] = S
+ out[:, :, 0:h, w:2*w] = E
+ out[:, :, 0:h, 2*w:3*w] = N
+ out[:, :, h:2*h, 0:w] = Bm
+ out[:, :, h:2*h, w:2*w] = T
+ out[:, :, h:2*h, 2*w:3*w] = Wf
+ return out
+
+
+def _cubemap_pad_with_adjoint(O, L, R, U, D, pL, pR, pU, pD, pad_mode='replicate',
+ seam_strength=0.0, seam_width=0):
+ """
+ Pads a face O with neighbor strips L/R/U/D (already extracted from adjacent faces).
+ Supports optional seam blending (Engine B) by mixing neighbor padding with O edge.
+ """
+ B, C, h, w = O.shape
+ Hp = h + pU + pD
+ Wp = w + pL + pR
+ Z = torch.zeros((B, C, Hp, Wp), device=O.device, dtype=O.dtype)
+ Z[:, :, pU:pU + h, pL:pL + w] = O
+
+ if pL == 0 and pR == 0 and pU == 0 and pD == 0:
+ return Z
+
+ # Helper: create ramp for seam_width (0 at boundary, 1 at outer pad)
+ def _make_ramp(n, seam_w, device, dtype):
+ if n <= 0:
+ return None
+ seam_w = int(max(0, min(seam_w, n)))
+ if seam_w == 0:
+ return torch.ones((n,), device=device, dtype=dtype)
+ if seam_w == 1:
+ ramp = torch.ones((n,), device=device, dtype=dtype)
+ ramp[0] = 0.0
+ return ramp
+ ramp = torch.ones((n,), device=device, dtype=dtype)
+ ramp[:seam_w] = torch.linspace(0.0, 1.0, steps=seam_w, device=device, dtype=dtype)
+ return ramp
+
+ # Fill left/right strips
+ if pL > 0:
+ Lp = _safe_pad4d(L, (0, 0, pU, pD), mode=pad_mode)
+ strip = Lp
+ if seam_strength > 0.0:
+ Oedge = O[:, :, :, :min(pL, w)]
+ Oedge = _safe_pad4d(Oedge, (0, max(0, pL - Oedge.shape[-1]), pU, pD), mode='replicate')
+ ramp = _make_ramp(pL, seam_width, O.device, O.dtype).view(1, 1, 1, pL)
+ blend_scheme = Oedge * (1.0 - ramp) + strip * ramp
+ strip = strip * (1.0 - seam_strength) + blend_scheme * seam_strength
+ Z[:, :, :, :pL] = strip
+
+ if pR > 0:
+ Rp = _safe_pad4d(R, (0, 0, pU, pD), mode=pad_mode)
+ strip = Rp
+ if seam_strength > 0.0:
+ Oedge = O[:, :, :, max(0, w - pR):w]
+ need = pR - Oedge.shape[-1]
+ Oedge = _safe_pad4d(Oedge, (max(0, need), 0, pU, pD), mode='replicate')
+ ramp = _make_ramp(pR, seam_width, O.device, O.dtype).view(1, 1, 1, pR).flip(-1)
+ blend_scheme = Oedge * (1.0 - ramp) + strip * ramp
+ strip = strip * (1.0 - seam_strength) + blend_scheme * seam_strength
+ Z[:, :, :, -pR:] = strip
+
+ # Fill top/bottom strips
+ if pU > 0:
+ Up = _safe_pad4d(U, (pL, pR, 0, 0), mode=pad_mode)
+ strip = Up
+ if seam_strength > 0.0:
+ Oedge = O[:, :, :min(pU, h), :]
+ Oedge = _safe_pad4d(Oedge, (pL, pR, 0, max(0, pU - Oedge.shape[-2])), mode='replicate')
+ ramp = _make_ramp(pU, seam_width, O.device, O.dtype).view(1, 1, pU, 1)
+ blend_scheme = Oedge * (1.0 - ramp) + strip * ramp
+ strip = strip * (1.0 - seam_strength) + blend_scheme * seam_strength
+ Z[:, :, :pU, :] = strip
+
+ if pD > 0:
+ Dp = _safe_pad4d(D, (pL, pR, 0, 0), mode=pad_mode)
+ strip = Dp
+ if seam_strength > 0.0:
+ Oedge = O[:, :, max(0, h - pD):h, :]
+ need = pD - Oedge.shape[-2]
+ Oedge = _safe_pad4d(Oedge, (pL, pR, max(0, need), 0), mode='replicate')
+ ramp = _make_ramp(pD, seam_width, O.device, O.dtype).view(1, 1, pD, 1).flip(-2)
+ blend_scheme = Oedge * (1.0 - ramp) + strip * ramp
+ strip = strip * (1.0 - seam_strength) + blend_scheme * seam_strength
+ Z[:, :, -pD:, :] = strip
+
+ # Fix corners overlapping (same as cubemap(3).py logic)
+ if pU and pL:
+ Z[:, :, :pU, :pL] /= 2
+ if pU and pR:
+ Z[:, :, :pU, -pR:] /= 2
+ if pD and pL:
+ Z[:, :, -pD:, :pL] /= 2
+ if pD and pR:
+ Z[:, :, -pD:, -pR:] /= 2
+
+ return Z
+
+
+def conv2d_cubemap_batched(input_tensor, weight, bias, stride, dilation, groups,
+ pad_h, pad_w, pad_mode='replicate',
+ engine='A (Fast)', seam_width=0, seam_strength=0.0):
+ """
+ Cubemap convolution for a 3x2 cubemap net (S/E/N over B/T/W), using 1 conv call:
+ - Engine A: neighbor padding (fast, like cubemap(3).py but batched)
+ - Engine B: same, but with seam-aware blending inside padding regions.
+ NOTE: Requires square faces (h == w) to keep rotations consistent.
+ """
+ if pad_h != pad_w:
+ return F.conv2d(input_tensor, weight, bias, stride, (pad_h, pad_w), dilation, groups)
+
+ if pad_h == 0 and pad_w == 0:
+ return F.conv2d(input_tensor, weight, bias, stride, (0, 0), dilation, groups)
+
+ try:
+ S, E, N, Bm, T, Wf = _cubemap_split_faces(input_tensor)
+ except Exception:
+ return F.conv2d(input_tensor, weight, bias, stride, (pad_h, pad_w), dilation, groups)
+
+ B, C, h, w = S.shape
+ if h != w:
+ return F.conv2d(input_tensor, weight, bias, stride, (pad_h, pad_w), dilation, groups)
+
+ p = int(pad_h)
+ pL = pR = pU = pD = p
+
+ seam_strength = float(max(0.0, min(seam_strength, 1.0))) if (engine or '').startswith('B') else 0.0
+ seam_width = int(max(0, seam_width))
+
+ ZS = _cubemap_pad_with_adjoint(
+ S,
+ L=Wf[:, :, :, -pL:],
+ R=E[:, :, :, :pR],
+ U=T[:, :, -pU:, :],
+ D=Bm[:, :, :pD, :],
+ pL=pL, pR=pR, pU=pU, pD=pD,
+ pad_mode=pad_mode,
+ seam_strength=seam_strength,
+ seam_width=seam_width
+ )
+
+ ZE = _cubemap_pad_with_adjoint(
+ E,
+ L=S[:, :, :, -pL:],
+ R=N[:, :, :, :pR],
+ U=torch.rot90(T[:, :, :, -pU:], k=-1, dims=[2, 3]),
+ D=torch.rot90(Bm[:, :, :, -pD:], k=+1, dims=[2, 3]),
+ pL=pL, pR=pR, pU=pU, pD=pD,
+ pad_mode=pad_mode,
+ seam_strength=seam_strength,
+ seam_width=seam_width
+ )
+
+ ZN = _cubemap_pad_with_adjoint(
+ N,
+ L=E[:, :, :, -pL:],
+ R=Wf[:, :, :, :pR],
+ U=T[:, :, :pU, :].flip(-1),
+ D=Bm[:, :, -pD:, :].flip(-1),
+ pL=pL, pR=pR, pU=pU, pD=pD,
+ pad_mode=pad_mode,
+ seam_strength=seam_strength,
+ seam_width=seam_width
+ )
+
+ ZB = _cubemap_pad_with_adjoint(
+ Bm,
+ L=torch.rot90(Wf[:, :, -pL:, :], k=+1, dims=[2, 3]),
+ R=torch.rot90(E[:, :, -pR:, :], k=-1, dims=[2, 3]),
+ U=S[:, :, -pU:, :],
+ D=N[:, :, -pD:, :].flip(-1),
+ pL=pL, pR=pR, pU=pU, pD=pD,
+ pad_mode=pad_mode,
+ seam_strength=seam_strength,
+ seam_width=seam_width
+ )
+
+ ZT = _cubemap_pad_with_adjoint(
+ T,
+ L=torch.rot90(Wf[:, :, :pL, :], k=-1, dims=[2, 3]),
+ R=torch.rot90(E[:, :, :pR, :], k=+1, dims=[2, 3]),
+ U=N[:, :, :pU, :].flip(-1),
+ D=S[:, :, :pD, :],
+ pL=pL, pR=pR, pU=pU, pD=pD,
+ pad_mode=pad_mode,
+ seam_strength=seam_strength,
+ seam_width=seam_width
+ )
+
+ ZW = _cubemap_pad_with_adjoint(
+ Wf,
+ L=N[:, :, :, -pL:],
+ R=S[:, :, :, :pR],
+ U=torch.rot90(T[:, :, :, :pL], k=+1, dims=[2, 3]),
+ D=torch.rot90(Bm[:, :, :, :pD], k=-1, dims=[2, 3]),
+ pL=pL, pR=pR, pU=pU, pD=pD,
+ pad_mode=pad_mode,
+ seam_strength=seam_strength,
+ seam_width=seam_width
+ )
+
+ Z = torch.cat([ZS, ZE, ZN, ZB, ZT, ZW], dim=0)
+ Y = F.conv2d(Z, weight, bias, stride, (0, 0), dilation, groups)
+ YS, YE, YN, YB, YT, YW = Y.chunk(6, dim=0)
+
+ return _cubemap_stitch_faces(YS, YE, YN, YB, YT, YW)
+
+# ===================================
+# CUBEMAP (3D) — Engine C (GridSample / True 3D mapping)
+# ===================================
+
+def _ypr_rotation_matrix(yaw_deg: float, pitch_deg: float, roll_deg: float, device, dtype):
+ """
+ Builds a rotation matrix from yaw/pitch/roll angles (degrees).
+ Convention:
+ - yaw around +Y axis
+ - pitch around +X axis
+ - roll around +Z axis
+ Applied as: R = Rz(roll) @ Rx(pitch) @ Ry(yaw)
+ """
+ yaw = math.radians(float(yaw_deg))
+ pitch = math.radians(float(pitch_deg))
+ roll = math.radians(float(roll_deg))
+
+ cy, sy = math.cos(yaw), math.sin(yaw)
+ cp, sp = math.cos(pitch), math.sin(pitch)
+ cr, sr = math.cos(roll), math.sin(roll)
+
+ # Ry (yaw)
+ Ry = torch.tensor([[cy, 0.0, sy],
+ [0.0, 1.0, 0.0],
+ [-sy, 0.0, cy]], device=device, dtype=dtype)
+
+ # Rx (pitch)
+ Rx = torch.tensor([[1.0, 0.0, 0.0],
+ [0.0, cp, -sp],
+ [0.0, sp, cp]], device=device, dtype=dtype)
+
+ # Rz (roll)
+ Rz = torch.tensor([[cr, -sr, 0.0],
+ [sr, cr, 0.0],
+ [0.0, 0.0, 1.0]], device=device, dtype=dtype)
+
+ return (Rz @ Rx @ Ry)
+
+
+def _cubemap_dirs_from_face_uv(face_id: int, u, v):
+ """
+ Maps face-local (u,v) to 3D direction vectors BEFORE normalization.
+ Faces in our atlas mapping:
+ 0: Front (+Z) -> S
+ 1: Right (+X) -> E
+ 2: Back (-Z) -> N
+ 3: Bottom (-Y) -> Bm
+ 4: Top (+Y) -> T
+ 5: Left (-X) -> Wf
+ u, v are broadcastable tensors, typically shaped (Hp, Wp) or (1,1,Hp,Wp)
+ """
+ if face_id == 0: # +Z (Front)
+ x, y, z = u, -v, torch.ones_like(u)
+ elif face_id == 1: # +X (Right)
+ x, y, z = torch.ones_like(u), -v, -u
+ elif face_id == 2: # -Z (Back)
+ x, y, z = -u, -v, -torch.ones_like(u)
+ elif face_id == 3: # -Y (Bottom)
+ x, y, z = u, -torch.ones_like(u), -v
+ elif face_id == 4: # +Y (Top)
+ x, y, z = u, torch.ones_like(u), v
+ elif face_id == 5: # -X (Left)
+ x, y, z = -torch.ones_like(u), -v, u
+ else:
+ raise ValueError("Invalid face_id for cubemap.")
+ return x, y, z
+
+
+def _cubemap_dir_to_atlas_grid(x, y, z, face_h: int, face_w: int, device, dtype):
+ """
+ Converts 3D direction vectors to a single atlas (3x2 net) sampling grid in [-1,1].
+ Returns grid shaped (..., 2) with last dim [x_norm, y_norm].
+
+ ✅ FLOAT16 FIX: Использует адаптивный epsilon!
+ 🔧 FIX #5: Координаты приводятся к float32 для точности вычислений
+ """
+ # 🔧 FIX #5: Приведение к float32 для точных вычислений (избегаем артефактов в fp16)
+ x = x.to(torch.float32)
+ y = y.to(torch.float32)
+ z = z.to(torch.float32)
+
+ # ✅ FIX: Адаптивный epsilon для float32 (т.к. теперь все в float32)
+ eps_val = get_safe_epsilon(torch.float32)
+ eps = torch.tensor(eps_val, device=device, dtype=torch.float32)
+
+ # Normalize directions (avoid divide-by-zero)
+ inv_len = torch.rsqrt(torch.clamp(x * x + y * y + z * z, min=eps_val))
+ x = x * inv_len
+ y = y * inv_len
+ z = z * inv_len
+
+ ax = x.abs()
+ ay = y.abs()
+ az = z.abs()
+
+ # Major axis selection
+ is_x = (ax >= ay) & (ax >= az)
+ is_y = (ay >= ax) & (ay >= az)
+ is_z = ~(is_x | is_y)
+
+ # Face index map: 0..5
+ face_idx = torch.empty_like(x, dtype=torch.int64)
+
+ # Defaults (placeholders)
+ u = torch.zeros_like(x)
+ v = torch.zeros_like(x)
+
+ # +X / -X
+ mask = is_x & (x >= 0)
+ face_idx[mask] = 1
+ u[mask] = -z[mask] / (ax[mask] + eps) # ✅ eps теперь безопасен для float16
+ v[mask] = -y[mask] / (ax[mask] + eps)
+
+ mask = is_x & (x < 0)
+ face_idx[mask] = 5
+ u[mask] = z[mask] / (ax[mask] + eps)
+ v[mask] = -y[mask] / (ax[mask] + eps)
+
+ # +Y / -Y
+ mask = is_y & (y >= 0)
+ face_idx[mask] = 4
+ u[mask] = x[mask] / (ay[mask] + eps)
+ v[mask] = z[mask] / (ay[mask] + eps)
+
+ mask = is_y & (y < 0)
+ face_idx[mask] = 3
+ u[mask] = x[mask] / (ay[mask] + eps)
+ v[mask] = -z[mask] / (ay[mask] + eps)
+
+ # +Z / -Z
+ mask = is_z & (z >= 0)
+ face_idx[mask] = 0
+ u[mask] = x[mask] / (az[mask] + eps)
+ v[mask] = -y[mask] / (az[mask] + eps)
+
+ mask = is_z & (z < 0)
+ face_idx[mask] = 2
+ u[mask] = -x[mask] / (az[mask] + eps)
+ v[mask] = -y[mask] / (az[mask] + eps)
+
+ # Atlas tile offsets (col,row) for each face_idx
+ # 0:F -> (0,0), 1:R -> (1,0), 2:B -> (2,0), 3:Bo -> (0,1), 4:T -> (1,1), 5:L -> (2,1)
+ col = torch.zeros_like(u)
+ row = torch.zeros_like(v)
+
+ col = torch.where(face_idx == 0, torch.tensor(0.0, device=device, dtype=dtype), col)
+ row = torch.where(face_idx == 0, torch.tensor(0.0, device=device, dtype=dtype), row)
+
+ col = torch.where(face_idx == 1, torch.tensor(1.0, device=device, dtype=dtype), col)
+ row = torch.where(face_idx == 1, torch.tensor(0.0, device=device, dtype=dtype), row)
+
+ col = torch.where(face_idx == 2, torch.tensor(2.0, device=device, dtype=dtype), col)
+ row = torch.where(face_idx == 2, torch.tensor(0.0, device=device, dtype=dtype), row)
+
+ col = torch.where(face_idx == 3, torch.tensor(0.0, device=device, dtype=dtype), col)
+ row = torch.where(face_idx == 3, torch.tensor(1.0, device=device, dtype=dtype), row)
+
+ col = torch.where(face_idx == 4, torch.tensor(1.0, device=device, dtype=dtype), col)
+ row = torch.where(face_idx == 4, torch.tensor(1.0, device=device, dtype=dtype), row)
+
+ col = torch.where(face_idx == 5, torch.tensor(2.0, device=device, dtype=dtype), col)
+ row = torch.where(face_idx == 5, torch.tensor(1.0, device=device, dtype=dtype), row)
+
+ # Convert (u,v) [-1,1] -> atlas pixel coords -> normalized coords [-1,1]
+ H_atlas = int(face_h * 2)
+ W_atlas = int(face_w * 3)
+
+ # align_corners=True mapping uses (W-1)/(H-1)
+ x_pix = col * face_w + (u + 1.0) * 0.5 * (face_w - 1)
+ y_pix = row * face_h + (v + 1.0) * 0.5 * (face_h - 1)
+
+ x_norm = (x_pix / max(W_atlas - 1, 1)) * 2.0 - 1.0
+ y_norm = (y_pix / max(H_atlas - 1, 1)) * 2.0 - 1.0
+
+ # 🔧 FIX #5: Возвращаем в исходный dtype после вычислений
+ grid = torch.stack([x_norm, y_norm], dim=-1).to(dtype)
+ return grid
+
+
+def _build_cubemap_engine_c_grids(face_h: int, face_w: int, pad: int,
+ yaw: float, pitch: float, roll: float,
+ coord_mode: str = "Cartesian (Face UV)",
+ twist_deg: float = 0.0,
+ polar_scale: float = 1.0,
+ polar_power: float = 1.0,
+ swirl_deg: float = 0.0,
+ swirl_power: float = 1.0,
+ device=None, dtype=None,
+ antipode: bool = False,
+ angle_quant: float = 0.5):
+ """
+ Builds and caches per-face sampling grids (Engine C) for cubemap atlas.
+ Grids map each pixel in a padded face to the correct location in the 3x2 atlas.
+ """
+ if face_h <= 1 or face_w <= 1:
+ return None
+
+ # Quantize angles to stabilize caching
+ q = float(angle_quant)
+ q_milli = int(round(float(q) * 1000.0))
+ if q_milli <= 0: q_milli = 1
+ yaw_t = int(round(float(yaw) / q))
+ pitch_t = int(round(float(pitch) / q))
+ roll_t = int(round(float(roll) / q))
+ twist_t = int(round(float(twist_deg) / q))
+ swirl_t = int(round(float(swirl_deg) / q))
+ yaw_q = float(yaw_t) * q
+ pitch_q = float(pitch_t) * q
+ roll_q = float(roll_t) * q
+ twist_q = float(twist_t) * q
+ swirl_q = float(swirl_t) * q
+
+ # Quantize continuous params a bit for caching
+ polar_scale_q = round(float(polar_scale) * 100.0) / 100.0
+ polar_power_q = round(float(polar_power) * 100.0) / 100.0
+ swirl_power_q = round(float(swirl_power) * 100.0) / 100.0
+
+ dev_type = getattr(device, "type", None)
+ dev_index = getattr(device, "index", None)
+ key = (
+ str(dev_type) if dev_type is not None else str(device),
+ int(dev_index) if dev_index is not None else -1,
+ str(dtype), int(face_h), int(face_w), int(pad),
+ str(coord_mode),
+ int(yaw_t), int(pitch_t), int(roll_t),
+ int(twist_t),
+ int(round(float(polar_scale_q) * 100.0)), int(round(float(polar_power_q) * 100.0)),
+ int(swirl_t), int(round(float(swirl_power_q) * 100.0)),
+ bool(antipode), int(q_milli))
+ cached = _CUBEMAP_GRID_CACHE.get(key, None)
+ if cached is not None:
+ return cached
+
+ p = int(max(0, pad))
+ Hp = int(face_h + 2 * p)
+ Wp = int(face_w + 2 * p)
+
+ # Face-local u,v coordinate system (padded)
+ # u maps across width, v maps across height. Center region uses u,v in [-1,1].
+ j = torch.arange(Wp, device=device, dtype=dtype)
+ i = torch.arange(Hp, device=device, dtype=dtype)
+ denom_w = float(max(face_w - 1, 1))
+ denom_h = float(max(face_h - 1, 1))
+ u = 2.0 * ((j - p) / denom_w) - 1.0
+ v = 2.0 * ((i - p) / denom_h) - 1.0
+
+ # Broadcast to (Hp,Wp)
+ u2 = u.view(1, Wp).expand(Hp, Wp)
+ v2 = v.view(Hp, 1).expand(Hp, Wp)
+
+ # Advanced UV transform (twist / polar warp / swirl)
+ if coord_mode is None:
+ coord_mode = "Cartesian (Face UV)"
+ cm = str(coord_mode)
+ twist_rad = float(twist_q) * (math.pi / 180.0)
+ swirl_rad = float(swirl_q) * (math.pi / 180.0)
+ do_polar = cm.startswith("Polar")
+ if abs(twist_rad) > 1e-9 or abs(swirl_rad) > 1e-9 or do_polar:
+ # 🔧 FIX #4: Добавлен eps_val для защиты sqrt от NaN в float16
+
+ eps_val = get_safe_epsilon(dtype)
+
+ r = torch.sqrt(u2 * u2 + v2 * v2 + eps_val)
+ # clamp radius for numerical stability in padding areas
+ r_clamped = torch.clamp(r, 0.0, 2.0)
+ theta = torch.atan2(v2, u2)
+ theta = theta + twist_rad
+ if abs(swirl_rad) > 1e-9:
+ sp = float(swirl_power_q)
+ theta = theta + swirl_rad * torch.pow(r_clamped, sp)
+ if do_polar:
+ ps = float(polar_scale_q)
+ pp = float(polar_power_q)
+ r2 = torch.pow(torch.clamp(r_clamped * ps, min=0.0), pp)
+ else:
+ r2 = r
+ u2 = r2 * torch.cos(theta)
+ v2 = r2 * torch.sin(theta)
+
+ R = _ypr_rotation_matrix(yaw_q, pitch_q, roll_q, device=device, dtype=dtype)
+
+ grids = []
+ for face_id in range(6):
+ x, y, z = _cubemap_dirs_from_face_uv(face_id, u2, v2)
+
+ # Rotate directions
+ # (Hp,Wp,3) @ (3,3)^T
+ dirs = torch.stack([x, y, z], dim=-1)
+ dirs = torch.matmul(dirs, R.transpose(0, 1))
+
+ if antipode:
+ dirs = -dirs
+
+ grid = _cubemap_dir_to_atlas_grid(
+ dirs[..., 0], dirs[..., 1], dirs[..., 2],
+ face_h=face_h, face_w=face_w,
+ device=device, dtype=dtype
+ )
+ grids.append(grid)
+
+ grids = torch.stack(grids, dim=0) # (6,Hp,Wp,2)
+ _CUBEMAP_GRID_CACHE[key] = grids
+ return grids
+
+
+def _grid_sample_geoaa(atlas, grid, samples: int = 1, radius_px: float = 0.0,
+ mode: str = "bilinear", padding_mode: str = "border"):
+ """
+ Optional geometric AA (multi-sampling) for Engine C.
+ - samples: 1..4
+ - radius_px: pixel radius in atlas space (approx)
+ """
+ samples = int(max(1, min(int(samples), 4)))
+ radius_px = float(max(0.0, radius_px))
+ # sanitize grid_sample args
+ if mode not in ("bilinear", "nearest"):
+ mode = "bilinear"
+ if padding_mode not in ("border", "reflection", "zeros"):
+ padding_mode = "border"
+
+
+ if samples == 1 or radius_px <= 0.0:
+ return F.grid_sample(atlas, grid, mode=mode, padding_mode=padding_mode, align_corners=True)
+
+ B, C, H, W = atlas.shape
+ # normalize radius to grid space (align_corners=True => 1px == 2/(W-1))
+ dx = (radius_px * 2.0) / max(W - 1, 1)
+ dy = (radius_px * 2.0) / max(H - 1, 1)
+
+ offsets = [(0.0, 0.0)]
+ if samples >= 2:
+ offsets.append((dx, dy))
+ if samples >= 3:
+ offsets.append((-dx, dy))
+ if samples >= 4:
+ offsets.append((dx, -dy))
+
+ acc = None
+ for ox, oy in offsets:
+ g = grid.clone()
+ g[..., 0] = (g[..., 0] + ox).clamp(-1.0, 1.0)
+ g[..., 1] = (g[..., 1] + oy).clamp(-1.0, 1.0)
+ y = F.grid_sample(atlas, g, mode=mode, padding_mode=padding_mode, align_corners=True)
+ acc = y if acc is None else (acc + y)
+
+ return acc / float(len(offsets))
+
+
+def conv2d_cubemap_gridsample(input_tensor, weight, bias, stride, dilation, groups,
+ pad_h, pad_w,
+ yaw=0.0, pitch=0.0, roll=0.0,
+ coord_mode="Cartesian (Face UV)", twist_deg=0.0,
+ polar_scale=1.0, polar_power=1.0,
+ swirl_deg=0.0, swirl_power=1.0,
+ grid_interp="bilinear", grid_padding="border",
+ cache_angle_quant=0.5,
+ geoaa_samples=1, geoaa_radius_px=0.0,
+ antipode_strength=0.0):
+ """
+ Engine C: True 3D cubemap mapping using grid_sample.
+ - Builds padded faces by sampling from the full 3x2 atlas via direction mapping.
+ - Supports yaw/pitch/roll rotation of the sampling directions.
+ - Optional geometric AA (multi-sampling) and Kohaku-inspired antipode mixing.
+ """
+ if pad_h != pad_w:
+ return F.conv2d(input_tensor, weight, bias, stride, (pad_h, pad_w), dilation, groups)
+
+ p = int(pad_h)
+ if p <= 0:
+ return F.conv2d(input_tensor, weight, bias, stride, (0, 0), dilation, groups)
+
+ B, C, H, W = input_tensor.shape
+ if H % 2 != 0 or W % 3 != 0:
+ return F.conv2d(input_tensor, weight, bias, stride, (pad_h, pad_w), dilation, groups)
+
+ face_h = H // 2
+ face_w = W // 3
+ if face_h != face_w:
+ return F.conv2d(input_tensor, weight, bias, stride, (pad_h, pad_w), dilation, groups)
+
+ device = input_tensor.device
+ # grid_sample expects float grid; use float32 for stability if input is fp16/bf16
+ grid_dtype = torch.float32 if input_tensor.dtype in (torch.float16, torch.bfloat16) else input_tensor.dtype
+
+ grids = _build_cubemap_engine_c_grids(face_h, face_w, p, yaw, pitch, roll,
+ coord_mode, twist_deg, polar_scale, polar_power,
+ swirl_deg, swirl_power,
+ device, grid_dtype,
+ antipode=False,
+ angle_quant=cache_angle_quant)
+ if grids is None:
+ return F.conv2d(input_tensor, weight, bias, stride, (pad_h, pad_w), dilation, groups)
+
+ antipode_strength = float(max(0.0, min(float(antipode_strength), 1.0)))
+
+ if antipode_strength > 0.0:
+ grids_anti = _build_cubemap_engine_c_grids(face_h, face_w, p, yaw, pitch, roll,
+ coord_mode, twist_deg, polar_scale, polar_power,
+ swirl_deg, swirl_power,
+ device, grid_dtype,
+ antipode=True,
+ angle_quant=cache_angle_quant)
+ else:
+ grids_anti = None
+
+ Hp = int(face_h + 2 * p)
+ Wp = int(face_w + 2 * p)
+
+ faces_padded = []
+ for face_id in range(6):
+ g = grids[face_id].to(device=device)
+ gB = g.unsqueeze(0).expand(B, Hp, Wp, 2).contiguous()
+
+ # grid_sample uses input dtype, but grid dtype may differ; that's ok.
+ y0 = _grid_sample_geoaa(input_tensor, gB, samples=geoaa_samples, radius_px=geoaa_radius_px, mode=grid_interp, padding_mode=grid_padding)
+
+ if grids_anti is not None:
+ ga = grids_anti[face_id].to(device=device)
+ gaB = ga.unsqueeze(0).expand(B, Hp, Wp, 2).contiguous()
+ y1 = _grid_sample_geoaa(input_tensor, gaB, samples=geoaa_samples, radius_px=geoaa_radius_px, mode=grid_interp, padding_mode=grid_padding)
+ y0 = y0 * (1.0 - antipode_strength) + y1 * antipode_strength
+
+ faces_padded.append(y0)
+
+ Z = torch.cat(faces_padded, dim=0) # (6B,C,Hp,Wp)
+ Y = F.conv2d(Z, weight, bias, stride, (0, 0), dilation, groups)
+ YS, YE, YN, YB, YT, YW = Y.chunk(6, dim=0)
+
+ return _cubemap_stitch_faces(YS, YE, YN, YB, YT, YW)
+
+
+
+# ========================================================================
+# PANORAMA LIVE (Equirectangular) — Engine C (3D grid_sample)
+# ========================================================================
+
+def _get_blur_kernel_1d(radius: int, device, dtype):
+ """Depthwise 1D blur kernel along X (width)."""
+ r = int(max(0, radius))
+ if r <= 0:
+ return None
+ k = 2 * r + 1
+ dev_type = getattr(device, "type", None)
+ dev_index = getattr(device, "index", None)
+ key = (int(k), str(dev_type) if dev_type is not None else str(device), int(dev_index) if dev_index is not None else -1, str(dtype))
+ ker = _BLUR_KERNEL_CACHE.get(key, None)
+ if ker is not None:
+ return ker
+ # Simple box kernel (stable, cheap). You can swap to Gaussian if needed.
+ w = torch.ones((k,), device=device, dtype=dtype) / float(k)
+ ker = w.view(1, 1, 1, k) # (1,1,1,k)
+ _BLUR_KERNEL_CACHE[key] = ker
+ return ker
+
+
+def _apply_pole_blur_smoothing(x, strength: float = 0.0, radius: int = 0, power: float = 1.0):
+ """
+ Applies circular horizontal blur near poles (top/bottom) with a smooth mask.
+ x: (B,C,H,W)
+ """
+ strength = float(max(0.0, min(float(strength), 1.0)))
+ radius = int(max(0, int(radius)))
+ power = float(max(0.25, min(float(power), 4.0)))
+
+ if strength <= 0.0 or radius <= 0:
+ return x
+
+ B, C, H, W = x.shape
+ device = x.device
+ dtype = x.dtype
+
+ ker = _get_blur_kernel_1d(radius, device, dtype)
+ if ker is None:
+ return x
+
+ # Pole mask: 1 near top/bottom, 0 near equator
+ yy = torch.linspace(0.0, 1.0, steps=H, device=device, dtype=dtype).view(1, 1, H, 1)
+ t = torch.abs(yy - 0.5) * 2.0 # 0 at equator, 1 at poles
+ pole_mask = torch.pow(torch.clamp(t, 0.0, 1.0), power) # (1,1,H,1)
+
+ # Circular pad along X then depthwise conv
+ xp = F.pad(x, (radius, radius, 0, 0), mode="circular")
+ # Depthwise conv: expand kernel per-channel
+ weight = ker.expand(C, 1, 1, ker.shape[-1]).contiguous()
+ blurred = F.conv2d(xp, weight, bias=None, stride=1, padding=0, groups=C)
+
+ m = pole_mask * strength
+ return x * (1.0 - m) + blurred * m
+
+
+def _build_panorama_engine_c_grid(H: int, W: int, pad_h: int, pad_w: int,
+ yaw: float, pitch: float, roll: float,
+ coord_mode: str = "Cartesian (lon/lat)",
+ polar_scale: float = 1.0,
+ polar_power: float = 1.0,
+ twist_deg: float = 0.0,
+ twist_power: float = 1.0,
+ swirl_deg: float = 0.0,
+ swirl_power: float = 1.0,
+ pole_ease_power: float = 1.0,
+ antipode: bool = False,
+ angle_quant: float = 0.5,
+ device=None, dtype=None):
+ """
+ Builds/caches a sampling grid for equirectangular panoramas.
+ Grid maps output pixels in a padded canvas to source coords in the original panorama.
+ Uses true 3D spherical mapping (yaw/pitch/roll) and optional UV warps.
+ """
+ if H <= 1 or W <= 1:
+ return None
+
+ ph = int(max(0, pad_h))
+ pw = int(max(0, pad_w))
+ Hp = int(H + 2 * ph)
+ Wp = int(W + 2 * pw)
+
+ q = float(max(0.1, float(angle_quant)))
+ q_milli = int(round(float(q) * 1000.0))
+ if q_milli <= 0: q_milli = 1
+ yaw_t = int(round(float(yaw) / q))
+ pitch_t = int(round(float(pitch) / q))
+ roll_t = int(round(float(roll) / q))
+ twist_t = int(round(float(twist_deg) / q))
+ swirl_t = int(round(float(swirl_deg) / q))
+ yaw_q = float(yaw_t) * q
+ pitch_q = float(pitch_t) * q
+ roll_q = float(roll_t) * q
+ twist_q = float(twist_t) * q
+ swirl_q = float(swirl_t) * q
+
+ polar_scale_q = round(float(polar_scale) * 100.0) / 100.0
+ polar_power_q = round(float(polar_power) * 100.0) / 100.0
+ twist_power_q = round(float(twist_power) * 100.0) / 100.0
+ swirl_power_q = round(float(swirl_power) * 100.0) / 100.0
+ pole_ease_q = round(float(pole_ease_power) * 100.0) / 100.0
+
+ dev_type = getattr(device, "type", None)
+ dev_index = getattr(device, "index", None)
+ key = (
+ str(dev_type) if dev_type is not None else str(device),
+ int(dev_index) if dev_index is not None else -1,
+ str(dtype), int(H), int(W), int(ph), int(pw),
+ str(coord_mode),
+ int(yaw_t), int(pitch_t), int(roll_t),
+ int(twist_t), int(round(float(twist_power_q) * 100.0)),
+ int(swirl_t), int(round(float(swirl_power_q) * 100.0)),
+ int(round(float(polar_scale_q) * 100.0)), int(round(float(polar_power_q) * 100.0)),
+ int(round(float(pole_ease_q) * 100.0)),
+ bool(antipode), int(q_milli))
+ cached = _PANO_GRID_CACHE.get(key, None)
+ if cached is not None:
+ return cached
+
+ # Output pixel -> base lon/lat (can extend beyond [0,1] in padding; that's OK)
+ j = torch.arange(Wp, device=device, dtype=dtype)
+ i = torch.arange(Hp, device=device, dtype=dtype)
+
+ denom_w = float(max(W - 1, 1))
+ denom_h = float(max(H - 1, 1))
+
+ u = (j - pw) / denom_w # 0..1 over original image
+ v = (i - ph) / denom_h
+
+ u2 = u.view(1, Wp).expand(Hp, Wp)
+ v2 = v.view(Hp, 1).expand(Hp, Wp)
+
+ # lon in radians (wrap naturally via sin/cos); lat in radians (can go beyond poles)
+ lon = (u2 - 0.5) * (2.0 * math.pi)
+ lat = (0.5 - v2) * math.pi
+
+ cm = str(coord_mode or "Cartesian (lon/lat)")
+ do_polar = cm.startswith("Polar")
+
+ # --- Optional twist & swirl in (lon,lat) domain ---
+ # Twist is latitude-dependent longitude shift ("roll" feel along parallels)
+ tr = float(twist_q) * (math.pi / 180.0)
+ tp = float(max(0.25, min(float(twist_power_q), 4.0)))
+ if abs(tr) > 1e-9:
+ t = torch.clamp(torch.abs(lat) / (0.5 * math.pi), 0.0, 1.0)
+ lon = lon + tr * torch.sign(lat) * torch.pow(t, tp)
+
+ sr = float(swirl_q) * (math.pi / 180.0)
+ sp = float(max(0.25, min(float(swirl_power_q), 4.0)))
+ if abs(sr) > 1e-9:
+ # Swirl strongest near poles by default
+ t = torch.clamp(torch.abs(lat) / (0.5 * math.pi), 0.0, 1.0)
+ lon = lon + sr * torch.pow(t, sp)
+
+ # --- Polar mode: radial warp around poles via latitude reparameterization ---
+ if do_polar:
+ ps = float(max(0.01, float(polar_scale_q)))
+ pp = float(max(0.25, min(float(polar_power_q), 6.0)))
+ # t=0 at equator, t=1 at poles
+ t = torch.clamp(torch.abs(lat) / (0.5 * math.pi), 0.0, 1.0)
+ r = 1.0 - t # r=1 at equator, 0 at poles
+ r2 = torch.pow(torch.clamp(r * ps, min=0.0, max=1.0), pp)
+ t2 = 1.0 - r2
+ lat = torch.sign(lat) * t2 * (0.5 * math.pi)
+
+ # Convert (lon,lat) to 3D direction
+ cl = torch.cos(lon)
+ sl = torch.sin(lon)
+ ca = torch.cos(lat)
+ sa = torch.sin(lat)
+
+ x = sl * ca
+ y = sa
+ z = cl * ca
+
+ # Apply global rotation
+ R = _ypr_rotation_matrix(yaw_q, pitch_q, roll_q, device=device, dtype=dtype)
+ dirs = torch.stack([x, y, z], dim=-1)
+ dirs = torch.matmul(dirs, R.transpose(0, 1))
+
+ if antipode:
+ dirs = -dirs
+
+ # Back to lon/lat
+ x2 = dirs[..., 0]
+ y2 = torch.clamp(dirs[..., 1], -1.0, 1.0)
+ z2 = dirs[..., 2]
+
+ lon2 = torch.atan2(x2, z2) # [-pi,pi]
+ lat2 = torch.asin(y2) # [-pi/2,pi/2]
+
+ # Pole easing curve (power) on latitude magnitude
+ pe = float(max(0.25, min(float(pole_ease_q), 6.0)))
+ if abs(pe - 1.0) > get_safe_epsilon(torch.float16):
+ t = torch.clamp(torch.abs(lat2) / (0.5 * math.pi), 0.0, 1.0)
+ t = torch.pow(t, pe)
+ lat2 = torch.sign(lat2) * t * (0.5 * math.pi)
+
+ # Convert to source UV [0,1) with X wrap
+ u_src = (lon2 / (2.0 * math.pi)) + 0.5
+ u_src = torch.remainder(u_src, 1.0) # wrap horizontally
+ v_src = 0.5 - (lat2 / math.pi) # 0..1
+
+ # to normalized grid_sample coords [-1,1]
+ x_norm = u_src * 2.0 - 1.0
+ y_norm = v_src * 2.0 - 1.0
+
+ # 🔧 FIX #5: Возвращаем в исходный dtype после вычислений
+ grid = torch.stack([x_norm, y_norm], dim=-1).to(dtype) # (Hp,Wp,2)
+ _PANO_GRID_CACHE[key] = grid
+ return grid
+
+
+def conv2d_panorama_gridsample(input_tensor, weight, bias, stride, dilation, groups,
+ pad_h, pad_w,
+ yaw=0.0, pitch=0.0, roll=0.0,
+ coord_mode="Cartesian (lon/lat)",
+ polar_scale=1.0, polar_power=1.0,
+ twist_deg=0.0, twist_power=1.0,
+ swirl_deg=0.0, swirl_power=1.0,
+ pole_ease_power=1.0,
+ grid_interp="bilinear", grid_padding="border",
+ cache_angle_quant=0.5,
+ geoaa_samples=1, geoaa_radius_px=0.0,
+ antipode_strength=0.0,
+ pole_blur_strength=0.0, pole_blur_radius=0, pole_blur_power=1.0):
+ """
+ Panorama Live Engine C:
+ - Builds a padded panorama by sampling the original via 3D spherical mapping.
+ - Runs conv2d without extra padding.
+ - Optional Kohaku-style antipode mixing and pole blur smoothing.
+ """
+ ph = int(max(0, int(pad_h)))
+ pw = int(max(0, int(pad_w)))
+ if ph <= 0 and pw <= 0:
+ return F.conv2d(input_tensor, weight, bias, stride, (0, 0), dilation, groups)
+
+ B, C, H, W = input_tensor.shape
+ device = input_tensor.device
+ grid_dtype = torch.float32 if input_tensor.dtype in (torch.float16, torch.bfloat16) else input_tensor.dtype
+
+ grid = _build_panorama_engine_c_grid(
+ H, W, ph, pw,
+ yaw=yaw, pitch=pitch, roll=roll,
+ coord_mode=coord_mode,
+ polar_scale=polar_scale, polar_power=polar_power,
+ twist_deg=twist_deg, twist_power=twist_power,
+ swirl_deg=swirl_deg, swirl_power=swirl_power,
+ pole_ease_power=pole_ease_power,
+ antipode=False,
+ angle_quant=cache_angle_quant,
+ device=device, dtype=grid_dtype
+ )
+ if grid is None:
+ return F.conv2d(input_tensor, weight, bias, stride, (pad_h, pad_w), dilation, groups)
+
+ Hp = int(H + 2 * ph)
+ Wp = int(W + 2 * pw)
+
+ gB = grid.unsqueeze(0).expand(B, Hp, Wp, 2).contiguous()
+ y0 = _grid_sample_geoaa(input_tensor, gB, samples=geoaa_samples, radius_px=geoaa_radius_px,
+ mode=grid_interp, padding_mode=grid_padding)
+
+ antipode_strength = float(max(0.0, min(float(antipode_strength), 1.0)))
+ if antipode_strength > 0.0:
+ grid_a = _build_panorama_engine_c_grid(
+ H, W, ph, pw,
+ yaw=yaw, pitch=pitch, roll=roll,
+ coord_mode=coord_mode,
+ polar_scale=polar_scale, polar_power=polar_power,
+ twist_deg=twist_deg, twist_power=twist_power,
+ swirl_deg=swirl_deg, swirl_power=swirl_power,
+ pole_ease_power=pole_ease_power,
+ antipode=True,
+ angle_quant=cache_angle_quant,
+ device=device, dtype=grid_dtype
+ )
+ gaB = grid_a.unsqueeze(0).expand(B, Hp, Wp, 2).contiguous()
+ y1 = _grid_sample_geoaa(input_tensor, gaB, samples=geoaa_samples, radius_px=geoaa_radius_px,
+ mode=grid_interp, padding_mode=grid_padding)
+ y0 = y0 * (1.0 - antipode_strength) + y1 * antipode_strength
+
+ # Optional pole blur
+ y0 = _apply_pole_blur_smoothing(y0,
+ strength=pole_blur_strength,
+ radius=pole_blur_radius,
+ power=pole_blur_power)
+
+ return F.conv2d(y0, weight, bias, stride, (0, 0), dilation, groups)
+
+def compute_stereoscopic_padding(input_tensor, pad_h, pad_w, eye='left',
+ convergence=0.05, separation=0.065):
+ """
+ Стереоскопический паддинг для 3D изображений.
+ eye: 'left', 'right' или 'both'
+ """
+ b, c, h, w = input_tensor.shape
+
+ eye = (eye or 'left').lower()
+ shift_amount = int(w * separation)
+
+ x_coords = torch.linspace(
+ 0.0, 1.0, w,
+ device=input_tensor.device,
+ dtype=input_tensor.dtype
+ ).view(1, 1, 1, w)
+ depth_map = torch.abs(x_coords - convergence).expand(b, c, h, w)
+ alpha = depth_map.clamp(0.0, 1.0)
+
+ if eye == 'left':
+ shifted = torch.roll(input_tensor, shifts=shift_amount, dims=3)
+ stereo_adjusted = input_tensor * (1.0 - alpha) + shifted * alpha
+ elif eye == 'right':
+ shifted = torch.roll(input_tensor, shifts=-shift_amount, dims=3)
+ stereo_adjusted = input_tensor * (1.0 - alpha) + shifted * alpha
+ else:
+ # 'both' — симметричный режим
+ shifted_left = torch.roll(input_tensor, shifts=shift_amount, dims=3)
+ shifted_right = torch.roll(input_tensor, shifts=-shift_amount, dims=3)
+ shifted_avg = 0.5 * (shifted_left + shifted_right)
+ stereo_adjusted = input_tensor * (1.0 - alpha) + shifted_avg * alpha
+
+ padded = F.pad(stereo_adjusted, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+ return padded
+
+def compute_hex_padding_x(input_tensor, pad_l, pad_r):
+ """Гексагональный паддинг (из v2.0)"""
+ b, c, h, w = input_tensor.shape
+ odd_mask = get_or_create_mask(h, w, input_tensor.device).expand(b, c, h, w)
+
+ shift = w // 2
+ input_shifted = torch.roll(input_tensor, shifts=shift, dims=3)
+ source = torch.where(odd_mask, input_shifted, input_tensor)
+
+ left_pad = source[:, :, :, -pad_l:]
+ right_pad = source[:, :, :, :pad_r]
+
+ return torch.cat([left_pad, input_tensor, right_pad], dim=3)
+
+# ========================================================================
+# ГЛАВНАЯ ФУНКЦИЯ ПАДДИНГА
+# ========================================================================
+# ========================================================================
+# ИСПРАВЛЕНИЕ: Функции для обеспечения правильных размеров тензоров
+# ========================================================================
+
+def ensure_output_size_match(output_tensor, expected_h, expected_w):
+ """
+ УЛУЧШЕННАЯ версия: Гарантирует точное совпадение размеров.
+ Критично для VAE ResNet блоков с skip connections.
+ FIX для ошибки: RuntimeError: The size of tensor a must match the size of tensor b
+ """
+ if output_tensor is None:
+ return None
+
+ b, c, h, w = output_tensor.shape
+
+ # Точное совпадение - возвращаем как есть
+ if h == expected_h and w == expected_w:
+ return output_tensor
+
+ # Вычисляем разницу
+ diff_h = h - expected_h
+ diff_w = w - expected_w
+
+ # ✅ КРИТИЧЕСКОЕ ИСПРАВЛЕНИЕ: используем центральный crop/pad
+ if diff_h > 0 or diff_w > 0:
+ # Обрезаем лишнее (центрируем)
+ crop_h_start = max(0, diff_h // 2)
+ crop_w_start = max(0, diff_w // 2)
+ crop_h_end = crop_h_start + expected_h
+ crop_w_end = crop_w_start + expected_w
+
+ # Защита от выхода за границы
+ crop_h_end = min(crop_h_end, h)
+ crop_w_end = min(crop_w_end, w)
+
+ result = output_tensor[:, :, crop_h_start:crop_h_end, crop_w_start:crop_w_end]
+
+ # Если всё ещё не совпадает - используем интерполяцию
+ if result.shape[2] != expected_h or result.shape[3] != expected_w:
+ result = F.interpolate(result, size=(expected_h, expected_w),
+ mode='bilinear', align_corners=False)
+ return result
+ else:
+ # Добавляем padding (симметричный)
+ pad_h_total = -diff_h
+ pad_w_total = -diff_w
+
+ pad_h_left = pad_h_total // 2
+ pad_h_right = pad_h_total - pad_h_left
+ pad_w_left = pad_w_total // 2
+ pad_w_right = pad_w_total - pad_w_left
+
+ result = F.pad(output_tensor,
+ (pad_w_left, pad_w_right, pad_h_left, pad_h_right),
+ mode='replicate')
+
+ # Финальная проверка
+ if result.shape[2] != expected_h or result.shape[3] != expected_w:
+ result = F.interpolate(result, size=(expected_h, expected_w),
+ mode='bilinear', align_corners=False)
+ return result
+
+def compute_expected_output_size(input_h, input_w, kernel_size, stride, padding, dilation):
+ """Вычисляет ожидаемый размер выходного тензора после свертки."""
+ k_h, k_w = kernel_size if isinstance(kernel_size, tuple) else (kernel_size, kernel_size)
+ s_h, s_w = stride if isinstance(stride, tuple) else (stride, stride)
+ d_h, d_w = dilation if isinstance(dilation, tuple) else (dilation, dilation)
+
+ if isinstance(padding, (tuple, list)):
+ p_h, p_w = padding[0], padding[1]
+ elif isinstance(padding, int):
+ p_h, p_w = padding, padding
+ else:
+ p_h, p_w = 0, 0
+
+ out_h = ((input_h + 2*p_h - d_h*(k_h-1) - 1) // s_h) + 1
+ out_w = ((input_w + 2*p_w - d_w*(k_w-1) - 1) // s_w) + 1
+ return out_h, out_w
+
+def custom_padding_forward(input_tensor, weight, bias, stride, padding, dilation, groups, params):
+ """
+ ИСПРАВЛЕННАЯ версия custom_padding_forward с фиксом размеров тензоров.
+
+ КРИТИЧЕСКИЕ ИЗМЕНЕНИЯ:
+ 1. Вычисляем ожидаемый размер выходного тензора ПЕРЕД применением padding
+ 2. После всех операций проверяем и корректируем размеры
+ 3. Гарантируем совместимость с skip connections в UNet
+ """
+ try:
+ # ===== ШАГ 1: Сохраняем оригинальные размеры =====
+ b, c, orig_h, orig_w = input_tensor.shape
+
+ # 🔧 FIX #1: Создаем унифицированную переменную для результата
+ tiled_output = None
+
+ # ===== ШАГ 2: Вычисляем ожидаемый размер ВЫХОДНОГО тензора =====
+ # Это размер, который должен получиться после свертки с оригинальным padding
+ k_h, k_w = weight.shape[2], weight.shape[3]
+
+ # Обрабатываем разные форматы padding
+ if isinstance(padding, str):
+ if padding == 'same':
+ # Для 'same' padding выход должен совпадать с входом (при stride=1)
+ expected_out_h = orig_h
+ expected_out_w = orig_w
+ elif padding == 'valid':
+ # Для 'valid' padding
+ s_h, s_w = stride if isinstance(stride, tuple) else (stride, stride)
+ d_h, d_w = dilation if isinstance(dilation, tuple) else (dilation, dilation)
+ expected_out_h = ((orig_h - d_h*(k_h-1) - 1) // s_h) + 1
+ expected_out_w = ((orig_w - d_w*(k_w-1) - 1) // s_w) + 1
+ else:
+ # Fallback
+ expected_out_h = orig_h
+ expected_out_w = orig_w
+ else:
+ # Вычисляем для числового padding
+ p_val = padding if isinstance(padding, int) else padding[0]
+ expected_out_h, expected_out_w = compute_expected_output_size(
+ orig_h, orig_w, (k_h, k_w), stride, (p_val, p_val), dilation
+ )
+
+ # ===== ШАГ 3: Проверяем активность тайлинга =====
+ current_step = getattr(shared.state, 'sampling_step', 0) if 'shared' in dir() else 0
+ start_step = params.get('start_step', 0)
+ end_step = params.get('end_step', 9999)
+
+ _in_range = (start_step <= current_step < end_step)
+ _past_end = (current_step >= end_step)
+
+ if not _in_range:
+ # 🔒 Lock after End: keep tiling active past end_step
+ if _past_end and params.get('tiling_lock_after_end', False):
+ pass # fall through to tiling below
+ else:
+ # Тайлинг неактивен - используем стандартную свертку
+ return F.conv2d(input_tensor, weight, bias, stride, padding, dilation, groups)
+
+ # 🎯 Pan One-Shot: apply torch.roll on the very first step of the active range
+ if params.get('tiling_pan_one_shot', False) and current_step == start_step:
+ script_ref = params.get('script_ref', None)
+ _already_panned = getattr(script_ref, '_tiling_pan_one_shot_done', False) if script_ref else True
+ if not _already_panned and script_ref is not None:
+ _px = params.get('pan_x', 0.0)
+ _py = params.get('pan_y', 0.0)
+ if _px or _py:
+ _h, _w = input_tensor.shape[-2], input_tensor.shape[-1]
+ _sh = int(round(_py * _h))
+ _sw = int(round(_px * _w))
+ input_tensor = torch.roll(input_tensor, shifts=(_sh, _sw), dims=(-2, -1))
+ script_ref._tiling_pan_one_shot_done = True
+
+ # Проверка "Disable Advanced Tiling during hires pass"
+ script = params.get('script_ref', None)
+ if params.get('tiling_disable_hr', False) and script is not None:
+ if getattr(script, 'tiling_enable_hr', False) and getattr(script, 'tiling_is_hires', False):
+ return F.conv2d(input_tensor, weight, bias, stride, padding, dilation, groups)
+
+ # ===== ШАГ 4: Вычисляем требуемый padding =====
+ d_h, d_w = (dilation, dilation) if isinstance(dilation, int) else dilation
+
+ if isinstance(padding, str):
+ if padding == 'same':
+ req_pad_h = ((k_h - 1) * d_h) // 2
+ req_pad_w = ((k_w - 1) * d_w) // 2
+ elif padding == 'valid':
+ req_pad_h = req_pad_w = 0
+ else:
+ req_pad_h = req_pad_w = 1
+ elif isinstance(padding, int):
+ req_pad_h = req_pad_w = padding
+ elif isinstance(padding, (tuple, list)):
+ req_pad_h, req_pad_w = padding[0], padding[1]
+ else:
+ req_pad_h = req_pad_w = 0
+
+ # FIX V3.7: Не выходим рано если нет паддинга и нет других режимов
+ if req_pad_h == 0 and req_pad_w == 0:
+ return F.conv2d(input_tensor, weight, bias, stride, padding, dilation, groups)
+
+ mode_x = params.get('mode_x', MODE_OFF)
+ mode_y = params.get('mode_y', MODE_OFF)
+
+ if mode_x == MODE_CUBEMAP or mode_y == MODE_CUBEMAP:
+ cubemap_engine = params.get('cubemap_engine', 'A (Fast)')
+ cubemap_pad_mode = params.get('cubemap_pad_mode', 'replicate')
+ seam_w = int(params.get('cubemap_blend_width', 0) or 0)
+ seam_s = float(params.get('cubemap_blend_strength', 0.0) or 0.0)
+
+ if str(cubemap_engine).startswith('C'):
+ # Engine C: grid_sample cubemap
+ yaw = float(params.get('cubemap_yaw', 0.0) or 0.0)
+ pitch = float(params.get('cubemap_pitch', 0.0) or 0.0)
+ roll = float(params.get('cubemap_roll', 0.0) or 0.0)
+ coord_mode = params.get('cubemap_coord_mode', 'Cartesian (Face UV)')
+ twist_deg = float(params.get('cubemap_twist_deg', 0.0) or 0.0)
+ polar_scale = float(params.get('cubemap_polar_scale', 1.0) or 1.0)
+ polar_power = float(params.get('cubemap_polar_power', 1.0) or 1.0)
+ swirl_deg = float(params.get('cubemap_swirl_deg', 0.0) or 0.0)
+ swirl_power = float(params.get('cubemap_swirl_power', 1.0) or 1.0)
+ grid_interp = params.get('cubemap_grid_interp', 'bilinear')
+ grid_padding = params.get('cubemap_grid_padding', 'border')
+ cache_angle_quant = float(params.get('cubemap_cache_angle_quant', 0.5) or 0.5)
+ geoaa_samples = int(params.get('cubemap_geoaa_samples', 1) or 1)
+ geoaa_radius = float(params.get('cubemap_geoaa_radius_px', 0.0) or 0.0)
+ antipode_strength = float(params.get('cubemap_antipode_strength', 0.0) or 0.0)
+
+ # 🔧 FIX #1: Используем tiled_output
+ tiled_output = conv2d_cubemap_gridsample(
+ input_tensor, weight, bias,
+ stride, dilation, groups,
+ req_pad_h, req_pad_w,
+ yaw=yaw, pitch=pitch, roll=roll,
+ coord_mode=coord_mode, twist_deg=twist_deg,
+ polar_scale=polar_scale, polar_power=polar_power,
+ swirl_deg=swirl_deg, swirl_power=swirl_power,
+ grid_interp=grid_interp, grid_padding=grid_padding,
+ cache_angle_quant=cache_angle_quant,
+ geoaa_samples=geoaa_samples, geoaa_radius_px=geoaa_radius,
+ antipode_strength=antipode_strength
+ )
+ else:
+ # Engine A/B: batched cubemap
+ # 🔧 FIX #1: Используем tiled_output
+ tiled_output = conv2d_cubemap_batched(
+ input_tensor, weight, bias,
+ stride, dilation, groups,
+ req_pad_h, req_pad_w,
+ pad_mode=cubemap_pad_mode,
+ engine=cubemap_engine,
+ seam_width=seam_w,
+ seam_strength=seam_s
+ )
+
+ # ✅ ИСПРАВЛЕНО: Multi-resolution для Cubemap (output-space)
+ if params.get('multires_enabled', False):
+ multires_params = validate_multires_params(params)
+
+ # Создаем простую версию (output space)
+ x_default = F.pad(input_tensor, (req_pad_w, req_pad_w, req_pad_h, req_pad_h),
+ mode='replicate')
+ out_default = F.conv2d(x_default, weight, bias, stride, 0, dilation, groups)
+
+ # Применяем смешивание к OUTPUTS
+ # 🔧 FIX #1: Используем tiled_output
+
+ tiled_output = apply_multires_blend(
+ tensor_simple=out_default,
+ tensor_advanced=tiled_output, # ← ИСПРАВЛЕНО: используем tiled_output!
+ current_step=current_step,
+ start_step=params['start_step'],
+ end_step=params['end_step'],
+ strategy=multires_params['strategy'],
+ transition_start=multires_params['transition_start'],
+ transition_end=multires_params['transition_end'],
+ sharpness=multires_params['sharpness'],
+ enabled=True
+ )
+
+ # ✅ КРИТИЧЕСКОЕ ИСПРАВЛЕНИЕ: корректируем размеры
+ tiled_output = ensure_output_size_match(tiled_output, expected_out_h, expected_out_w)
+ return tiled_output
+
+ # ────────── PANORAMA ──────────
+ elif mode_x == MODE_PANORAMA or mode_y == MODE_PANORAMA:
+ pano_engine = params.get('panorama_engine', 'A (Legacy)')
+ pano_engine_str = str(pano_engine)
+
+ # Engine C: true spherical mapping via grid_sample
+ if pano_engine_str.startswith('C'):
+ yaw = float(params.get('panorama_yaw', 0.0) or 0.0)
+ pitch = float(params.get('panorama_pitch', 0.0) or 0.0)
+ roll = float(params.get('panorama_roll', 0.0) or 0.0)
+ coord_mode = params.get('panorama_coord_mode', 'Cartesian (lon/lat)')
+ polar_scale = float(params.get('panorama_polar_scale', 1.0) or 1.0)
+ polar_power = float(params.get('panorama_polar_power', 1.0) or 1.0)
+ twist_deg = float(params.get('panorama_twist_deg', 0.0) or 0.0)
+ twist_power = float(params.get('panorama_twist_power', 1.0) or 1.0)
+ swirl_deg = float(params.get('panorama_swirl_deg', 0.0) or 0.0)
+ swirl_power = float(params.get('panorama_swirl_power', 1.0) or 1.0)
+ pole_ease_power = float(params.get('panorama_pole_ease_power', 1.0) or 1.0)
+ grid_interp = params.get('panorama_grid_interp', 'bilinear')
+ grid_padding = params.get('panorama_grid_padding', 'border')
+ cache_angle_quant = float(params.get('panorama_cache_angle_quant', 0.5) or 0.5)
+ geoaa_samples = int(params.get('panorama_geoaa_samples', 1) or 1)
+ geoaa_radius = float(params.get('panorama_geoaa_radius_px', 0.0) or 0.0)
+ antipode_strength = float(params.get('panorama_antipode_strength', 0.0) or 0.0)
+ pole_blur_strength = float(params.get('panorama_pole_blur_strength', 0.0) or 0.0)
+ pole_blur_radius = int(params.get('panorama_pole_blur_radius', 0) or 0)
+ pole_blur_power = float(params.get('panorama_pole_blur_power', 1.0) or 1.0)
+
+ # 🔧 FIX #1: Используем tiled_output
+ tiled_output = conv2d_panorama_gridsample(
+ input_tensor, weight, bias,
+ stride, dilation, groups,
+ req_pad_h, req_pad_w,
+ yaw=yaw, pitch=pitch, roll=roll,
+ coord_mode=coord_mode,
+ polar_scale=polar_scale, polar_power=polar_power,
+ twist_deg=twist_deg, twist_power=twist_power,
+ swirl_deg=swirl_deg, swirl_power=swirl_power,
+ pole_ease_power=pole_ease_power,
+ grid_interp=grid_interp, grid_padding=grid_padding,
+ cache_angle_quant=cache_angle_quant,
+ geoaa_samples=geoaa_samples, geoaa_radius_px=geoaa_radius,
+ antipode_strength=antipode_strength,
+ pole_blur_strength=pole_blur_strength, pole_blur_radius=pole_blur_radius,
+ pole_blur_power=pole_blur_power
+ )
+
+ # ✅ УЖЕ ПРАВИЛЬНО: Multi-resolution для Panorama C (output-space)
+ if params.get('multires_enabled', False):
+ multires_params = validate_multires_params(params)
+
+ x_default = F.pad(input_tensor, (req_pad_w, req_pad_w, req_pad_h, req_pad_h),
+ mode='replicate')
+ out_default = F.conv2d(x_default, weight, bias, stride, 0, dilation, groups)
+
+ # 🔧 FIX #1: Используем tiled_output
+
+
+ tiled_output = apply_multires_blend(
+ tensor_simple=out_default,
+ tensor_advanced=tiled_output,
+ current_step=current_step,
+ start_step=params['start_step'],
+ end_step=params['end_step'],
+ strategy=multires_params['strategy'],
+ transition_start=multires_params['transition_start'],
+ transition_end=multires_params['transition_end'],
+ sharpness=multires_params['sharpness'],
+ enabled=True
+ )
+
+ # ✅ КРИТИЧЕСКОЕ ИСПРАВЛЕНИЕ: корректируем размеры
+ tiled_output = ensure_output_size_match(tiled_output, expected_out_h, expected_out_w)
+ return tiled_output
+
+ # Engine B: fast pole-correct padding
+ elif pano_engine_str.startswith('B'):
+ x = input_tensor
+ anti_s = float(params.get('panorama_antipode_strength', 0.0) or 0.0)
+ anti_s = float(max(0.0, min(anti_s, 1.0)))
+ if anti_s > 0.0:
+ anti = torch.roll(torch.flip(x, dims=[2]), shifts=x.shape[-1] // 2, dims=3)
+ x = x * (1.0 - anti_s) + anti * anti_s
+
+ x = compute_polar_padding(x, req_pad_h, req_pad_w)
+
+ pole_blur_strength = float(params.get('panorama_pole_blur_strength', 0.0) or 0.0)
+ pole_blur_radius = int(params.get('panorama_pole_blur_radius', 0) or 0)
+ pole_blur_power = float(params.get('panorama_pole_blur_power', 1.0) or 1.0)
+ x = _apply_pole_blur_smoothing(x, strength=pole_blur_strength,
+ radius=pole_blur_radius, power=pole_blur_power)
+
+ # ✅ ИСПРАВЛЕНО: Применяем multires правильно
+ # 🔧 FIX #1: Используем tiled_output
+
+ tiled_output = F.conv2d(x, weight, bias, stride, 0, dilation, groups)
+
+ if params.get('multires_enabled', False):
+ multires_params = validate_multires_params(params)
+
+ x_default = F.pad(input_tensor, (req_pad_w, req_pad_w, req_pad_h, req_pad_h),
+ mode='replicate')
+ out_default = F.conv2d(x_default, weight, bias, stride, 0, dilation, groups)
+
+ # 🔧 FIX #1: Используем tiled_output
+
+
+ tiled_output = apply_multires_blend(
+ tensor_simple=out_default,
+ tensor_advanced=tiled_output,
+ current_step=current_step,
+ start_step=params['start_step'],
+ end_step=params['end_step'],
+ strategy=multires_params['strategy'],
+ transition_start=multires_params['transition_start'],
+ transition_end=multires_params['transition_end'],
+ sharpness=multires_params['sharpness'],
+ enabled=True
+ )
+
+ # ✅ КРИТИЧЕСКОЕ ИСПРАВЛЕНИЕ: корректируем размеры
+ tiled_output = ensure_output_size_match(tiled_output, expected_out_h, expected_out_w)
+ return tiled_output
+
+ # Engine A (legacy): simple circular wrap
+ else:
+ x = input_tensor
+ x = F.pad(x, (req_pad_w, req_pad_w, 0, 0), mode='circular')
+ x = F.pad(x, (0, 0, req_pad_h, req_pad_h), mode='circular')
+
+ # 🔧 FIX #1: Используем tiled_output
+
+
+ tiled_output = F.conv2d(x, weight, bias, stride, 0, dilation, groups)
+
+ if params.get('multires_enabled', False):
+ multires_params = validate_multires_params(params)
+
+ x_default = F.pad(input_tensor, (req_pad_w, req_pad_w, req_pad_h, req_pad_h),
+ mode='replicate')
+ out_default = F.conv2d(x_default, weight, bias, stride, 0, dilation, groups)
+
+ # 🔧 FIX #1: Используем tiled_output
+
+
+ tiled_output = apply_multires_blend(
+ tensor_simple=out_default,
+ tensor_advanced=tiled_output,
+ current_step=current_step,
+ start_step=params['start_step'],
+ end_step=params['end_step'],
+ strategy=multires_params['strategy'],
+ transition_start=multires_params['transition_start'],
+ transition_end=multires_params['transition_end'],
+ sharpness=multires_params['sharpness'],
+ enabled=True
+ )
+
+ # ✅ КРИТИЧЕСКОЕ ИСПРАВЛЕНИЕ: корректируем размеры
+ tiled_output = ensure_output_size_match(tiled_output, expected_out_h, expected_out_w)
+ return tiled_output
+
+ # ═══════════════════════════════════════════════════════════════════
+ # ОБЫЧНЫЕ РЕЖИМЫ (Circular, Mirror, Hexagonal, Voronoi, и т.д.)
+ # ═══════════════════════════════════════════════════════════════════
+
+ x = input_tensor
+
+ # ────────── NEW ENHANCED MODES ──────────
+ if mode_x == MODE_VORONOI or mode_y == MODE_VORONOI:
+ voronoi_cells = int(params.get('voronoi_cells', 8) or 8)
+ voronoi_seed = int(params.get('voronoi_seed', 42) or 42)
+ x = compute_voronoi_padding(x, req_pad_h, req_pad_w, voronoi_cells, voronoi_seed)
+
+ elif mode_x == MODE_PERLIN or mode_y == MODE_PERLIN:
+ perlin_strength = float(params.get('perlin_strength', 0.3) or 0.3)
+ perlin_scale = float(params.get('perlin_scale', 10.0) or 10.0)
+ x = compute_perlin_padding(x, req_pad_h, req_pad_w, perlin_strength, perlin_scale)
+
+ elif mode_x == MODE_FRACTAL or mode_y == MODE_FRACTAL:
+ fractal_iterations = int(params.get('fractal_iterations', 2) or 2)
+ fractal_scale = float(params.get('fractal_scale', 0.6) or 0.6)
+ x = compute_fractal_padding(x, req_pad_h, req_pad_w, fractal_iterations, fractal_scale)
+
+ elif mode_x == MODE_ADAPTIVE or mode_y == MODE_ADAPTIVE:
+ adaptive_threshold = float(params.get('adaptive_threshold', 0.1) or 0.1)
+ x = compute_adaptive_padding(x, req_pad_h, req_pad_w, adaptive_threshold)
+
+ elif mode_x == MODE_POLAR or mode_y == MODE_POLAR:
+ # Polar: X=circular (longitude wraps), Y=pole-correct (latitude flips)
+ # compute_polar_padding handles both axes together
+ x = compute_polar_padding(x, req_pad_h, req_pad_w)
+
+ elif mode_x == MODE_ANISOTROPIC or mode_y == MODE_ANISOTROPIC:
+ # Anisotropic: directional padding blending circular + reflect at angle
+ x = compute_anisotropic_padding(
+ x,
+ req_pad_h,
+ req_pad_w,
+ angle_deg=float(params.get('anisotropic_angle', 45) or 45),
+ angle_deg2=params.get('anisotropic_angle2', None),
+ angle_mix=float(params.get('anisotropic_angle_mix', 1.0) or 1.0),
+ )
+
+ # ────────── STANDARD MODES (раздельно по осям) ──────────
+ else:
+ # ✅ ИСПРАВЛЕНО: Blend mode применяется ВМЕСТО обычного padding
+ blend_enabled = params.get('blend_enabled', False)
+
+ if blend_enabled and (req_pad_h > 0 or req_pad_w > 0):
+ # Blend mode ЗАМЕНЯЕТ обычный padding
+ blend_params = validate_blend_params(params)
+
+ # Определяем какой advanced режим использовать.
+ # Polar и Anisotropic используют reflect как наиболее безопасный
+ # промежуточный fallback — он менее агрессивен, чем circular.
+ # Hexagonal по Y ведёт себя как circular, по X — смещённый wrap.
+ if mode_x == MODE_CIRCULAR or mode_y == MODE_CIRCULAR:
+ mode_advanced_str = 'circular'
+ elif mode_x == MODE_MIRROR or mode_y == MODE_MIRROR:
+ mode_advanced_str = 'reflect'
+ elif mode_x == MODE_HEXAGONAL or mode_y == MODE_HEXAGONAL:
+ mode_advanced_str = 'circular' # hex стагер близок к circular
+ elif mode_x == MODE_POLAR or mode_y == MODE_POLAR:
+ mode_advanced_str = 'reflect' # pole edges: reflect < circular artifacts
+ elif mode_x == MODE_ANISOTROPIC or mode_y == MODE_ANISOTROPIC:
+ mode_advanced_str = 'reflect' # directional: reflect более нейтрален
+ else:
+ mode_advanced_str = 'circular' # fallback: Voronoi/Perlin/Fractal/Adaptive
+
+ # Применяем улучшенный blend mode
+ x = compute_advanced_blend_padding(
+ input_tensor, # ← Исходный тензор БЕЗ padding
+ pad_h=req_pad_h,
+ pad_w=req_pad_w,
+ mode_simple='replicate',
+ mode_advanced=mode_advanced_str,
+ blend_strength=blend_params['strength'],
+ blend_width=blend_params['width'],
+ falloff_curve=blend_params['falloff'],
+ edge_sharpness=blend_params['sharpness']
+ )
+
+ else:
+ # Обычный padding без blend
+ # Ось Y
+ if mode_y == MODE_CIRCULAR:
+ x = F.pad(x, (0, 0, req_pad_h, req_pad_h), mode='circular')
+ elif mode_y == MODE_MIRROR:
+ x = _safe_pad4d(x, (0, 0, req_pad_h, req_pad_h), mode='reflect')
+ elif mode_y == MODE_HEXAGONAL:
+ x = F.pad(x, (0, 0, req_pad_h, req_pad_h), mode='circular')
+ else:
+ x = F.pad(x, (0, 0, req_pad_h, req_pad_h), mode='constant', value=0)
+
+ # Ось X
+ if mode_x == MODE_CIRCULAR:
+ x = F.pad(x, (req_pad_w, req_pad_w, 0, 0), mode='circular')
+ elif mode_x == MODE_MIRROR:
+ x = _safe_pad4d(x, (req_pad_w, req_pad_w, 0, 0), mode='reflect')
+ elif mode_x == MODE_HEXAGONAL:
+ x = compute_hex_padding_x(x, req_pad_w, req_pad_w)
+ else:
+ x = F.pad(x, (req_pad_w, req_pad_w, 0, 0), mode='constant', value=0)
+
+ # ═══════════════════════════════════════════════════════════════════
+ # CONVOLUTION + MULTI-RESOLUTION (унифицированно для всех режимов)
+ # ═══════════════════════════════════════════════════════════════════
+
+ # x теперь содержит padded тензор (с blend или без)
+
+ # 🔥 ЖЕЛЕЗНАЯ ЗАЩИТА ТИПОВ (Для Voronoi, Perlin, Fractal и остальных)
+ # Если веса модели в float16, а паддинг вернул float32 — конвертируем.
+ if x.dtype != weight.dtype:
+ x = x.to(dtype=weight.dtype)
+
+ out_advanced = F.conv2d(x, weight, bias, stride, 0, dilation, groups)
+
+ # ✅ ИСПРАВЛЕНО: Multi-resolution для обычных режимов
+ if params.get('multires_enabled', False):
+ multires_params = validate_multires_params(params)
+
+ # Создаем простую версию (output space)
+ x_default = F.pad(input_tensor, (req_pad_w, req_pad_w, req_pad_h, req_pad_h),
+ mode='replicate')
+ out_default = F.conv2d(x_default, weight, bias, stride, 0, dilation, groups)
+
+ # Смешиваем outputs
+ out_final = apply_multires_blend(
+ tensor_simple=out_default,
+ tensor_advanced=out_advanced, # ← ИСПРАВЛЕНО: правильная переменная!
+ current_step=current_step,
+ start_step=params['start_step'],
+ end_step=params['end_step'],
+ strategy=multires_params['strategy'],
+ transition_start=multires_params['transition_start'],
+ transition_end=multires_params['transition_end'],
+ sharpness=multires_params['sharpness'],
+ enabled=True
+ )
+
+ # ✅ КРИТИЧЕСКОЕ ИСПРАВЛЕНИЕ: корректируем размеры
+ out_final = ensure_output_size_match(out_final, expected_out_h, expected_out_w)
+ return out_final # ← ИСПРАВЛЕНО: возвращаем с multires!
+ else:
+ # ✅ КРИТИЧЕСКОЕ ИСПРАВЛЕНИЕ: корректируем размеры
+ out_advanced = ensure_output_size_match(out_advanced, expected_out_h, expected_out_w)
+ return out_advanced # ← Без multires
+
+ except Exception as e:
+ print(f"Advanced Tiling v3.1 Error: {e}")
+ import traceback
+ traceback.print_exc()
+ return F.conv2d(input_tensor, weight, bias, stride, padding, dilation, groups)
+
+# ========================================================================
+# РЕГИСТРАЦИЯ KOHAKU SAMPLER
+# ========================================================================
+
+
+# ========================================================================
+# STEREOSCOPIC 3D (postprocess helper)
+# ========================================================================
+
+def _pil_to_float_tensor(img: Image.Image) -> torch.Tensor:
+ """PIL -> torch float tensor (1,C,H,W) in [0,1] on CPU."""
+ if img.mode != "RGB":
+ img = img.convert("RGB")
+ arr = np.array(img).astype(np.float32) / 255.0 # (H,W,3)
+ t = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0) # (1,3,H,W)
+ return t
+
+
+def _float_tensor_to_pil(t: torch.Tensor) -> Image.Image:
+ """torch float tensor (1,C,H,W) in [0,1] -> PIL RGB."""
+ t = t.detach().clamp(0.0, 1.0)
+ arr = (t.squeeze(0).permute(1, 2, 0).cpu().numpy() * 255.0).round().astype(np.uint8)
+ return Image.fromarray(arr, mode="RGB")
+
+
+def _stereo_warp_tensor(t: torch.Tensor,
+ eye: str,
+ engine: str,
+ separation: float,
+ convergence: float,
+ depth_power: float = 1.0,
+ pole_power: float = 1.0) -> torch.Tensor:
+ """
+ Apply a lightweight stereo warp to an RGB tensor (1,3,H,W) in equirectangular space.
+ - Engine A: legacy roll+blend
+ - Engine B: spherical warp via grid_sample with longitude wrap and pole attenuation
+ """
+ eye = str(eye or "left").lower()
+ sign = 1.0 if eye == "left" else -1.0
+
+ separation = float(max(0.0, min(float(separation), 0.5)))
+ convergence = float(max(0.0, min(float(convergence), 1.0)))
+ depth_power = float(max(0.25, min(float(depth_power), 6.0)))
+ pole_power = float(max(0.25, min(float(pole_power), 6.0)))
+
+ B, C, H, W = t.shape
+ if W <= 1 or H <= 1 or separation <= 0.0:
+ return t
+
+ # base u,v in [0,1]
+ u = torch.linspace(0.0, 1.0, steps=W, dtype=torch.float32).view(1, 1, 1, W).expand(B, 1, H, W)
+ v = torch.linspace(0.0, 1.0, steps=H, dtype=torch.float32).view(1, 1, H, 1).expand(B, 1, H, W)
+
+ depth = torch.abs(u - convergence)
+ depth = torch.pow(torch.clamp(depth, 0.0, 1.0), depth_power)
+
+ if str(engine).startswith("A"):
+ # Legacy roll+blend
+ shift_px = int(round(W * separation))
+ if shift_px == 0:
+ return t
+ rolled = torch.roll(t, shifts=int(round(sign * shift_px)), dims=3)
+ alpha = depth.expand_as(t)
+ return t * (1.0 - alpha) + rolled * alpha
+
+ # Engine B: wrap-safe grid_sample warp
+ lat = (0.5 - v) * math.pi
+ attn = torch.pow(torch.cos(lat).clamp(0.0, 1.0), pole_power)
+
+ shift_u = sign * separation * depth * attn
+ u2 = torch.remainder(u + shift_u, 1.0)
+
+ # grid_sample normalized coords
+ x = u2 * 2.0 - 1.0
+ y = v * 2.0 - 1.0
+ grid = torch.cat([x, y], dim=1).permute(0, 2, 3, 1).contiguous() # (B,H,W,2)
+
+ return F.grid_sample(t, grid, mode="bilinear", padding_mode="border", align_corners=True)
+
+
+def _make_stereo_outputs(img: Image.Image, settings: dict):
+ """Returns (left,right) PIL images for the given input."""
+ t = _pil_to_float_tensor(img)
+ engine = settings.get("engine", "B (Spherical warp)")
+ separation = settings.get("separation", 0.065)
+ convergence = settings.get("convergence", 0.5)
+ depth_power = settings.get("depth_power", 1.0)
+ pole_power = settings.get("pole_power", 1.0)
+
+ left_t = _stereo_warp_tensor(t, "left", engine, separation, convergence, depth_power, pole_power)
+ right_t = _stereo_warp_tensor(t, "right", engine, separation, convergence, depth_power, pole_power)
+
+ return _float_tensor_to_pil(left_t), _float_tensor_to_pil(right_t)
+
+def register_kohaku_sampler():
+ """Регистрирует Kohaku_LoNyu_Yog сэмплер в WebUI"""
+ global _SAMPLER_REGISTERED
+
+ if _SAMPLER_REGISTERED:
+ return
+
+ if any(s.name == 'Kohaku_LoNyu_Yog' for s in sd_samplers.all_samplers):
+ _SAMPLER_REGISTERED = True
+ return
+
+ if not hasattr(k_diffusion.sampling, 'sample_kohaku_lonyu_yog'):
+ setattr(k_diffusion.sampling, 'sample_kohaku_lonyu_yog', sample_kohaku_lonyu_yog)
+
+ sampler_data = sd_samplers_common.SamplerData(
+ name='Kohaku_LoNyu_Yog',
+ constructor=lambda model: sd_samplers_kdiffusion.KDiffusionSampler('sample_kohaku_lonyu_yog', model),
+ aliases=['kohaku', 'lonyu'],
+ options={'second_order': True}
+ )
+
+ sd_samplers.all_samplers.append(sampler_data)
+ sd_samplers.all_samplers_map = {x.name: x for x in sd_samplers.all_samplers}
+
+ _SAMPLER_REGISTERED = True
+ print("✓ Kohaku_LoNyu_Yog sampler registered successfully!")
+
+# ========================================================================
+# CFG DRIFT CORRECTION
+# Источник: adept_sampler_v4_COMPLETE.py / ComfyUI-Latent-Modifiers
+# ========================================================================
+
+@torch.no_grad()
+def apply_combat_cfg_drift(latent: torch.Tensor,
+ method: str = 'mean',
+ intensity: float = 1.0) -> torch.Tensor:
+ """
+ Убирает CFG-induced mean drift из латента.
+
+ При высоком CFG (> 7) среднее латента постепенно смещается от нуля,
+ что вызывает цветовые сдвиги и пересвет/недосвет. Эта функция
+ вычитает это смещение пропорционально intensity.
+
+ Args:
+ latent: Латентный тензор [B, C, H, W]
+ method: 'mean' — быстро, глобальное среднее по всему батчу
+ 'median' — устойчив к выбросам, чуть медленнее
+ intensity: 0.0 = ничего не делать, 1.0 = убрать весь дрейф
+ """
+ if intensity <= 0.0:
+ return latent
+ try:
+ if method == 'median':
+ center = latent.view(latent.shape[0], -1).median(dim=-1, keepdim=True)[0]
+ center = center.view(-1, 1, 1, 1)
+ else:
+ center = latent.mean(dim=(1, 2, 3), keepdim=True)
+ return latent - center * float(intensity)
+ except Exception as e:
+ print(f"[CFG Drift] ошибка: {e}")
+ return latent
+
+
+# ========================================================================
+# КЛАСС СКРИПТА (Advanced Tiling + Latent Mirroring)
+# ========================================================================
+
+class AdvancedTilingScriptV3(scripts.Script):
+ def title(self):
+ return "Advanced Tiling v3.0 PRO (Kohaku + Stereo + Aniso + Latent Mirror)"
+
+ def show(self, is_img2img):
+ return scripts.AlwaysVisible
+
+ def ui(self, is_img2img):
+ with gr.Accordion("🚀 Advanced Tiling v3.0 PRO Edition", open=False):
+ with gr.Row():
+ enabled = gr.Checkbox(label="Enable Tiling", value=False)
+ use_kohaku = gr.Checkbox(
+ label="Use Kohaku_LoNyu_Yog Sampler",
+ value=False,
+ info="Geometric second-order method for better seamless quality"
+
+ )
+
+ with gr.Tabs():
+ with gr.Tab("🎨 Basic Modes"):
+ with gr.Row():
+ mode_x = gr.Dropdown(
+ label="Mode X",
+ choices=[MODE_OFF, MODE_CIRCULAR, MODE_MIRROR, MODE_HEXAGONAL,
+ MODE_VORONOI, MODE_PERLIN, MODE_FRACTAL, MODE_ADAPTIVE],
+ value=MODE_CIRCULAR,
+ info="NEW: Voronoi/Perlin/Fractal/Adaptive modes available!"
+
+ )
+ mode_y = gr.Dropdown(
+ label="Mode Y",
+ choices=[MODE_OFF, MODE_CIRCULAR, MODE_MIRROR, MODE_HEXAGONAL,
+ MODE_VORONOI, MODE_PERLIN, MODE_FRACTAL, MODE_ADAPTIVE],
+ value=MODE_CIRCULAR,
+ info="NEW: Voronoi/Perlin/Fractal/Adaptive modes available!"
+ )
+
+ # Shown when any special override is active (Panorama/Cubemap/Polar/Anisotropic)
+ special_mode_notice = gr.Markdown(
+ "ℹ️ Basic / Enhanced modes are active",
+ visible=True
+ )
+
+ with gr.Row():
+ multires = gr.Checkbox(
+ label="Multi-Resolution Mode",
+ value=False,
+ info="Gradually transition from simple to advanced tiling"
+
+ )
+ # 🚀 ADVANCED ZOOM & PROXIMITY SYSTEM
+ with gr.Row():
+ use_zoom = gr.Checkbox(label="🔍 Advanced Zoom System (NEW!)", value=False
+ )
+ use_blend = gr.Checkbox(label="Advanced Blend Mode", value=False
+ )
+
+ with gr.Accordion("🔍 Advanced Zoom Settings", open=False):
+ with gr.Row():
+ zoom_factor = gr.Slider(-9.0, 20.0, step=0.1, label="🎯 Zoom Factor", value=0.0
+ )
+ with gr.Row():
+ zoom_mode = gr.Dropdown(label="Zoom Mode",
+ choices=["outpaint_zoom", "blend_transition", "convergence_shift",
+ "grid_warp", "hybrid", "spiral_zoom"],
+ value="grid_warp",
+ info="geometry: grid_warp / spiral_zoom / convergence_shift | canvas: outpaint_zoom / blend_transition / hybrid"
+ )
+ zoom_engine = gr.Dropdown(label="Zoom Engine",
+ choices=["auto", "geometry", "canvas"],
+ value="auto",
+ info="auto = выбрать backend по Zoom Mode"
+ )
+ with gr.Row():
+ zoom_path = gr.Radio(
+ label="Zoom Path",
+ choices=["Latent", "Conv [Experimental]", "Both [Experimental]"],
+ value="Latent",
+ info=(
+ "Latent = варп params.x (стабильно, поддерживает все режимы). "
+ "Conv = scale+crop в каждом conv слое — поддерживает только zoom_factor + strength. "
+ "Both = оба пути одновременно."
+ )
+ )
+ with gr.Row():
+ conv_zoom_strength = gr.Slider(
+ 0.0, 1.0, step=0.05,
+ label="Conv Zoom Strength",
+ value=0.5,
+ visible=False,
+ info="Общая сила conv-path зума. 1.0 = полная сила по stage-весам."
+ )
+ with gr.Row():
+ blend_mode_type = gr.Dropdown(label="Blend Mode Type",
+ choices=["circular_reflect", "circular_constant", "reflect_constant",
+ "polar_circular", "mirror_circular", "aniso_circular",
+ "custom", "gradient_radial", "noise_blend"],
+ value="circular_reflect"
+ )
+ interp_mode = gr.Dropdown(choices=["bilinear", "bicubic", "nearest"],
+ value="bilinear",
+ label="Interpolation",
+ info="bicubic = лучшее качество (требует PyTorch ≥1.10)"
+ )
+
+ # ── Geometry Settings ──────────────────────────────
+ with gr.Group() as zoom_geometry_group:
+ gr.Markdown("### 🔷 Geometry Settings *(grid_warp · spiral_zoom · convergence_shift)*")
+ with gr.Row():
+ zoom_convergence = gr.Slider(0.0, 1.0, step=0.05, label="Convergence Point X", value=0.5)
+ zoom_depth_power = gr.Slider(0.25, 4.0, step=0.05, label="Depth Curve Power", value=1.0,
+ info="Кривая усиления эффекта convergence_shift")
+ with gr.Row():
+ auto_clamp_pan = gr.Checkbox(label="Auto Clamp Pan", value=True,
+ info="Не даёт уйти контенту за кадр при сильном pan")
+
+ # ── Canvas Settings ────────────────────────────────
+ with gr.Group() as zoom_canvas_group:
+ gr.Markdown("### 🎨 Canvas Settings *(outpaint_zoom · blend_transition · hybrid)*")
+ with gr.Row():
+ noise_strength = gr.Slider(minimum=0.0, maximum=2.0, step=0.05, value=1.0,
+ label="Noise Strength",
+ info="Сила coherent latent fill в пустых зонах")
+ adaptive_noise_scale = gr.Checkbox(label="Adaptive Noise", value=True,
+ info="Дальше от контента → сильнее fill")
+ with gr.Row():
+ edge_fade = gr.Checkbox(label="Edge Fade (fill zones)", value=True,
+ info="Затухание fill-зоны у краёв кадра. Работает только когда есть fill (zoom-out / outpaint).")
+ variance_correction = gr.Checkbox(label="Variance Correction", value=True,
+ info="Убирает серость на швах")
+ with gr.Row():
+ zoom_fade_to_black = gr.Checkbox(label="Fade to Black", value=False,
+ info="Радиальное затемнение краёв")
+ zoom_fade_strength = gr.Slider(minimum=0.0, maximum=0.5, step=0.01, value=0.15,
+ label="Fade Strength",
+ info="Размер зоны затемнения")
+
+ # ── Common / Shared ────────────────────────────────
+ with gr.Group():
+ gr.Markdown("### ⚙️ Common Settings")
+ with gr.Row():
+ debug_mode = gr.Checkbox(label="Debug Mode", value=False)
+
+ with gr.Accordion("🗄️ Compatibility / Legacy", open=False):
+ zoom_force_original_size = gr.Checkbox(
+ label="🛡️ Force Original Size (legacy / compat only)",
+ value=True,
+ info="[Legacy] Этот флаг относился к conv-path zoom, который отключён. "
+ "Latent-path zoom всегда сохраняет исходный размер тензора. "
+ "Оставлен только для совместимости с сохранёнными пресетами."
+ )
+
+ with gr.Accordion("🎯 Zoom Positioning", open=False):
+ gr.Markdown("""
+ **Точное позиционирование для Zoom:**
+ - Независимое от Latent Mirroring
+ - Контроль положения оригинала при zoom
+ """)
+ with gr.Row():
+ zoom_pan_x = gr.Slider(minimum=-1.0, maximum=1.0, step=0.01,
+ label='Zoom X Offset (Pan)', value=0.0,
+ info='Смещение по горизонтали: -1=влево, 0=центр, +1=вправо')
+ zoom_pan_y = gr.Slider(minimum=-1.0, maximum=1.0, step=0.01,
+ label='Zoom Y Offset (Pan)', value=0.0,
+ info='Смещение по вертикали: -1=вверх, 0=центр, +1=вниз')
+ gr.Markdown("**Быстрые пресеты:**")
+ with gr.Row():
+ btn_center = gr.Button("📍 Center", size="sm")
+ btn_top = gr.Button("⬆️ Top", size="sm")
+ btn_bottom = gr.Button("⬇️ Bottom", size="sm")
+ btn_left = gr.Button("⬅️ Left", size="sm")
+ btn_right = gr.Button("➡️ Right", size="sm")
+ btn_center.click(lambda: (0.0, 0.0), outputs=[zoom_pan_x, zoom_pan_y])
+ btn_top.click( lambda: (0.0, -0.5), outputs=[zoom_pan_x, zoom_pan_y])
+ btn_bottom.click(lambda: (0.0, 0.5), outputs=[zoom_pan_x, zoom_pan_y])
+ btn_left.click( lambda: (-0.5, 0.0), outputs=[zoom_pan_x, zoom_pan_y])
+ btn_right.click( lambda: (0.5, 0.0), outputs=[zoom_pan_x, zoom_pan_y])
+
+ with gr.Accordion("🌀 Spiral Zoom Settings", open=False) as zoom_spiral_group:
+ gr.Markdown("""
+ **Параметры спирального зума:**
+ - Работает только с Zoom Mode = spiral_zoom
+ """)
+ with gr.Row():
+ spiral_rotation = gr.Slider(0.0, 2.0, step=0.05,
+ label="Rotation Strength", value=0.5,
+ info="0 = нет вращения, 1 = средне, 2 = максимум")
+ spiral_direction = gr.Radio(
+ label="Rotation Direction",
+ choices=["Clockwise", "Counter-clockwise"],
+ value="Clockwise",
+ info="Clockwise = +1.0, Counter-clockwise = -1.0")
+
+ # ── Zoom Step Control ──────────────────────────────
+ with gr.Accordion("⏱ Zoom Step Control", open=False):
+ gr.Markdown("""
+**По умолчанию zoom применяется на шаге 0 (чистый шум).**
+Включите, чтобы приме��ять zoom позже или как анимированный диапазон.
+
+- **Step 0** = текущее поведение (лучше для canvas fill)
+- **Custom fraction** = один раз, на выбранном шаге (0.10–0.25 = после структуры)
+- **Animated range** = плавный «наезд камеры» по шагам *(только geometry backend)*
+ """)
+ with gr.Row():
+ zoom_step_control_enabled = gr.Checkbox(
+ label="Enable Zoom Step Control",
+ value=False,
+ info="Включить. По умолчанию: step 0."
+ )
+ zoom_lock_after_end = gr.Checkbox(
+ label="🔒 Lock after End",
+ value=False,
+ info=(
+ "После последнего zoom-шага блокирует любой повторный старт zoom "
+ "(например, при hires pass или сбросе состояния). "
+ "Sampler продолжает естественно от последнего warped-состояния — "
+ "latent не перезаписывается."
+ )
+ )
+ with gr.Row():
+ zoom_apply_mode = gr.Radio(
+ label="Apply Mode",
+ choices=["Step 0 (default)", "Custom fraction", "Animated range"],
+ value="Step 0 (default)",
+ visible=False,
+ info="Step 0 = one-shot. Custom = один шаг по фракции. Animated = диапазон с интерполяцией."
+ )
+ # ── Once: Custom fraction ──────────────────────
+ with gr.Row():
+ zoom_apply_frac = gr.Slider(
+ 0.0, 1.0, step=0.01,
+ label="Apply at fraction of total steps",
+ value=0.0,
+ visible=False,
+ info="0.0 = шаг 0, 0.15 = 15% шагов, 1.0 = последний шаг"
+ )
+ # ── Animated range controls ────────────────────
+ with gr.Row():
+ zoom_range_start_frac = gr.Slider(
+ 0.0, 1.0, step=0.01,
+ label="Range Start (fraction)",
+ value=0.0,
+ visible=False,
+ info="Начало диапазона (0.0 = шаг 0)"
+ )
+ zoom_range_end_frac = gr.Slider(
+ 0.0, 1.0, step=0.01,
+ label="Range End (fraction)",
+ value=0.35,
+ visible=False,
+ info="Конец диапазона (0.35 = 35% шагов)"
+ )
+ with gr.Row():
+ zoom_factor_start = gr.Slider(
+ -9.0, 20.0, step=0.1,
+ label="Zoom Factor Start",
+ value=0.0,
+ visible=False,
+ info="Zoom factor в начале диапазона"
+ )
+ zoom_factor_end = gr.Slider(
+ -9.0, 20.0, step=0.1,
+ label="Zoom Factor End",
+ value=5.0,
+ visible=False,
+ info="Zoom factor в конце диапазона"
+ )
+ with gr.Row():
+ zoom_easing = gr.Dropdown(
+ choices=["instant", "linear", "ease_in", "ease_out", "ease_in_out"],
+ value="ease_in_out",
+ label="Easing",
+ visible=False,
+ info="instant = скачок в начале, ease_in_out = медленный наезд"
+ )
+ zoom_every_n_steps = gr.Slider(
+ 1, 10, step=1,
+ label="Apply every N steps",
+ value=1,
+ visible=False,
+ info="1 = каждый шаг, 3 = каждый третий"
+ )
+ with gr.Row():
+ zoom_from_origin = gr.Checkbox(
+ label="From origin (recommended)",
+ value=True,
+ visible=False,
+ info="Варпить от сохранённого латента начала диапазона, а не от текущего. Устраняет накопление blur."
+ )
+
+ with gr.Accordion("🎭 Zoom Compose / ROI", open=False):
+ with gr.Row():
+ zoom_compose_mode = gr.Radio(
+ label="Zoom Compose Mode",
+ choices=["Global", "Pinned Subject", "Dual-Transform ROI"],
+ value="Global",
+ info=(
+ "Global = обычный zoom. "
+ "Pinned Subject = объект удерживается, фон зумится. "
+ "Dual-Transform ROI = объект и фон масштабируются по-разному."
+ )
+ )
+ with gr.Row():
+ roi_shape = gr.Dropdown(
+ label="ROI Shape",
+ choices=["ellipse", "box"],
+ value="ellipse",
+ visible=False,
+ )
+ roi_preserve_strength = gr.Slider(
+ 0.0, 1.0, step=0.05,
+ label="Preserve Strength",
+ value=1.0,
+ visible=False,
+ info="Сила удержания ROI-зоны в режиме Pinned Subject"
+ )
+ with gr.Row():
+ roi_center_x = gr.Slider(
+ 0.0, 1.0, step=0.01,
+ label="ROI Center X", value=0.5,
+ visible=False,
+ )
+ roi_center_y = gr.Slider(
+ 0.0, 1.0, step=0.01,
+ label="ROI Center Y", value=0.5,
+ visible=False,
+ )
+ with gr.Row():
+ roi_radius_x = gr.Slider(
+ 0.01, 1.0, step=0.01,
+ label="ROI Radius X", value=0.18,
+ visible=False,
+ )
+ roi_radius_y = gr.Slider(
+ 0.01, 1.0, step=0.01,
+ label="ROI Radius Y", value=0.18,
+ visible=False,
+ )
+ with gr.Row():
+ roi_feather = gr.Slider(
+ 0.0, 0.5, step=0.01,
+ label="ROI Feather", value=0.08,
+ visible=False,
+ info="Мягкость перехода на границе ROI"
+ )
+ with gr.Row():
+ roi_fg_zoom_factor = gr.Slider(
+ -9.0, 20.0, step=0.1,
+ label="ROI Foreground Zoom Factor",
+ value=0.0,
+ visible=False,
+ info="Zoom factor для объекта (Dual-Transform ROI)"
+ )
+ roi_bg_zoom_factor = gr.Slider(
+ -9.0, 20.0, step=0.1,
+ label="ROI Background Zoom Factor",
+ value=0.0,
+ visible=False,
+ info="Zoom factor для фона (Dual-Transform ROI). Полностью заменяет основной Zoom Factor для фоновой зоны."
+ )
+
+
+ with gr.Row():
+ blend_strength = gr.Slider(0.0, 1.0, step=0.05, label="Blend Strength (legacy)", value=0.5
+ )
+
+ # ═══ NEW: ADVANCED BLEND SETTINGS ═══
+ with gr.Accordion("🎨 Advanced Blend Settings", open=False):
+ gr.Markdown("""
+ **Blend Mode улучшен!** Теперь это настоящий слайдер приближения/отдаления:
+ - `0.0` = далеко (простой padding)
+ - `0.5` = средняя дистанция (смешивание)
+ - `1.0` = близко (полный advanced tiling)
+ """)
+
+ with gr.Row():
+ blend_falloff = gr.Dropdown(
+ label="Falloff Curve",
+ choices=["linear", "smoothstep", "cosine", "perceptual"],
+ value="smoothstep",
+ info="Shape of the transition gradient"
+
+ )
+ blend_sharpness = gr.Slider(
+ 0.1, 5.0, step=0.1,
+ label="Edge Sharpness",
+ value=1.0,
+ info="<1 = softer, >1 = sharper transitions"
+
+ )
+
+ blend_width = gr.Slider(
+ 0, 128, step=8,
+ label="Blend Width (pixels, 0=auto)",
+ value=0,
+ info="Width of transition zone"
+
+ )
+
+
+ # ═══ NEW: ADVANCED MULTI-RESOLUTION SETTINGS ═══
+ with gr.Accordion("🔬 Advanced Multi-Resolution Settings", open=False):
+ gr.Markdown("""
+**Multi-Resolution** смешивает обычный (replicate) и продвинутый (tiled) padding по шагам диффузии:
+- **linear** — равномерный переход
+- **cosine** — плавный S-образный ✅ рекомендуется
+- **exponential** — быстрый старт, медленный финиш
+- **sigmoid** — острая S-кривая
+- **early_boost** — максимум в начале, быстрое угасание
+- **late_smooth** — медленный нарастающий финиш
+ """)
+
+ multires_strategy = gr.Dropdown(
+ label="Interpolation Strategy",
+ choices=["linear", "cosine", "exponential", "sigmoid", "early_boost", "late_smooth"],
+ value="cosine",
+ info="How to blend simple → advanced over diffusion steps"
+ )
+
+ with gr.Row():
+ multires_start = gr.Slider(
+ 0.0, 1.0, step=0.05,
+ label="Transition Start",
+ value=0.0,
+ info="Fraction of steps where transition begins (0.0 = from start)"
+ )
+ multires_end = gr.Slider(
+ 0.0, 1.0, step=0.05,
+ label="Transition End",
+ value=0.3,
+ info="Fraction of steps where transition ends (0.3 = at 30%) — auto-swapped if < Start"
+ )
+
+ multires_sharpness = gr.Slider(
+ 0.1, 5.0, step=0.1,
+ label="Transition Sharpness",
+ value=1.0,
+ info="Speed of transition (< 1 = slower / wider, > 1 = faster / sharper)"
+ )
+
+ # NEW ENHANCED MODES Parameters
+ with gr.Accordion("✨ NEW Enhanced Modes Parameters", open=False):
+ gr.Markdown("**Parameters for Voronoi, Perlin, Fractal, and Adaptive modes**")
+
+ with gr.Row():
+ voronoi_cells = gr.Slider(
+ label="Voronoi: Cells",
+ minimum=4, maximum=32, value=8, step=1,
+ info="Number of organic cells for Voronoi mode"
+
+ )
+ voronoi_seed = gr.Slider(
+ label="Voronoi: Seed",
+ minimum=0, maximum=9999, value=42, step=1,
+ info="Random seed for pattern reproducibility"
+
+ )
+
+ with gr.Row():
+ perlin_strength = gr.Slider(
+ label="Perlin: Distortion Strength",
+ minimum=0.0, maximum=1.0, value=0.3, step=0.05,
+ info="How much Perlin noise distorts tiling"
+
+ )
+ perlin_scale = gr.Slider(
+ label="Perlin: Noise Scale",
+ minimum=1.0, maximum=50.0, value=10.0, step=1.0,
+ info="Scale of Perlin noise pattern"
+
+ )
+
+ with gr.Row():
+ fractal_iterations = gr.Slider(
+ label="Fractal: Iterations",
+ minimum=1, maximum=4, value=2, step=1,
+ info="Number of fractal recursion levels"
+
+ )
+ fractal_scale = gr.Slider(
+ label="Fractal: Scale Factor",
+ minimum=0.3, maximum=0.9, value=0.6, step=0.05,
+ info="Size reduction per iteration"
+
+ )
+
+ adaptive_threshold = gr.Slider(
+ label="Adaptive: Edge Threshold",
+ minimum=0.0, maximum=1.0, value=0.1, step=0.05,
+ info="Edge detection threshold for auto mode selection"
+
+ )
+
+ with gr.Tab("🌐 Advanced Modes"):
+ gr.Markdown("**Специальные режимы для сложных топологий**")
+
+ with gr.Row():
+ use_panorama = gr.Checkbox(label="Panorama 360°", value=False
+ )
+ use_polar = gr.Checkbox(
+ label="Polar (Sphere Correct)",
+ value=False,
+ info="Correct pole transitions for equirectangular"
+
+ )
+
+
+ with gr.Accordion("🧭 Panorama Live (panorama-tools integrated)", open=False):
+ gr.Markdown("**Live equirectangular panorama processing during generation**")
+
+ with gr.Row():
+ panorama_engine = gr.Dropdown(
+ label="Panorama Engine",
+ choices=["A (Legacy)", "B (Fast Pole-Correct)", "C (Live 3D GridSample)"],
+ value="C (Live 3D GridSample)",
+ info="A = legacy circular wrap. B = fast pole-correct padding (+ optional antipode + pole blur). C = true spherical mapping via grid_sample (best seams, slower)."
+
+ )
+ panorama_coord_mode = gr.Dropdown(
+ label="Engine C: Coord Mode",
+ choices=["Cartesian (lon/lat)", "Polar (radial warp around poles)"],
+ value="Cartesian (lon/lat)",
+ info="Advanced: Cartesian uses standard lon/lat. Polar re-parameterizes latitude near poles."
+
+ )
+
+ with gr.Row():
+ panorama_yaw = gr.Slider(-180, 180, step=1, label="Engine C: Yaw (°)", value=0
+ )
+ panorama_pitch = gr.Slider(-180, 180, step=1, label="Engine C: Pitch (°)", value=0
+ )
+ panorama_roll = gr.Slider(-180, 180, step=1, label="Engine C: Roll (°)", value=0
+ )
+
+ with gr.Row():
+ panorama_twist_deg = gr.Slider(-180, 180, step=1, label="Engine C: Twist (°)", value=0,
+ info="Latitude-dependent longitude twist (local roll feel)."
+ )
+ panorama_twist_power = gr.Slider(0.25, 4.0, step=0.01, label="Engine C: Twist Power", value=1.0
+ )
+
+ panorama_swirl_deg = gr.Slider(-180, 180, step=1, label="Engine C: Swirl (°)", value=0,
+ info="Extra rotation bias toward poles (0=off)."
+ )
+ panorama_swirl_power = gr.Slider(0.25, 4.0, step=0.01, label="Engine C: Swirl Power", value=1.0
+ )
+
+ with gr.Row():
+ panorama_polar_scale = gr.Slider(0.25, 2.0, step=0.01, label="Engine C: Polar Scale", value=1.0
+ )
+ panorama_polar_power = gr.Slider(0.25, 4.0, step=0.01, label="Engine C: Polar Power", value=1.0
+ )
+ panorama_pole_ease_power = gr.Slider(0.25, 4.0, step=0.01, label="Pole Easing Power", value=1.0,
+ info="Eases latitude magnitude near poles (1=off)."
+ )
+
+ with gr.Row():
+ panorama_antipode_strength = gr.Slider(0.0, 1.0, step=0.05, label="Antipode Mix (anti-seam)", value=0.0,
+ info="Kohaku-inspired mixing with the antipode point (0=off)."
+ )
+ panorama_pole_blur_strength = gr.Slider(0.0, 1.0, step=0.05, label="Pole Blur Strength", value=0.0
+ )
+ panorama_pole_blur_radius = gr.Slider(0, 16, step=1, label="Pole Blur Radius (px)", value=0
+ )
+
+ with gr.Row():
+ panorama_pole_blur_power = gr.Slider(0.25, 4.0, step=0.01, label="Pole Blur Mask Power", value=1.0
+ )
+ panorama_geoaa_samples = gr.Slider(1, 4, step=1, label="Engine C: Geo AA Samples", value=1
+ )
+ panorama_geoaa_radius = gr.Slider(0.0, 2.0, step=0.25, label="Engine C: Geo AA Radius (px)", value=0.0
+ )
+
+ with gr.Row():
+ panorama_grid_interp = gr.Dropdown(label="Engine C: grid_sample Interp",
+ choices=["bilinear", "nearest"],
+ value="bilinear"
+ )
+ panorama_grid_padding = gr.Dropdown(label="Engine C: grid_sample Padding",
+ choices=["border", "reflection", "zeros"],
+ value="border"
+ )
+ panorama_cache_angle_quant = gr.Slider(0.1, 5.0, step=0.1, label="Engine C: Cache Quant (°)", value=0.5
+ )
+
+ with gr.Row():
+ use_cubemap = gr.Checkbox(
+ label="Cubemap (3D)",
+ value=False,
+ info="3x2 cubemap net (S/E/N over B/T/W). Faces must be square: width/3 == height/2."
+
+ )
+ cubemap_engine = gr.Dropdown(
+ label="Cubemap Engine",
+ choices=["A (Fast)", "B (Advanced)", "C (3D GridSample)"],
+ value="A (Fast)",
+ info="A = fastest batched cubemap padding. B = seam-aware padding blend (reduces seams). C = true 3D grid_sample mapping (yaw/pitch/roll, slower but best seams)."
+
+ )
+ cubemap_resolution_mode = gr.Dropdown(
+ label="Cubemap Input Size",
+ choices=["Already 3x2 (Full image)", "Face size (auto scale to 3x2)"],
+ value="Already 3x2 (Full image)",
+ info="If you choose 'Face size', your base width/height will be interpreted as a single face."
+
+ )
+
+ with gr.Row():
+ cubemap_pad_mode = gr.Dropdown(
+ label="Cubemap Pad Mode",
+ choices=["replicate", "reflect", "circular"],
+ value="replicate",
+ info="Padding mode used when assembling neighbor strips."
+
+ )
+ cubemap_blend_width = gr.Slider(
+ 0, 16, step=1,
+ label="Cubemap Seam Width (px)",
+ value=2,
+ info="Only for Engine B: how many pixels inside padding are blended."
+
+ )
+ cubemap_blend_strength = gr.Slider(
+ 0.0, 1.0, step=0.05,
+ label="Cubemap Seam Strength",
+ value=0.75,
+ info="Only for Engine B: 0 = Engine A behavior, 1 = full seam blending."
+
+ )
+
+
+
+ with gr.Row():
+ cubemap_yaw = gr.Slider(
+ -180, 180, step=1,
+ label="Engine C: Yaw (°)",
+ value=0,
+ info="Only for Engine C: rotation around Y axis."
+
+ )
+ cubemap_pitch = gr.Slider(
+ -180, 180, step=1,
+ label="Engine C: Pitch (°)",
+ value=0,
+ info="Only for Engine C: rotation around X axis."
+
+ )
+ cubemap_roll = gr.Slider(
+ -180, 180, step=1,
+ label="Engine C: Roll (°)",
+ value=0,
+ info="Only for Engine C: rotation around Z axis."
+
+ )
+
+ # --- Engine C advanced coordinate controls ---
+ with gr.Row():
+ cubemap_coord_mode = gr.Dropdown(
+ choices=["Cartesian (Face UV)", "Polar (Radial Warp)"],
+ value="Cartesian (Face UV)",
+ label="Engine C: Coord Mode",
+ info="Advanced: how face UV is interpreted before cubemap projection."
+
+ )
+ cubemap_twist_deg = gr.Slider(
+ -180, 180, step=1,
+ label="Engine C: Face Twist (°)",
+ value=0,
+ info="Advanced: rotate face UV around face normal before projection."
+
+ )
+
+ with gr.Row():
+ cubemap_polar_scale = gr.Slider(
+ 0.25, 2.0, step=0.01,
+ label="Engine C: Polar Radius Scale",
+ value=1.0,
+ info="Only for Polar mode: r' = (r*scale)^power."
+
+ )
+ cubemap_polar_power = gr.Slider(
+ 0.25, 4.0, step=0.01,
+ label="Engine C: Polar Power",
+ value=1.0,
+ info="Only for Polar mode: r' = (r*scale)^power."
+
+ )
+
+ with gr.Row():
+ cubemap_swirl_deg = gr.Slider(
+ -180, 180, step=1,
+ label="Engine C: Swirl (°)",
+ value=0,
+ info="Extra angle: adds radius-dependent twist (0=off)."
+
+ )
+ cubemap_swirl_power = gr.Slider(
+ 0.25, 4.0, step=0.01,
+ label="Engine C: Swirl Power",
+ value=1.0,
+ info="Swirl curve: twist ∝ r^power."
+
+ )
+
+ with gr.Row():
+ cubemap_grid_interp = gr.Dropdown(
+ choices=["bilinear", "nearest"],
+ value="bilinear",
+ label="Engine C: grid_sample Interp",
+ info="Bilinear=best quality. Nearest=faster/sharper."
+
+ )
+ cubemap_grid_padding = gr.Dropdown(
+ choices=["border", "reflection", "zeros"],
+ value="border",
+ label="Engine C: grid_sample Padding",
+ info="border recommended for seams."
+
+ )
+ cubemap_cache_angle_quant = gr.Slider(
+ 0.1, 5.0, step=0.1,
+ label="Engine C: Cache Quant (°)",
+ value=0.5,
+ info="Cache step for yaw/pitch/roll/twist/swirl. Lower=more precise, slower."
+
+ )
+
+ with gr.Row():
+ cubemap_geoaa_samples = gr.Slider(
+ 1, 4, step=1,
+ label="Engine C: Geo AA Samples",
+ value=1,
+ info="Only for Engine C: multi-sampling (1=off). Higher = smoother but slower."
+
+ )
+ cubemap_geoaa_radius = gr.Slider(
+ 0.0, 2.0, step=0.25,
+ label="Engine C: Geo AA Radius (px)",
+ value=0.0,
+ info="Only for Engine C: jitter radius in atlas pixels."
+
+ )
+ cubemap_antipode_strength = gr.Slider(
+ 0.0, 1.0, step=0.05,
+ label="Engine C: Antipode Mix",
+ value=0.0,
+ info="Only for Engine C: Kohaku-inspired antipode blending on the sphere."
+
+ )
+
+ with gr.Row():
+ use_anisotropic = gr.Checkbox(
+ label="Anisotropic (Directional)",
+ value=False,
+ info="Different behavior along diagonals"
+
+ )
+ aniso_angle = gr.Slider(
+ 0, 360, step=15,
+ label="Anisotropic Angle",
+ value=45,
+ info="Direction of fibers/texture (degrees)"
+
+ )
+
+ aniso_angle2 = gr.Slider(
+ 0, 360, step=15,
+ label="Second Angle (optional)",
+ value=0,
+ info="Advanced: enable by setting Angle Mix < 1.0"
+
+ )
+ aniso_angle_mix = gr.Slider(
+ 0.0, 1.0, step=0.05,
+ label="Angle Mix (Angle1 → Angle2)",
+ value=1.0,
+ info="1.0 = only Angle1, 0.0 = only Angle2."
+
+ )
+
+ # ── LATENT NOISE INIT ─────────────────────────────────
+ with gr.Accordion("🎲 Latent Noise Init (Panorama)", open=False):
+ gr.Markdown("""
+Заменяет стандартный `randn` шум на откалиброванный при старте генерации.
+Рекомендуется при **Panorama 360°** — убирает цветовые пятна на стыках.
+`null_mix=0.25` = 25% нейтрального латента → нет случайного цветового дрейфа.
+ """)
+ latent_noise_init = gr.Checkbox(
+ label="Enable Calibrated Noise Init",
+ value=False,
+ info="Только при первом шаге (step=0)"
+ )
+ null_mix = gr.Slider(
+ minimum=0.0, maximum=0.5, step=0.05,
+ label="Null Mix",
+ value=0.25,
+ info="Доля нейтрального латента (рек. 0.25 для панорам)"
+ )
+
+
+ with gr.Tab("🎭 Stereoscopic 3D"):
+ gr.Markdown("**Генерация стереопар для 3D контента**")
+
+ with gr.Row():
+ stereo_enabled = gr.Checkbox(label="Enable Stereoscopic Mode", value=False)
+ stereo_eye = gr.Radio(
+ label="Eye",
+ choices=["left", "right", "both"],
+ value="left",
+ info="Which eye view to generate"
+
+ )
+
+
+ with gr.Row():
+ stereo_engine = gr.Dropdown(
+ label="Stereo Engine",
+ choices=["A (Legacy shift)", "B (Spherical warp)"],
+ value="B (Spherical warp)",
+ info="B = smoother spherical warp (recommended). A = old-style shift/blend."
+
+ )
+ stereo_output = gr.Dropdown(
+ label="Output",
+ choices=["Side-by-Side", "Left only", "Right only", "Both separate"],
+ value="Side-by-Side",
+ info="Default: create a single side-by-side image. You can also output only one eye or two separate images."
+
+ )
+ stereo_in_model = gr.Checkbox(
+ label="Apply stereo during denoise (experimental)",
+ value=False,
+ info="If enabled, stereo shift affects UNet/conv padding during generation. If disabled, stereo is applied as a postprocess (recommended)."
+
+ )
+
+ with gr.Row():
+ stereo_depth_power = gr.Slider(
+ 0.25, 4.0, step=0.05,
+ label="Depth Curve Power",
+ value=1.0,
+ info="Higher values push parallax more toward edges."
+
+ )
+ stereo_pole_power = gr.Slider(
+ 0.25, 4.0, step=0.05,
+ label="Pole Attenuation Power",
+ value=1.0,
+ info="Scales stereo shift by cos(latitude)^power to reduce pole stretching."
+
+ )
+
+ with gr.Row():
+ stereo_separation = gr.Slider(
+ 0.0, 0.15, step=0.005,
+ label="IPD (Inter-Pupillary Distance)",
+ value=0.065,
+ info="Eye separation as fraction of width"
+
+ )
+ stereo_convergence = gr.Slider(
+ 0.0, 1.0, step=0.05,
+ label="Convergence Point",
+ value=0.5,
+ info="Depth at which eyes converge"
+
+ )
+
+ gr.Markdown("""
+ **💡 Совет для стерео:**
+ - Генерируйте сначала левый глаз
+ - Затем правый с теми же параметрами
+ - Используйте Side-by-Side или Anaglyph компоновку
+ """)
+
+ with gr.Tab("🪞 Latent Mirroring"):
+ # Главный переключатель латентного зеркалирования
+ enable_mirroring = gr.Checkbox(
+ label="Enable Latent Mirroring",
+ value=False
+ )
+
+ with gr.Group():
+ mirror_mode = gr.Radio(
+ label='Latent Mirror mode',
+ choices=['None', 'Alternate Steps', 'Blend Average'],
+ value='None',
+ type="index"
+ )
+ mirror_style = gr.Radio(
+ label='Latent Mirror style',
+ choices=[
+ 'Horizontal Mirroring',
+ 'Vertical Mirroring',
+ 'Horizontal+Vertical Mirroring',
+ '90 Degree Rotation',
+ '180 Degree Rotation',
+ 'Roll Channels',
+ 'None'
+ ],
+ value='Horizontal Mirroring',
+ type="index"
+ )
+
+ # ── Step Control ──────────────────────────────────────
+ with gr.Accordion("⏱️ Step Control", open=False):
+ mirror_step_control_enabled = gr.Checkbox(
+ label="Enable Step Control", value=False,
+ info="Применять зеркало/паннинг только в указанном диапазоне шагов")
+ mirror_step_mode = gr.Radio(
+ label="Step mode",
+ choices=["Max fraction (original)", "Custom range"],
+ value="Max fraction (original)",
+ type="index"
+ )
+
+ mirroring_max_step_fraction = gr.Slider(
+ minimum=0.0, maximum=1.0, step=0.01,
+ label='Maximum steps fraction to mirror at',
+ value=0.25,
+ visible=True,
+ info="Используется в режиме Max fraction"
+ )
+ with gr.Row():
+ mirror_start_frac = gr.Slider(
+ minimum=0.0, maximum=1.0, step=0.01,
+ label="Mirror Start (fraction of total steps)",
+ value=0.0,
+ visible=False
+ )
+ mirror_end_frac = gr.Slider(
+ minimum=0.0, maximum=1.0, step=0.01,
+ label="Mirror End (fraction of total steps)",
+ value=0.25,
+ visible=False
+ )
+
+ gr.HTML(""
+ "Зеркало и паннинг применяются только в указанном диапазоне шагов
")
+
+ with gr.Row():
+ sc_pan_one_shot = gr.Checkbox(
+ label="🎯 Pan One-Shot at range start",
+ value=False,
+ info="X/Y Pan применится ровно ОДИН РАЗ на первом шаге диапазона")
+ gr.HTML(""
+ "↑ Выстреливает один раз на шаге Start
")
+
+ with gr.Row():
+ sc_pan_lock_after_end = gr.Checkbox(
+ label="🔒 Lock after End",
+ value=False,
+ info="Паннинг работает в диапазоне [Start → End], "
+ "после End — навсегда отключается до конца генерации.")
+ gr.HTML(""
+ "Пример: Start=0.0, End=0.30 → паннинг активен 0–30%, "
+ "после 30% — полное отключение
")
+
+ def _toggle_mirror_step_vis(mode_idx):
+ is_custom = (mode_idx == 1)
+ return (
+ gr.update(visible=not is_custom), # max_fraction
+ gr.update(visible=is_custom), # start_frac
+ gr.update(visible=is_custom), # end_frac
+ )
+ mirror_step_mode.change(
+ fn=_toggle_mirror_step_vis,
+ inputs=[mirror_step_mode],
+ outputs=[mirroring_max_step_fraction,
+ mirror_start_frac, mirror_end_frac]
+ )
+
+ # ── X/Y Panning ──────────────────────────────────────
+ with gr.Row():
+ x_pan = gr.Slider(
+ minimum=-1.0, maximum=1.0, step=0.01,
+ label='X panning', value=0.0
+ )
+ y_pan = gr.Slider(
+ minimum=-1.0, maximum=1.0, step=0.01,
+ label='Y panning', value=0.0
+ )
+
+ if not is_img2img:
+ disable_hr = gr.Checkbox(label='Disable during hires pass', value=False)
+ else:
+ disable_hr = gr.State(False)
+
+ # ── CFG DRIFT CORRECTION ──────────────────────────────────────
+ with gr.Accordion("⚡ CFG Drift Correction", open=False):
+ gr.Markdown("""
+При высоком CFG (> 7) латент накапливает средний дрейф → цветовые сдвиги, пересвет.
+Эта функция вычитает дрейф на каждом шаге. Применяется **последней** операцией в callback.
+ """)
+ cfg_drift_enable = gr.Checkbox(
+ label="Enable CFG Drift Correction",
+ value=False,
+ info="Рекомендуется при CFG > 7"
+ )
+ with gr.Row():
+ cfg_drift_method = gr.Radio(
+ label="Method",
+ choices=["mean", "median"],
+ value="mean",
+ type="value",
+ info="mean — быстро; median — устойчив к выбросам"
+ )
+ cfg_drift_intensity = gr.Slider(
+ minimum=0.0, maximum=1.0, step=0.05,
+ label="Intensity",
+ value=1.0,
+ info="Доля убираемого дрейфа (1.0 = весь)"
+ )
+
+ # ── DIFFUSION CG ──────────────────────────────────────────────
+ with gr.Accordion("🎨 Diffusion CG (Color Grading)", open=False):
+ gr.Markdown("""
+Балансировка цвета и нормализация контраста с sin-расписанием.
+Эффект максимален в начале генерации и плавно затухает к концу.
+ """)
+ dcg_enable = gr.Checkbox(
+ label="Enable Diffusion CG",
+ value=False,
+ info="Источник: DiffusionCG v2.0.0 (sdsw)"
+ )
+ with gr.Row():
+ dcg_recenter = gr.Slider(
+ minimum=0.0, maximum=1.0, step=0.05,
+ label="Recenter Strength",
+ value=0.0,
+ info="Убирает цветовой дрейф (bias к красному и т.д.)"
+ )
+ dcg_normalization = gr.Slider(
+ minimum=0.0, maximum=1.0, step=0.05,
+ label="Normalization Strength",
+ value=0.0,
+ info="Растягивает диапазон → больше контраста"
+ )
+
+ # ── LATENT CENTER + MAXIMIZE (F2+F3) ─────────────────────────
+ with gr.Accordion("⚖️ Latent Center / Maximize", open=False):
+ gr.Markdown("""
+Балансировка и нормализация **каждый шаг** (без расписания, в отличие от DiffusionCG).
+**Center** — убирает bias смещения по цветовым каналам.
+**Maximize** — растягивает диапазон к ±boundary (больше деталей/контраста).
+ """)
+ lcm_enable = gr.Checkbox(
+ label="Enable Center / Maximize",
+ value=False,
+ info="Источник: sdxl_latent_tweak.py / SLAPaper"
+ )
+ with gr.Row():
+ lcm_per_channel_shift = gr.Slider(
+ minimum=0.0, maximum=1.0, step=0.05,
+ label="Per-Channel Shift",
+ value=1.0,
+ info="Сила вычитания среднего по каналу (0=выкл)"
+ )
+ lcm_full_tensor_shift = gr.Slider(
+ minimum=0.0, maximum=1.0, step=0.05,
+ label="Full Tensor Shift",
+ value=1.0,
+ info="Сила вычитания глобального среднего (0=выкл)"
+ )
+ with gr.Row():
+ lcm_maximize = gr.Checkbox(
+ label="Enable Maximize",
+ value=False,
+ info="Растяжка диапазона maximize_tensor_v2"
+ )
+ lcm_boundary = gr.Slider(
+ minimum=1.0, maximum=8.0, step=0.5,
+ label="Maximize Boundary",
+ value=4.0,
+ info="Целевой диапазон ±boundary (рек. 4.0)"
+ )
+
+ # ── BAND-PASS GRAIN (F5/F11/F12) ──────────────────────────────
+ with gr.Accordion("🌾 Latent Grain (Band-Pass)", open=False):
+ gr.Markdown("""
+Добавляет band-pass зерно в латентное пространство каждый шаг.
+**Band-pass** = разница двух avg_pool2d → чистая текстурная частота (без LF blob/HF shimmer).
+RMS-нормализация: `noise_scale` остаётся предсказуемым независимо от `radius`.
+ """)
+ grain_enable = gr.Checkbox(
+ label="Enable Latent Grain",
+ value=False,
+ info="Источник: ComfyUI-LatentDetailer"
+ )
+ with gr.Row():
+ grain_noise_scale = gr.Slider(
+ minimum=0.0, maximum=0.25, step=0.005,
+ label="Noise Scale",
+ value=0.02,
+ info="Амплитуда зерна (рек. 0.02–0.08)"
+ )
+ grain_noise_radius = gr.Slider(
+ minimum=1, maximum=16, step=1,
+ label="Noise Radius",
+ value=3,
+ info="Размер зерна (1=мелкое, 8=крупное)"
+ )
+ with gr.Row():
+ grain_noise_tail = gr.Slider(
+ minimum=-1.0, maximum=1.0, step=0.1,
+ label="Noise Tail",
+ value=0.0,
+ info="Форма распределения (0=Гаусс, +1=тяжёлые хвосты)"
+ )
+ grain_luma = gr.Slider(
+ minimum=0.0, maximum=1.0, step=0.05,
+ label="Luma Bias",
+ value=0.0,
+ info="Bias зерна в тёмные области (0=равномерно)"
+ )
+ grain_seed = gr.Slider(
+ minimum=-1, maximum=2147483647, step=1,
+ label="Grain Seed",
+ value=-1,
+ info="-1 = случайный каждый шаг"
+ )
+
+ with gr.Row():
+ start_step = gr.Slider(0, 150, step=1, label="Start Step", value=0
+ )
+ end_step = gr.Slider(0, 150, step=1, label="End Step", value=150
+ )
+
+ # Режим интерпретации Start/End Step: абсолютные шаги или доли от p.steps
+ with gr.Row():
+ step_mode = gr.Radio(
+ label="Tiling Step Mode",
+ choices=["Absolute Steps", "Fraction of total steps"],
+ value="Absolute Steps",
+ type="index"
+
+ )
+ step_start_frac = gr.Slider(
+ 0.0, 1.0, step=0.01,
+ label="Start (fraction of total steps)",
+ value=0.0,
+ visible=False
+ )
+ step_end_frac = gr.Slider(
+ 0.0, 1.0, step=0.01,
+ label="End (fraction of total steps)",
+ value=1.0,
+ visible=False
+ )
+
+ with gr.Row():
+ tiling_lock_after_end = gr.Checkbox(
+ label="🔒 Lock after End",
+ value=False,
+ info=(
+ "После последнего активного шага тайлинг остаётся ВКЛЮЧЁННЫМ "
+ "(circular/panorama padding продолжает работать до конца генерации). "
+ "Без этого — тайлинг отключается при step > End Step."
+ )
+ )
+ tiling_pan_one_shot = gr.Checkbox(
+ label="🎯 Pan One-Shot at range start",
+ value=False,
+ info=(
+ "Применить torch.roll сдвиг (pan_x/pan_y) ровно один раз — "
+ "на первом шаге активного диапазона. "
+ "Дальше тайлинг продолжается без дополнительного сдвига."
+ )
+ )
+
+ with gr.Row():
+ patch_vae = gr.Radio(
+ label="VAE Patching",
+ choices=["Off", "Safe", "Strict"],
+ value="Off",
+ type="value",
+ info=(
+ "Off — VAE не патчится (по умолчанию, безопасно). "
+ "Safe — патчит VAE encoder + безопасные части; пропускает decoder-up/mid/attn/skip; "
+ "auto-fallback при ошибке размеров. "
+ "Strict — только encoder, декодер не трогается совсем."
+ )
+ )
+
+ with gr.Row():
+ tiling_disable_hr = gr.Checkbox(
+ label="Disable Advanced Tiling during hires pass",
+ value=False,
+ info=(
+ "When hires fix is enabled, apply Advanced Tiling only on "
+ "the first (base) sampling pass"
+ )
+
+ )
+
+ # Preview Tool
+ with gr.Accordion("🔍 Preview & Info", open=False):
+ with gr.Tabs():
+ with gr.Tab("Visual Preview"):
+ gr.Markdown(
+ "**Preview** supports Basic Modes (Circular/Mirror/Hexagonal), "
+ "Anisotropic, and Stereo. "
+ "Panorama / Cubemap / Polar / Enhanced procedural modes "
+ "(Voronoi, Perlin, Fractal, Adaptive) are shown as a "
+ "placeholder — runtime behaviour will differ."
+ )
+ preview_btn = gr.Button("Generate Preview", variant="primary")
+ preview_img = gr.Image(label="Preview Grid (2x2)")
+
+ preview_btn.click(
+ fn=self.generate_preview,
+ inputs=[mode_x, mode_y,
+ use_panorama, use_polar, use_cubemap,
+ use_anisotropic, aniso_angle,
+ stereo_enabled, stereo_eye],
+ outputs=preview_img
+ )
+
+ with gr.Tab("Kohaku Info"):
+ gr.Markdown("""
+ ## 🔬 Kohaku_LoNyu_Yog Принцип работы
+ (описание опущено ради компактности)
+ """)
+
+ # для Latent Mirroring
+ self.run_callback = False
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 1. ГЛАВНЫЙ ПЕРЕКЛЮЧАТЕЛЬ: enabled
+ # ════════════════════════════════════════════════════════════════════════
+ # Список ВСЕХ элементов тайлинга (кроме enabled)
+ all_tiling_controls = [
+ mode_x, mode_y, multires, use_zoom, use_blend,
+ use_panorama, use_polar, use_cubemap, use_anisotropic,
+ stereo_enabled, enable_mirroring,
+ start_step, end_step, step_mode, step_start_frac, step_end_frac,
+ tiling_lock_after_end, tiling_pan_one_shot,
+ patch_vae, tiling_disable_hr, use_kohaku,
+ cfg_drift_enable, cfg_drift_method, cfg_drift_intensity,
+ latent_noise_init, null_mix,
+ dcg_enable, dcg_recenter, dcg_normalization,
+ lcm_enable, lcm_per_channel_shift, lcm_full_tensor_shift,
+ lcm_maximize, lcm_boundary,
+ grain_enable, grain_noise_scale, grain_noise_radius,
+ grain_noise_tail, grain_luma, grain_seed
+ ]
+
+ # mode_x / mode_y are excluded from sync_interactivity outputs because
+ # their interactive state is owned exclusively by sync_special_and_enhanced().
+ # Including them here caused a two-callback conflict on special toggle clicks.
+ base_tiling_controls = [
+ multires, use_zoom, use_blend,
+ use_panorama, use_polar, use_cubemap, use_anisotropic,
+ stereo_enabled, enable_mirroring,
+ start_step, end_step, step_mode, step_start_frac, step_end_frac,
+ tiling_lock_after_end, tiling_pan_one_shot,
+ patch_vae, tiling_disable_hr, use_kohaku,
+ cfg_drift_enable, cfg_drift_method, cfg_drift_intensity,
+ latent_noise_init, null_mix,
+ dcg_enable, dcg_recenter, dcg_normalization,
+ lcm_enable, lcm_per_channel_shift, lcm_full_tensor_shift,
+ lcm_maximize, lcm_boundary,
+ grain_enable, grain_noise_scale, grain_noise_radius,
+ grain_noise_tail, grain_luma, grain_seed
+ ]
+
+ # Master enabled.change is registered after mirror_controls is built (see below)
+
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 2. ZOOM SETTINGS: use_zoom → zoom controls
+ # ════════════════════════════════════════════════════════════════════════
+ zoom_controls = [
+ zoom_factor, zoom_mode, zoom_engine, noise_strength, interp_mode,
+ edge_fade, variance_correction, auto_clamp_pan,
+ adaptive_noise_scale, debug_mode,
+ zoom_convergence, zoom_depth_power,
+ zoom_force_original_size, zoom_fade_to_black, zoom_fade_strength,
+ zoom_pan_x, zoom_pan_y,
+ spiral_rotation, spiral_direction,
+ blend_mode_type,
+ zoom_path, conv_zoom_strength,
+ zoom_step_control_enabled, zoom_apply_mode, zoom_apply_frac,
+ zoom_range_start_frac, zoom_range_end_frac,
+ zoom_factor_start, zoom_factor_end, zoom_easing,
+ zoom_every_n_steps, zoom_from_origin,
+ zoom_lock_after_end,
+ # Compose / ROI
+ zoom_compose_mode,
+ roi_shape, roi_preserve_strength,
+ roi_center_x, roi_center_y,
+ roi_radius_x, roi_radius_y,
+ roi_feather,
+ roi_fg_zoom_factor, roi_bg_zoom_factor,
+ ]
+
+ # ── Visibility: показываем/скрываем Geometry/Canvas/Spiral группы ──
+ def _zoom_visibility(mode, engine):
+ zm = str(mode or "grid_warp").lower()
+ ze = str(engine or "auto").lower()
+ if ze == "geometry":
+ backend = "geometry"
+ elif ze == "canvas":
+ backend = "canvas"
+ else:
+ backend = "geometry" if zm in {"grid_warp", "spiral_zoom", "convergence_shift"} else "canvas"
+ show_geom = (backend == "geometry")
+ show_canvas = (backend == "canvas")
+ show_spiral = (zm == "spiral_zoom")
+ return (
+ gr.update(visible=show_geom),
+ gr.update(visible=show_canvas),
+ gr.update(visible=show_spiral),
+ )
+
+ for _trigger in (zoom_mode, zoom_engine):
+ _trigger.change(
+ fn=_zoom_visibility,
+ inputs=[zoom_mode, zoom_engine],
+ outputs=[zoom_geometry_group, zoom_canvas_group, zoom_spiral_group],
+ )
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 3. BLEND SETTINGS
+ # ════════════════════════════════════════════════════════════════════════
+ blend_controls = [
+ blend_strength, blend_falloff, blend_sharpness, blend_width
+ ]
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 4. MULTIRES SETTINGS
+ # ════════════════════════════════════════════════════════════════════════
+ multires_controls = [
+ multires_strategy, multires_start, multires_end, multires_sharpness
+ ]
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 5. PANORAMA SETTINGS
+ # ════════════════════════════════════════════════════════════════════════
+ panorama_controls = [
+ panorama_engine, panorama_coord_mode,
+ panorama_yaw, panorama_pitch, panorama_roll,
+ panorama_twist_deg, panorama_twist_power,
+ panorama_swirl_deg, panorama_swirl_power,
+ panorama_polar_scale, panorama_polar_power, panorama_pole_ease_power,
+ panorama_antipode_strength, panorama_pole_blur_strength,
+ panorama_pole_blur_radius, panorama_pole_blur_power,
+ panorama_geoaa_samples, panorama_geoaa_radius,
+ panorama_grid_interp, panorama_grid_padding, panorama_cache_angle_quant
+ ]
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 6. CUBEMAP SETTINGS
+ # ════════════════════════════════════════════════════════════════════════
+ cubemap_controls = [
+ cubemap_engine, cubemap_resolution_mode, cubemap_pad_mode,
+ cubemap_blend_width, cubemap_blend_strength,
+ cubemap_yaw, cubemap_pitch, cubemap_roll,
+ cubemap_coord_mode, cubemap_twist_deg,
+ cubemap_polar_scale, cubemap_polar_power,
+ cubemap_swirl_deg, cubemap_swirl_power,
+ cubemap_grid_interp, cubemap_grid_padding, cubemap_cache_angle_quant,
+ cubemap_geoaa_samples, cubemap_geoaa_radius, cubemap_antipode_strength
+ ]
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 7. ANISOTROPIC SETTINGS
+ # ════════════════════════════════════════════════════════════════════════
+ aniso_controls = [aniso_angle, aniso_angle2, aniso_angle_mix]
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 8. STEREO SETTINGS
+ # ════════════════════════════════════════════════════════════════════════
+ stereo_controls = [
+ stereo_eye, stereo_engine, stereo_output,
+ stereo_in_model, stereo_separation, stereo_convergence,
+ stereo_depth_power, stereo_pole_power
+ ]
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 9. LATENT MIRRORING
+ # ════════════════════════════════════════════════════════════════════════
+ mirror_controls = [
+ mirror_mode, mirror_style, x_pan, y_pan,
+ mirroring_max_step_fraction,
+ mirror_step_mode, mirror_start_frac, mirror_end_frac,
+ mirror_step_control_enabled, sc_pan_one_shot, sc_pan_lock_after_end,
+ ]
+
+ # Добавить disable_hr только если это не img2img
+ if not is_img2img:
+ mirror_controls.append(disable_hr)
+
+ # ════════════════════════════════════════════════════════════════════════
+ # INTERACTIVITY — decomposed by non-overlapping output groups
+ #
+ # Architecture (v54):
+ # enabled.change() → sync_master_enabled() — only time we update ALL groups
+ # use_zoom.change() → zoom_controls only
+ # use_blend.change() → blend_controls only
+ # multires.change() → multires_controls only
+ # use_panorama/polar → panorama_controls only (Polar shares panorama UI)
+ # use_cubemap.change()→ cubemap_controls only
+ # use_aniso.change() → aniso_controls only
+ # stereo.change() → stereo_controls only
+ # mirroring.change() → mirror_controls only
+ # mode_x/mode_y/specials → sync_special_and_enhanced() (mode_x/mode_y + notice + visibility)
+ #
+ # Each sub-toggle callback owns exactly one output group → no fan-out,
+ # no split-brain, no pending storm on simple checkbox clicks.
+ # ════════════════════════════════════════════════════════════════════════
+ master_controls = (
+ base_tiling_controls # mode_x/mode_y excluded — owned by sync_special_and_enhanced
+ + zoom_controls
+ + blend_controls
+ + multires_controls
+ + panorama_controls
+ + cubemap_controls
+ + aniso_controls
+ + stereo_controls
+ + mirror_controls
+ )
+
+ def _si(flag, controls):
+ """Helper: set_interactive shorthand."""
+ return [gr.update(interactive=bool(flag))] * len(controls)
+
+ # ── Master enabled: the only callback allowed to update everything ────
+ def sync_master_enabled(
+ en,
+ use_zoom_v, use_blend_v, multires_v,
+ use_panorama_v, use_polar_v, use_cubemap_v, use_aniso_v,
+ stereo_v, mirroring_v,
+ ):
+ updates = _si(en, base_tiling_controls)
+ updates += _si(en and bool(use_zoom_v), zoom_controls)
+ updates += _si(en and bool(use_blend_v), blend_controls)
+ updates += _si(en and bool(multires_v), multires_controls)
+ updates += _si(en and bool(use_panorama_v or use_polar_v), panorama_controls)
+ updates += _si(en and bool(use_cubemap_v), cubemap_controls)
+ updates += _si(en and bool(use_aniso_v), aniso_controls)
+ updates += _si(en and bool(stereo_v), stereo_controls)
+ updates += _si(en and bool(mirroring_v), mirror_controls)
+ return updates
+
+ enabled.change(
+ fn=sync_master_enabled,
+ inputs=[enabled,
+ use_zoom, use_blend, multires,
+ use_panorama, use_polar, use_cubemap, use_anisotropic,
+ stereo_enabled, enable_mirroring],
+ outputs=master_controls,
+ )
+
+ # ── Narrow per-group callbacks: each owns exactly one output group ────
+ use_zoom.change(
+ fn=lambda en, v: _si(en and bool(v), zoom_controls),
+ inputs=[enabled, use_zoom], outputs=zoom_controls,
+ )
+ use_blend.change(
+ fn=lambda en, v: _si(en and bool(v), blend_controls),
+ inputs=[enabled, use_blend], outputs=blend_controls,
+ )
+ multires.change(
+ fn=lambda en, v: _si(en and bool(v), multires_controls),
+ inputs=[enabled, multires], outputs=multires_controls,
+ )
+ for _trigger in (use_panorama, use_polar):
+ _trigger.change(
+ fn=lambda en, pan, pol: _si(en and bool(pan or pol), panorama_controls),
+ inputs=[enabled, use_panorama, use_polar], outputs=panorama_controls,
+ )
+ use_cubemap.change(
+ fn=lambda en, v: _si(en and bool(v), cubemap_controls),
+ inputs=[enabled, use_cubemap], outputs=cubemap_controls,
+ )
+ use_anisotropic.change(
+ fn=lambda en, v: _si(en and bool(v), aniso_controls),
+ inputs=[enabled, use_anisotropic], outputs=aniso_controls,
+ )
+ stereo_enabled.change(
+ fn=lambda en, v: _si(en and bool(v), stereo_controls),
+ inputs=[enabled, stereo_enabled], outputs=stereo_controls,
+ )
+ enable_mirroring.change(
+ fn=lambda en, v: _si(en and bool(v), mirror_controls),
+ inputs=[enabled, enable_mirroring], outputs=mirror_controls,
+ )
+
+
+ # ════════════════════════════════════════════════════════════════════════
+ # STEP RANGE NORMALIZATION: auto-swap if start > end
+ # ════════════════════════════════════════════════════════════════════════
+ def _normalize_abs_range(a, b):
+ a, b = int(a), int(b)
+ if a > b:
+ a, b = b, a
+ return gr.update(value=a), gr.update(value=b)
+
+ def _normalize_frac_range(a, b):
+ a = float(max(0.0, min(1.0, a)))
+ b = float(max(0.0, min(1.0, b)))
+ if a > b:
+ a, b = b, a
+ return gr.update(value=a), gr.update(value=b)
+
+ start_step.change(fn=_normalize_abs_range,
+ inputs=[start_step, end_step],
+ outputs=[start_step, end_step])
+ end_step.change(fn=_normalize_abs_range,
+ inputs=[start_step, end_step],
+ outputs=[start_step, end_step])
+ step_start_frac.change(fn=_normalize_frac_range,
+ inputs=[step_start_frac, step_end_frac],
+ outputs=[step_start_frac, step_end_frac])
+ step_end_frac.change(fn=_normalize_frac_range,
+ inputs=[step_start_frac, step_end_frac],
+ outputs=[step_start_frac, step_end_frac])
+ mirror_start_frac.change(fn=_normalize_frac_range,
+ inputs=[mirror_start_frac, mirror_end_frac],
+ outputs=[mirror_start_frac, mirror_end_frac])
+ mirror_end_frac.change(fn=_normalize_frac_range,
+ inputs=[mirror_start_frac, mirror_end_frac],
+ outputs=[mirror_start_frac, mirror_end_frac])
+ multires_start.change(fn=_normalize_frac_range,
+ inputs=[multires_start, multires_end],
+ outputs=[multires_start, multires_end])
+ multires_end.change(fn=_normalize_frac_range,
+ inputs=[multires_start, multires_end],
+ outputs=[multires_start, multires_end])
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 10. ENHANCED MODES PARAMETERS: Conditional visibility + special lockout
+ #
+ # Previously: two separate callback loops on _SPECIAL_INPUTS, each firing
+ # its own round-trip on the same click event.
+ # Now: one combined callback covers both special-mode lockout
+ # (mode_x/mode_y interactive + notice) AND enhanced-param visibility.
+ # ════════════════════════════════════════════════════════════════════════
+
+ _SPECIAL_INPUTS = [use_panorama, use_polar, use_cubemap, use_anisotropic]
+
+ def _special_mode_state(use_panorama_v, use_polar_v, use_cubemap_v, use_aniso_v):
+ """
+ Returns updates for mode_x, mode_y (interactive lock) and
+ special_mode_notice (text) whenever a special override toggle changes.
+ Also used internally by sync_special_and_enhanced.
+ """
+ special_on = bool(use_panorama_v or use_polar_v or use_cubemap_v or use_aniso_v)
+ label_parts = []
+ if use_panorama_v: label_parts.append("Panorama 360°")
+ if use_cubemap_v: label_parts.append("Cubemap")
+ if use_polar_v: label_parts.append("Polar")
+ if use_aniso_v: label_parts.append("Anisotropic")
+ if special_on:
+ msg = f"⚠️ **{', '.join(label_parts)}** overrides Mode X / Mode Y"
+ else:
+ msg = "ℹ️ Basic / Enhanced modes are active"
+ return (
+ gr.update(interactive=not special_on), # mode_x
+ gr.update(interactive=not special_on), # mode_y
+ gr.update(value=msg), # special_mode_notice
+ )
+
+ def update_enhanced_params_visibility(
+ mode_x_val, mode_y_val,
+ use_panorama_v, use_polar_v, use_cubemap_v, use_aniso_v
+ ):
+ """
+ Show Enhanced Mode parameter groups only when:
+ (a) No special mode is active (Panorama/Cubemap/Polar/Anisotropic would
+ override mode_x/mode_y in process(), making these params irrelevant),
+ AND
+ (b) The corresponding enhanced mode is actually selected.
+ """
+ special_on = bool(use_panorama_v or use_polar_v or use_cubemap_v or use_aniso_v)
+ if special_on:
+ show_voronoi = False
+ show_perlin = False
+ show_fractal = False
+ show_adaptive = False
+ else:
+ show_voronoi = (mode_x_val == MODE_VORONOI or mode_y_val == MODE_VORONOI)
+ show_perlin = (mode_x_val == MODE_PERLIN or mode_y_val == MODE_PERLIN)
+ show_fractal = (mode_x_val == MODE_FRACTAL or mode_y_val == MODE_FRACTAL)
+ show_adaptive = (mode_x_val == MODE_ADAPTIVE or mode_y_val == MODE_ADAPTIVE)
+
+ return [
+ gr.update(visible=show_voronoi), # voronoi_cells
+ gr.update(visible=show_voronoi), # voronoi_seed
+ gr.update(visible=show_perlin), # perlin_strength
+ gr.update(visible=show_perlin), # perlin_scale
+ gr.update(visible=show_fractal), # fractal_iterations
+ gr.update(visible=show_fractal), # fractal_scale
+ gr.update(visible=show_adaptive), # adaptive_threshold
+ ]
+
+ _ENHANCED_OUTPUTS = [
+ voronoi_cells, voronoi_seed,
+ perlin_strength, perlin_scale,
+ fractal_iterations, fractal_scale,
+ adaptive_threshold,
+ ]
+
+ def sync_special_and_enhanced(
+ en,
+ mode_x_val, mode_y_val,
+ use_panorama_v, use_polar_v, use_cubemap_v, use_aniso_v
+ ):
+ """
+ Combined single-round-trip callback for mode_x/mode_y ownership.
+ Handles: interactive lock (respects master enabled), notice text,
+ and enhanced-param visibility.
+ Returns: [mx, my, notice, *enhanced_visibility_updates]
+ """
+ special_on = bool(use_panorama_v or use_polar_v or use_cubemap_v or use_aniso_v)
+ # mode_x/mode_y are interactive only when master enabled AND no special override
+ mx_up = gr.update(interactive=bool(en) and not special_on)
+ my_up = gr.update(interactive=bool(en) and not special_on)
+ _, _, notice_up = _special_mode_state(
+ use_panorama_v, use_polar_v, use_cubemap_v, use_aniso_v
+ )
+ enh_updates = update_enhanced_params_visibility(
+ mode_x_val, mode_y_val,
+ use_panorama_v, use_polar_v, use_cubemap_v, use_aniso_v
+ )
+ return [mx_up, my_up, notice_up] + enh_updates
+
+ _COMBINED_INPUTS = [enabled, mode_x, mode_y] + _SPECIAL_INPUTS
+ _COMBINED_OUTPUTS = [mode_x, mode_y, special_mode_notice] + _ENHANCED_OUTPUTS
+
+ # enabled affects mode_x/mode_y interactive too
+ enabled.change(
+ fn=sync_special_and_enhanced,
+ inputs=_COMBINED_INPUTS,
+ outputs=_COMBINED_OUTPUTS,
+ )
+ # mode_x / mode_y changes affect enhanced visibility (lockout unchanged)
+ for _trigger in (mode_x, mode_y):
+ _trigger.change(
+ fn=sync_special_and_enhanced,
+ inputs=_COMBINED_INPUTS,
+ outputs=_COMBINED_OUTPUTS,
+ )
+ # special toggle changes: lockout + notice + visibility
+ for _ctrl in _SPECIAL_INPUTS:
+ _ctrl.change(
+ fn=sync_special_and_enhanced,
+ inputs=_COMBINED_INPUTS,
+ outputs=_COMBINED_OUTPUTS,
+ )
+
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 11. STEP MODE VISIBILITY: Показывать нужные слайдеры
+ # ════════════════════════════════════════════════════════════════════════
+ # Когда step_mode == "Absolute Steps" → показывать start_step/end_step
+ # Когда step_mode == "Fraction" → показывать step_start_frac/step_end_frac
+
+ def update_step_mode_visibility(mode_index):
+ """0 = Absolute Steps, 1 = Fraction"""
+ show_absolute = (mode_index == 0)
+ show_fraction = (mode_index == 1)
+
+ return [
+ gr.update(visible=show_absolute), # start_step
+ gr.update(visible=show_absolute), # end_step
+ gr.update(visible=show_fraction), # step_start_frac
+ gr.update(visible=show_fraction), # step_end_frac
+ ]
+
+ step_mode.change(
+ fn=update_step_mode_visibility,
+ inputs=[step_mode],
+ outputs=[start_step, end_step, step_start_frac, step_end_frac]
+ )
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 12. MIRROR STEP MODE VISIBILITY
+ # ════════════════════════════════════════════════════════════════════════
+ def update_mirror_step_mode_visibility(mode_index):
+ """0 = Max fraction, 1 = Custom range"""
+ show_max_frac = (mode_index == 0)
+ show_custom = (mode_index == 1)
+
+ return [
+ gr.update(visible=show_max_frac), # mirroring_max_step_fraction
+ gr.update(visible=show_custom), # mirror_start_frac
+ gr.update(visible=show_custom), # mirror_end_frac
+ ]
+
+ mirror_step_mode.change(
+ fn=update_mirror_step_mode_visibility,
+ inputs=[mirror_step_mode],
+ outputs=[mirroring_max_step_fraction, mirror_start_frac, mirror_end_frac]
+ )
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 13a. ZOOM PATH VISIBILITY (conv_zoom_strength shown for Conv / Both)
+ # ════════════════════════════════════════════════════════════════════════
+ # Latent-only controls (hidden when Conv path is selected):
+ _latent_only_controls = [
+ zoom_mode, zoom_engine, blend_mode_type,
+ zoom_convergence, zoom_depth_power,
+ zoom_pan_x, zoom_pan_y,
+ spiral_rotation, spiral_direction,
+ zoom_force_original_size, zoom_fade_to_black, zoom_fade_strength,
+ interp_mode, noise_strength, variance_correction,
+ edge_fade, auto_clamp_pan, adaptive_noise_scale,
+ # Step control parent + all children (Issue 1 fix)
+ zoom_step_control_enabled,
+ zoom_apply_mode, zoom_apply_frac,
+ zoom_range_start_frac, zoom_range_end_frac,
+ zoom_factor_start, zoom_factor_end,
+ zoom_easing, zoom_every_n_steps, zoom_from_origin,
+ zoom_lock_after_end,
+ # Compose UI only for Latent path
+ zoom_compose_mode,
+ roi_shape, roi_preserve_strength,
+ roi_center_x, roi_center_y,
+ roi_radius_x, roi_radius_y,
+ roi_feather,
+ roi_fg_zoom_factor, roi_bg_zoom_factor,
+ ]
+
+ def update_zoom_path_visibility(path_val):
+ raw = str(path_val or "Latent")
+ path = "Conv" if ("Conv" in raw and "Both" not in raw) else \
+ "Both" if "Both" in raw else "Latent"
+ show_conv = path in ("Conv", "Both")
+ show_latent = path in ("Latent", "Both")
+ conv_upd = gr.update(visible=show_conv)
+ latent_updts = [gr.update(visible=show_latent)] * len(_latent_only_controls)
+ return [conv_upd] + latent_updts
+
+ zoom_path.change(
+ fn=update_zoom_path_visibility,
+ inputs=[zoom_path],
+ outputs=[conv_zoom_strength] + _latent_only_controls,
+ )
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 13b. ZOOM COMPOSE VISIBILITY
+ # ════════════════════════════════════════════════════════════════════════
+ _compose_roi_widgets = [
+ roi_shape, roi_preserve_strength,
+ roi_center_x, roi_center_y,
+ roi_radius_x, roi_radius_y,
+ roi_feather,
+ roi_fg_zoom_factor, roi_bg_zoom_factor,
+ ]
+
+ def update_zoom_compose_visibility(mode_val):
+ mode = str(mode_val or "Global")
+ show_roi = mode in ("Pinned Subject", "Dual-Transform ROI")
+ show_preserve = mode == "Pinned Subject"
+ show_dual = mode == "Dual-Transform ROI"
+ return [
+ gr.update(visible=show_roi), # roi_shape
+ gr.update(visible=show_preserve), # roi_preserve_strength
+ gr.update(visible=show_roi), # roi_center_x
+ gr.update(visible=show_roi), # roi_center_y
+ gr.update(visible=show_roi), # roi_radius_x
+ gr.update(visible=show_roi), # roi_radius_y
+ gr.update(visible=show_roi), # roi_feather
+ gr.update(visible=show_dual), # roi_fg_zoom_factor
+ gr.update(visible=show_dual), # roi_bg_zoom_factor
+ ]
+
+ zoom_compose_mode.change(
+ fn=update_zoom_compose_visibility,
+ inputs=[zoom_compose_mode],
+ outputs=_compose_roi_widgets,
+ )
+
+ # ════════════════════════════════════════════════════════════════════════
+ # 13. ZOOM STEP CONTROL VISIBILITY
+ # ════════════════════════════════════════════════════════════════════════
+ def update_zoom_step_control_visibility(ctrl_enabled, apply_mode):
+ en = bool(ctrl_enabled)
+ mode = str(apply_mode or "Step 0 (default)")
+ is_custom = en and mode == "Custom fraction"
+ is_range = en and mode == "Animated range"
+ return [
+ gr.update(visible=en), # zoom_apply_mode
+ gr.update(visible=is_custom), # zoom_apply_frac
+ gr.update(visible=is_range), # zoom_range_start_frac
+ gr.update(visible=is_range), # zoom_range_end_frac
+ gr.update(visible=is_range), # zoom_factor_start
+ gr.update(visible=is_range), # zoom_factor_end
+ gr.update(visible=is_range), # zoom_easing
+ gr.update(visible=is_range), # zoom_every_n_steps
+ gr.update(visible=is_range), # zoom_from_origin
+ ]
+
+ _zsc_inputs = [zoom_step_control_enabled, zoom_apply_mode]
+ _zsc_outputs = [
+ zoom_apply_mode, zoom_apply_frac,
+ zoom_range_start_frac, zoom_range_end_frac,
+ zoom_factor_start, zoom_factor_end,
+ zoom_easing, zoom_every_n_steps, zoom_from_origin,
+ ]
+ zoom_step_control_enabled.change(
+ fn=update_zoom_step_control_visibility,
+ inputs=_zsc_inputs, outputs=_zsc_outputs,
+ )
+ zoom_apply_mode.change(
+ fn=update_zoom_step_control_visibility,
+ inputs=_zsc_inputs, outputs=_zsc_outputs,
+ )
+
+
+ #
+ # .change() callbacks handle all user-interaction state transitions.
+ # This one-shot helper only syncs the two things that can't be expressed
+ # as widget constructor defaults:
+ # 1) special_mode_notice text (depends on runtime toggle values)
+ # 2) enhanced-param visibility (depends on mode_x/mode_y + specials)
+ #
+ # Deliberately does NOT touch master_controls / mode_x.interactive here:
+ # - master interactivity: enabled.change() → sync_master_enabled() (full),
+ # sub-toggles each own exactly one group (narrow callbacks)
+ # - mode_x/mode_y lockout + notice + enhanced visibility:
+ # sync_special_and_enhanced() — also wired to enabled.change()
+ # Touching those here would create a race with the .change() handlers.
+ #
+ # Limitation: preset-restore sync requires demo.load() which is not
+ # available inside scripts.Script.ui() — accepted Gradio constraint.
+ # ════════════════════════════════════════════════════════════════════════
+
+ def _apply_initial_ui_state():
+ try:
+ pan = bool(getattr(use_panorama, "value", False))
+ pol = bool(getattr(use_polar, "value", False))
+ cub = bool(getattr(use_cubemap, "value", False))
+ ani = bool(getattr(use_anisotropic, "value", False))
+ mx = getattr(mode_x, "value", MODE_CIRCULAR)
+ my = getattr(mode_y, "value", MODE_CIRCULAR)
+
+ # 1) notice text only (mode_x/mode_y interactive is already
+ # correct from declared defaults; don't touch it here)
+ _, _, notice_up = _special_mode_state(pan, pol, cub, ani)
+ if notice_up.get("value") is not None:
+ special_mode_notice.value = notice_up["value"]
+
+ # 2) enhanced-param visibility
+ vis_updates = update_enhanced_params_visibility(mx, my, pan, pol, cub, ani)
+ _enh = [
+ voronoi_cells, voronoi_seed,
+ perlin_strength, perlin_scale,
+ fractal_iterations, fractal_scale,
+ adaptive_threshold,
+ ]
+ for widget, upd in zip(_enh, vis_updates):
+ vis = upd.get("visible")
+ if vis is not None:
+ widget.visible = vis
+
+ # 3) zoom step control visibility
+ zsc_en = bool(getattr(zoom_step_control_enabled, "value", False))
+ zsc_mode = str(getattr(zoom_apply_mode, "value",
+ "Step 0 (default)") or "Step 0 (default)")
+ zsc_updates = update_zoom_step_control_visibility(zsc_en, zsc_mode)
+ _zsc_widgets = [
+ zoom_apply_mode, zoom_apply_frac,
+ zoom_range_start_frac, zoom_range_end_frac,
+ zoom_factor_start, zoom_factor_end,
+ zoom_easing, zoom_every_n_steps, zoom_from_origin,
+ ]
+ for widget, upd in zip(_zsc_widgets, zsc_updates):
+ vis = upd.get("visible")
+ if vis is not None:
+ widget.visible = vis
+
+ # 4) zoom compose visibility — BEFORE zoom path
+ _zcm_val = str(getattr(zoom_compose_mode, "value", "Global") or "Global")
+ _zcm_updates = update_zoom_compose_visibility(_zcm_val)
+ for widget, upd in zip(_compose_roi_widgets, _zcm_updates):
+ vis = upd.get("visible")
+ if vis is not None:
+ widget.visible = vis
+
+ # 5) zoom path visibility — LAST, wins over compose
+ _zp_val = str(getattr(zoom_path, "value", "Latent") or "Latent")
+ _zp_updates = update_zoom_path_visibility(_zp_val)
+ _zp_widgets = [conv_zoom_strength] + _latent_only_controls
+ for widget, upd in zip(_zp_widgets, _zp_updates):
+ vis = upd.get("visible")
+ if vis is not None:
+ widget.visible = vis
+ except Exception:
+ pass # non-critical; widgets keep their declared defaults
+
+ _apply_initial_ui_state()
+
+
+ return [enabled, mode_x, mode_y,
+ start_step, end_step,
+ step_mode, step_start_frac, step_end_frac,
+ tiling_lock_after_end, tiling_pan_one_shot,
+ # --- ИСПРАВЛЕНИЕ: Добавлены новые параметры multires ---
+ multires, multires_strategy, multires_start, multires_end, multires_sharpness,
+
+ voronoi_cells, voronoi_seed,
+ perlin_strength, perlin_scale,
+ fractal_iterations, fractal_scale,
+ adaptive_threshold,
+ use_panorama, use_polar,
+ panorama_engine, panorama_coord_mode,
+ panorama_yaw, panorama_pitch, panorama_roll,
+ panorama_twist_deg, panorama_twist_power, panorama_swirl_deg, panorama_swirl_power,
+ panorama_polar_scale, panorama_polar_power, panorama_pole_ease_power,
+ panorama_antipode_strength, panorama_pole_blur_strength, panorama_pole_blur_radius, panorama_pole_blur_power,
+ panorama_geoaa_samples, panorama_geoaa_radius,
+ panorama_grid_interp, panorama_grid_padding, panorama_cache_angle_quant,
+ use_cubemap, cubemap_engine, cubemap_resolution_mode, cubemap_pad_mode, cubemap_blend_width, cubemap_blend_strength,
+ cubemap_yaw, cubemap_pitch, cubemap_roll, cubemap_coord_mode, cubemap_twist_deg, cubemap_polar_scale, cubemap_polar_power, cubemap_swirl_deg, cubemap_swirl_power, cubemap_grid_interp, cubemap_grid_padding, cubemap_cache_angle_quant, cubemap_geoaa_samples, cubemap_geoaa_radius, cubemap_antipode_strength,
+
+ # --- ИСПРАВЛЕНИЕ: Добавлены новые параметры blend ---
+ use_blend, blend_strength, blend_falloff, blend_sharpness, blend_width,
+
+ # --- ZOOM PARAMETERS ---
+ use_zoom, zoom_factor, zoom_mode, zoom_engine,
+ zoom_path, conv_zoom_strength,
+ zoom_step_control_enabled, zoom_apply_mode, zoom_apply_frac,
+ zoom_range_start_frac, zoom_range_end_frac,
+ zoom_factor_start, zoom_factor_end, zoom_easing,
+ zoom_every_n_steps, zoom_from_origin,
+ zoom_lock_after_end,
+ zoom_compose_mode,
+ roi_shape, roi_preserve_strength,
+ roi_center_x, roi_center_y,
+ roi_radius_x, roi_radius_y,
+ roi_feather,
+ roi_fg_zoom_factor, roi_bg_zoom_factor,
+ noise_strength, interp_mode, edge_fade,
+ variance_correction, auto_clamp_pan, adaptive_noise_scale, debug_mode,
+ blend_mode_type,
+ zoom_convergence, zoom_depth_power,
+ zoom_force_original_size, zoom_fade_to_black, zoom_fade_strength,
+ zoom_pan_x, zoom_pan_y,
+ spiral_rotation, spiral_direction,
+ use_anisotropic, aniso_angle, aniso_angle2, aniso_angle_mix,
+ stereo_enabled, stereo_eye, stereo_engine, stereo_output, stereo_in_model, stereo_separation, stereo_convergence, stereo_depth_power, stereo_pole_power,
+ patch_vae, tiling_disable_hr, use_kohaku,
+ enable_mirroring,
+ mirror_mode, mirror_style, x_pan, y_pan,
+ mirroring_max_step_fraction,
+ mirror_step_mode, mirror_start_frac, mirror_end_frac,
+ mirror_step_control_enabled, sc_pan_one_shot, sc_pan_lock_after_end,
+ disable_hr,
+ cfg_drift_enable, cfg_drift_method, cfg_drift_intensity,
+ latent_noise_init, null_mix,
+ dcg_enable, dcg_recenter, dcg_normalization,
+ lcm_enable, lcm_per_channel_shift, lcm_full_tensor_shift,
+ lcm_maximize, lcm_boundary,
+ grain_enable, grain_noise_scale, grain_noise_radius,
+ grain_noise_tail, grain_luma, grain_seed]
+
+ # ====== LATENT MIRRORING CALLBACK ======
+
+ def denoise_callback(self, params):
+ # -------- Latent Noise Init (step 0 only) --------
+ if (params.sampling_step == 0
+ and getattr(self, "_latent_noise_init", False)
+ and not getattr(self, "is_hires", False)
+ and params.x is not None):
+ try:
+ b, c, h, w = params.x.shape
+ noise = gaussian_latent_noise(
+ h, w,
+ ver=getattr(self, "_sd_ver", "v1"),
+ nul=getattr(self, "_null_mix", 0.25),
+ srnd=True,
+ device=params.x.device,
+ dtype=params.x.dtype,
+ )
+ # Expand to batch size
+ params.x = noise.unsqueeze(0).expand(b, -1, -1, -1).contiguous()
+ except Exception as e:
+ print(f"[Latent Noise Init] ошибка: {e}")
+
+ # -------- Latent Zoom ------------------------------------------------
+ # Three modes, all guarded by is_hires:
+ # Step 0 / Custom fraction → one-shot, _latent_zoom_applied blocks repeat
+ # Animated range → fires on every step in [start, end] range,
+ # from_origin avoids blur accumulation
+ if (
+ getattr(self, "_latent_zoom_enabled", False)
+ and not getattr(self, "is_hires", False)
+ and params.x is not None
+ ):
+ try:
+ _zoom_mode_str = str(getattr(self, "_latent_zoom_apply_mode",
+ "Step 0 (default)") or "Step 0 (default)")
+ _sc_enabled = getattr(self, "_latent_zoom_step_control_enabled", False)
+ _total = max(int(params.total_sampling_steps or 1), 1)
+ _cur = int(params.sampling_step)
+
+ _do_zoom_now = False
+ _zoom_factor_override = None # None = use zp["zoom_factor"] as-is
+
+ if not _sc_enabled or _zoom_mode_str == "Step 0 (default)":
+ # ── ONE-SHOT at step 0 (default) ──────────────────────────
+ if _cur == 0 and not getattr(self, "_latent_zoom_applied", False):
+ _do_zoom_now = True
+
+ elif _zoom_mode_str == "Custom fraction":
+ # ── ONE-SHOT at custom step ───────────────────────────────
+ if not getattr(self, "_latent_zoom_applied", False):
+ _frac = float(getattr(self, "_latent_zoom_apply_frac", 0.0) or 0.0)
+ _target = min(int(round((_total - 1) * _frac)), _total - 1)
+ if _cur == _target:
+ _do_zoom_now = True
+
+ elif _zoom_mode_str == "Animated range":
+ # Hard guard: if lock_after_end fired once, never re-enter this range
+ if (getattr(self, "_zoom_lock_after_end", False)
+ and getattr(self, "_zoom_range_finished_once", False)):
+ pass # silently skip — one-pass guarantee
+ else:
+ # ── ANIMATED RANGE ─────────────────────────────────────
+ # canvas backend warning: fill at mid-steps = noisy artefacts
+ zp_chk = dict(getattr(self, "_latent_zoom_params", None) or {})
+ _zm_chk = str(zp_chk.get("zoom_mode", "grid_warp"))
+ _be_chk = resolve_zoom_backend(_zm_chk, zp_chk.get("zoom_engine", "auto"))
+ if _be_chk != ZOOM_BACKEND_GEOMETRY:
+ if not getattr(self, "_zoom_canvas_warned", False):
+ print("[Latent Zoom] ⚠ Animated range с canvas backend даёт "
+ "шумный fill на mid-steps. Рекомендуется geometry backend "
+ "(grid_warp / spiral_zoom / convergence_shift).")
+ self._zoom_canvas_warned = True
+
+ _rng_s = float(getattr(self, "_zoom_range_start_frac", 0.0))
+ _rng_e = float(getattr(self, "_zoom_range_end_frac", 0.35))
+ _step_s = min(int(round((_total - 1) * _rng_s)), _total - 1)
+ _step_e = min(int(round((_total - 1) * _rng_e)), _total - 1)
+ if _step_s > _step_e:
+ _step_s, _step_e = _step_e, _step_s
+
+ _every_n = max(1, int(getattr(self, "_zoom_every_n_steps", 1) or 1))
+ _in_range = (_step_s <= _cur <= _step_e)
+ _on_tick = (_in_range and ((_cur - _step_s) % _every_n == 0))
+
+ if _in_range and _on_tick:
+ # Compute interpolation progress
+ _span = max(_step_e - _step_s, 1)
+ _t = (_cur - _step_s) / _span
+ _eased = _zoom_easing_fn(_t, str(getattr(self, "_zoom_easing", "ease_in_out") or "ease_in_out"))
+ _zf_s_raw = getattr(self, "_zoom_factor_start", 0.0)
+ _zf_e_raw = getattr(self, "_zoom_factor_end", 5.0)
+ _zf_s = float(_zf_s_raw if _zf_s_raw is not None else 0.0)
+ _zf_e = float(_zf_e_raw if _zf_e_raw is not None else 5.0)
+ _zoom_factor_override = _zf_s + (_zf_e - _zf_s) * _eased
+
+ # from_origin: store x at first step of range, warp from it every time
+ if getattr(self, "_zoom_from_origin", True):
+ if not getattr(self, "_zoom_origin_stored", False):
+ self._zoom_origin_tensor = params.x.detach().clone()
+ self._zoom_origin_stored = True
+
+ _do_zoom_now = True
+
+ # 🔒 Arm guard on the last tick so it fires even if pass ends here
+ if getattr(self, "_zoom_lock_after_end", False) and _cur == _step_e:
+ self._zoom_range_finished_once = True
+
+ elif _cur > _step_e and getattr(self, "_zoom_lock_after_end", False):
+ # 🔒 Guard for normal exit (step counter goes past end)
+ self._zoom_range_finished_once = True
+ _do_zoom_now = False
+
+ if _do_zoom_now:
+ zp = dict(getattr(self, "_latent_zoom_params", None) or {})
+ _zm = zp.get("zoom_mode", "grid_warp")
+ if hasattr(_zm, "value"):
+ _zm = str(_zm.value)
+ else:
+ _zm = str(_zm)
+ zp["zoom_mode"] = _zm
+ if _zoom_factor_override is not None:
+ zp["zoom_factor"] = _zoom_factor_override
+
+ _seed = -1
+ try:
+ _seed = int(getattr(getattr(self, "_p_ref", None), "seed", -1) or -1)
+ except Exception:
+ pass
+
+ # Animated range + from_origin: always warp from stored origin tensor
+ if (_zoom_mode_str == "Animated range"
+ and getattr(self, "_zoom_from_origin", True)
+ and getattr(self, "_zoom_origin_stored", False)):
+ _src = self._zoom_origin_tensor
+ else:
+ _src = params.x
+
+ # Route through compose layer (Global / Pinned Subject / Dual-Transform)
+ params.x = apply_zoom_compose_latent(
+ _src, zp,
+ compose_mode=getattr(self, "_zoom_compose_mode", "Global"),
+ roi_shape=getattr(self, "_roi_shape", "ellipse"),
+ roi_center_x=getattr(self, "_roi_center_x", 0.5),
+ roi_center_y=getattr(self, "_roi_center_y", 0.5),
+ roi_radius_x=getattr(self, "_roi_radius_x", 0.18),
+ roi_radius_y=getattr(self, "_roi_radius_y", 0.18),
+ roi_feather=getattr(self, "_roi_feather", 0.08),
+ roi_preserve_strength=getattr(self, "_roi_preserve_strength", 1.0),
+ roi_fg_zoom_factor=getattr(self, "_roi_fg_zoom_factor", 0.0),
+ roi_bg_zoom_factor=getattr(self, "_roi_bg_zoom_factor", 0.0),
+ seed=_seed,
+ )
+
+ self._latent_zoom_applied = True
+ _zf_log = zp.get("zoom_factor", "?")
+ print(f"[Latent Zoom] ✓ step {_cur} "
+ f"mode={_zoom_mode_str!r} zf={_zf_log:.3f}"
+ if isinstance(_zf_log, float) else
+ f"[Latent Zoom] ✓ step {_cur} mode={_zoom_mode_str!r}")
+
+ except Exception as _ze:
+ import traceback
+ print(f"[Latent Zoom] ошибка: {_ze}")
+ traceback.print_exc()
+ # ─────────────────────────────────────────────────────────────────────
+ tiling_is_hires = getattr(self, "tiling_is_hires", False)
+ if getattr(self, "tiling_enable_hr", False) and params.total_sampling_steps > 0:
+ if params.sampling_step >= params.total_sampling_steps - 2:
+ # Переключаем флаг между base/hires
+ self.tiling_is_hires = not tiling_is_hires
+
+ # --- Оригинальная логика Latent Mirroring ---
+ is_hires = self.is_hires
+
+ # indices start at -1; params.sampling_step = max(0, real_sampling_step)
+ if params.sampling_step >= params.total_sampling_steps - 2:
+ self.is_hires = not is_hires and self.enable_hr
+
+ # -------- Per-step Latent Effects (независимы от mirroring) --------
+ # BUG FIX (run_callback gate): CFG drift / DCG / LCM / Grain раньше были
+ # заблокированы через `if not self.run_callback or is_hires: return`,
+ # где run_callback завязан только на need_mirroring. То есть все эти фичи
+ # молча не работали при выключенном Latent Mirroring.
+ # Теперь они проверяют собственный флаг _run_latent_effects и не зависят
+ # от того, включён ли mirroring.
+ if not is_hires and getattr(self, "_run_latent_effects", False):
+ cur_step = params.sampling_step
+ total_steps = max(params.total_sampling_steps, 1)
+
+ # -------- CFG Drift Correction (runs every step) --------
+ if getattr(self, "_cfg_drift_enable", False):
+ params.x = apply_combat_cfg_drift(
+ params.x,
+ method=getattr(self, "_cfg_drift_method", "mean"),
+ intensity=getattr(self, "_cfg_drift_intensity", 1.0)
+ )
+
+ # -------- Diffusion CG (runs every step) --------
+ if getattr(self, "_dcg_enable", False):
+ params.x = apply_diffusion_cg(
+ params.x,
+ cur_step=cur_step,
+ total_steps=total_steps,
+ recenter=getattr(self, "_dcg_recenter", 0.0),
+ normalization=getattr(self, "_dcg_normalization", 0.0),
+ )
+
+ # -------- Latent Center / Maximize (F2+F3, runs every step) --------
+ if getattr(self, "_lcm_enable", False):
+ try:
+ pcs = getattr(self, "_lcm_per_channel_shift", 1.0)
+ fts = getattr(self, "_lcm_full_tensor_shift", 1.0)
+ params.x = center_tensor(
+ params.x.clone(), per_channel_shift=pcs, full_tensor_shift=fts
+ )
+ if getattr(self, "_lcm_maximize", False):
+ bnd = getattr(self, "_lcm_boundary", 4.0)
+ params.x = maximize_tensor_v2(params.x.clone(), boundary=bnd)
+ except Exception as e:
+ print(f"[LCM] ошибка: {e}")
+
+ # -------- Latent Grain (F5/F11/F12, runs every step) --------
+ if getattr(self, "_grain_enable", False):
+ params.x = apply_latent_grain(
+ params.x,
+ noise_scale = getattr(self, "_grain_noise_scale", 0.02),
+ noise_radius = getattr(self, "_grain_noise_radius", 3),
+ noise_tail = getattr(self, "_grain_noise_tail", 0.0),
+ grain_luma = getattr(self, "_grain_luma", 0.0),
+ seed = getattr(self, "_grain_seed", -1),
+ )
+
+ # -------- Latent Mirroring / Pan (gate: run_callback) --------
+ if not self.run_callback or is_hires:
+ return
+
+ cur_step = params.sampling_step
+ total_steps = max(params.total_sampling_steps, 1)
+ # 0 = Max fraction (оригинал),
+ # 1 = Custom range [mirror_start_frac, mirror_end_frac]
+ mirror_step_mode = getattr(self, "mirror_step_mode", 0)
+
+ if mirror_step_mode == 0:
+ # Оригинальное поведение: от начала до max_fraction * total_steps
+ if cur_step >= total_steps * self.mirroring_max_step_fraction:
+ return
+ else:
+ # Новый режим: собственный диапазон Start/End в долях
+ start_step = int(total_steps * getattr(self, "mirror_start_frac", 0.0))
+ end_step = int(total_steps * getattr(self, "mirror_end_frac", 1.0))
+ if start_step > end_step:
+ start_step, end_step = end_step, start_step
+ if not (start_step <= cur_step <= end_step):
+ return
+
+ try:
+ if self.mirror_mode == 1:
+ if self.mirror_style == 0:
+ params.x[:, :, :, :] = torch.flip(params.x, [3])
+ elif self.mirror_style == 1:
+ params.x[:, :, :, :] = torch.flip(params.x, [2])
+ elif self.mirror_style == 2:
+ params.x[:, :, :, :] = torch.flip(params.x, [3, 2])
+ elif self.mirror_style == 3:
+ params.x[:, :, :, :] = torch.rot90(params.x, dims=[2, 3])
+ elif self.mirror_style == 4:
+ params.x[:, :, :, :] = torch.rot90(
+ torch.rot90(params.x, dims=[2, 3]), dims=[2, 3]
+ )
+ elif self.mirror_style == 5:
+ params.x[:, :, :, :] = torch.roll(params.x, shifts=1, dims=[1])
+
+ elif self.mirror_mode == 2:
+ if self.mirror_style == 0:
+ params.x[:, :, :, :] = (torch.flip(params.x, [3]) + params.x) / 2
+ elif self.mirror_style == 1:
+ params.x[:, :, :, :] = (torch.flip(params.x, [2]) + params.x) / 2
+ elif self.mirror_style == 2:
+ params.x[:, :, :, :] = (torch.flip(params.x, [2, 3]) + params.x) / 2
+ elif self.mirror_style == 3:
+ params.x[:, :, :, :] = (torch.rot90(params.x, dims=[2, 3]) + params.x) / 2
+ elif self.mirror_style == 4:
+ params.x[:, :, :, :] = (
+ torch.rot90(torch.rot90(params.x, dims=[2, 3]), dims=[2, 3]) + params.x
+ ) / 2
+ elif self.mirror_style == 5:
+ params.x[:, :, :, :] = (torch.roll(params.x, shifts=1, dims=[1]) + params.x) / 2
+ except RuntimeError as e:
+ if self.mirror_style in (3, 4):
+ raise RuntimeError('90 Degree Rotation requires a square image.') from e
+ else:
+ raise RuntimeError('Error transforming image for latent mirroring.') from e
+
+ if self.x_pan != 0 or self.y_pan != 0:
+ self._apply_advanced_pan(params, cur_step, total_steps)
+
+ def _apply_advanced_pan(self, params, step, total):
+ """Advanced pan: One-Shot, Lock after End, обычный per-step pan.
+ Реализация из latent_mirroring_advanced.py.
+ """
+ if self.x_pan == 0.0 and self.y_pan == 0.0:
+ return
+
+ def _mirror_range_bounds(t):
+ mm = getattr(self, "mirror_step_mode", 0)
+ if mm == 0:
+ start = 0
+ end = int(t * self.mirroring_max_step_fraction)
+ else:
+ start = int(t * getattr(self, "mirror_start_frac", 0.0))
+ end = int(t * getattr(self, "mirror_end_frac", 1.0))
+ if start > end:
+ start, end = end, start
+ return start, end
+
+ def _in_mirror_range(s, t):
+ start, end = _mirror_range_bounds(t)
+ return start <= s <= end
+
+ sc = getattr(self, "mirror_step_control_enabled", False)
+
+ # ── Mode 1: sc_pan_one_shot — один раз на первом шаге диапазона ────────
+ if sc and self.sc_pan_one_shot:
+ if self._pan_applied:
+ return
+ if not _in_mirror_range(step, total):
+ return
+ start, _ = _mirror_range_bounds(total)
+ if step != start:
+ return
+ self._pan_applied = True
+ self._do_pan(params)
+ return
+
+ # ── Mode 2: sc_pan_lock_after_end ────────────────────────────────────
+ # Корректное поведение: до Start → ждать, в диапазоне → pan,
+ # только ПОСЛЕ End → навсегда lock. Не лочить до начала окна!
+ if sc and self.sc_pan_lock_after_end:
+ if self._pan_locked:
+ return
+ start, end = _mirror_range_bounds(total)
+ if step < start:
+ return # до старта — просто ждём
+ if step > end:
+ self._pan_locked = True # вышли за End → вечный замок
+ return
+ # Внутри диапазона — работаем
+ self._do_pan(params)
+ return
+
+ # ── Mode 3: обычный per-step pan (проверяем диапазон) ────────────────
+ if not _in_mirror_range(step, total):
+ return
+ self._do_pan(params)
+
+ def _do_pan(self, params):
+ """Физически применяет сдвиг X/Y к латенту."""
+ x = params.x
+ if self.x_pan != 0.0:
+ x[:] = torch.roll(x, shifts=int(x.size(3) * self.x_pan), dims=[3])
+ if self.y_pan != 0.0:
+ x[:] = torch.roll(x, shifts=int(x.size(2) * self.y_pan), dims=[2])
+
+ # ====== PREVIEW ======
+
+ def generate_preview(self, mx, my,
+ use_panorama=False, use_polar=False, use_cubemap=False,
+ use_aniso=False, aniso_angle=45,
+ stereo=False, eye='left'):
+ """
+ Generate 2×2 tiling preview.
+ Basic modes (Circular/Mirror/Hexagonal), Anisotropic, and Stereo are
+ rendered visually. Special modes (Panorama, Cubemap, Polar) and enhanced
+ procedural modes (Voronoi, Perlin, Fractal, Adaptive) show a labelled
+ placeholder — runtime behaviour will differ from this preview.
+ """
+ h, w = 256, 256
+
+ # ── Special-mode placeholder ──────────────────────────────────────────
+ _special_labels = []
+ if use_panorama: _special_labels.append("Panorama 360°")
+ if use_cubemap: _special_labels.append("Cubemap")
+ if use_polar: _special_labels.append("Polar")
+ if _special_labels:
+ canvas = np.full((h * 2, w * 2, 3), 30, dtype=np.uint8)
+ label = f"[ {' / '.join(_special_labels)} ]\nPreview not supported.\nSee rendered output."
+ try:
+ from PIL import Image as _PIL_Image, ImageDraw as _PIL_Draw
+ pil = _PIL_Image.fromarray(canvas)
+ draw = _PIL_Draw.Draw(pil)
+ draw.multiline_text((20, h - 30), label, fill=(200, 200, 60), spacing=6)
+ canvas = np.array(pil)
+ except Exception:
+ pass # PIL not available — return blank canvas
+ return canvas
+
+ # ── Enhanced procedural mode placeholder ─────────────────────────────
+ _proc_modes = {
+ MODE_VORONOI: "Voronoi",
+ MODE_PERLIN: "Perlin Noise",
+ MODE_FRACTAL: "Fractal",
+ MODE_ADAPTIVE:"Adaptive",
+ }
+ _active_proc = next((name for m, name in _proc_modes.items()
+ if mx == m or my == m), None)
+ if _active_proc:
+ canvas = np.full((h * 2, w * 2, 3), 20, dtype=np.uint8)
+ try:
+ from PIL import Image as _PIL_Image, ImageDraw as _PIL_Draw
+ pil = _PIL_Image.fromarray(canvas)
+ draw = _PIL_Draw.Draw(pil)
+ draw.multiline_text(
+ (20, h - 20),
+ f"[ {_active_proc} ]\nRendered differently at runtime.",
+ fill=(100, 180, 200), spacing=6
+ )
+ canvas = np.array(pil)
+ except Exception:
+ pass
+ return canvas
+
+ # ── Normal 2×2 preview (Basic + Anisotropic + Stereo) ────────────────
+ img = np.zeros((h, w, 3), dtype=np.uint8)
+ for i in range(h):
+ for j in range(w):
+ col = (i + j) % 255
+ if i < 5 or i > h - 5 or j < 5 or j > w - 5:
+ img[i, j] = [255, 50, 50]
+ else:
+ img[i, j] = [col, col // 2, 255 - col]
+
+ def get_tile(r, c):
+ tile = img.copy()
+
+ if use_aniso:
+ angle_rad = np.radians(aniso_angle)
+ for ii in range(h):
+ for jj in range(w):
+ dist = abs((jj - w / 2) * np.cos(angle_rad) +
+ (ii - h / 2) * np.sin(angle_rad))
+ tile[ii, jj] = tile[ii, jj] * (0.5 + 0.5 * np.sin(dist * 0.1))
+
+ elif stereo:
+ shift = 10 if eye == 'left' else -10
+ tile = np.roll(tile, shift, axis=1)
+
+ else:
+ if mx == MODE_MIRROR and c % 2 != 0:
+ tile = np.fliplr(tile)
+ if my == MODE_MIRROR and r % 2 != 0:
+ tile = np.flipud(tile)
+ if mx == MODE_HEXAGONAL and r % 2 != 0:
+ tile = np.roll(tile, w // 2, axis=1)
+
+ return tile.astype(np.uint8)
+
+ canvas = np.zeros((h * 2, w * 2, 3), dtype=np.uint8)
+ for r in range(2):
+ for c in range(2):
+ canvas[r * h:(r + 1) * h, c * w:(c + 1) * w] = get_tile(r, c)
+
+ return canvas
+
+ # ====== PROCESS (TILING + MIRRORING) ======
+
+ def process(self, p,
+ enabled, mode_x, mode_y,
+ start_step, end_step,
+ step_mode, step_start_frac, step_end_frac,
+ tiling_lock_after_end, tiling_pan_one_shot,
+ multires, multires_strategy, multires_start, multires_end, multires_sharpness,
+ voronoi_cells, voronoi_seed,
+ perlin_strength, perlin_scale,
+ fractal_iterations, fractal_scale,
+ adaptive_threshold,
+ use_panorama, use_polar,
+ panorama_engine, panorama_coord_mode,
+ panorama_yaw, panorama_pitch, panorama_roll,
+ panorama_twist_deg, panorama_twist_power, panorama_swirl_deg, panorama_swirl_power,
+ panorama_polar_scale, panorama_polar_power, panorama_pole_ease_power,
+ panorama_antipode_strength, panorama_pole_blur_strength, panorama_pole_blur_radius, panorama_pole_blur_power,
+ panorama_geoaa_samples, panorama_geoaa_radius,
+ panorama_grid_interp, panorama_grid_padding, panorama_cache_angle_quant,
+ use_cubemap, cubemap_engine, cubemap_resolution_mode, cubemap_pad_mode, cubemap_blend_width, cubemap_blend_strength,
+ cubemap_yaw, cubemap_pitch, cubemap_roll, cubemap_coord_mode, cubemap_twist_deg, cubemap_polar_scale, cubemap_polar_power, cubemap_swirl_deg, cubemap_swirl_power, cubemap_grid_interp, cubemap_grid_padding, cubemap_cache_angle_quant, cubemap_geoaa_samples, cubemap_geoaa_radius, cubemap_antipode_strength,
+ use_blend, blend_strength, blend_falloff, blend_sharpness, blend_width,
+ # --- ZOOM PARAMETERS ---
+ use_zoom, zoom_factor, zoom_mode, zoom_engine,
+ zoom_path, conv_zoom_strength,
+ zoom_step_control_enabled, zoom_apply_mode, zoom_apply_frac,
+ zoom_range_start_frac, zoom_range_end_frac,
+ zoom_factor_start, zoom_factor_end, zoom_easing,
+ zoom_every_n_steps, zoom_from_origin,
+ zoom_lock_after_end,
+ zoom_compose_mode,
+ roi_shape, roi_preserve_strength,
+ roi_center_x, roi_center_y,
+ roi_radius_x, roi_radius_y,
+ roi_feather,
+ roi_fg_zoom_factor, roi_bg_zoom_factor,
+ noise_strength, interp_mode, edge_fade,
+ variance_correction, auto_clamp_pan, adaptive_noise_scale, debug_mode,
+ blend_mode_type,
+ zoom_convergence, zoom_depth_power,
+ zoom_force_original_size, zoom_fade_to_black, zoom_fade_strength,
+ zoom_pan_x, zoom_pan_y,
+ spiral_rotation, spiral_direction,
+ use_anisotropic, aniso_angle, aniso_angle2, aniso_angle_mix,
+ stereo_enabled, stereo_eye, stereo_engine, stereo_output, stereo_in_model, stereo_separation, stereo_convergence, stereo_depth_power, stereo_pole_power,
+ patch_vae, tiling_disable_hr, use_kohaku,
+ enable_mirroring,
+ mirror_mode, mirror_style, x_pan, y_pan,
+ mirroring_max_step_fraction,
+ mirror_step_mode, mirror_start_frac, mirror_end_frac,
+ mirror_step_control_enabled, sc_pan_one_shot, sc_pan_lock_after_end,
+ disable_hr,
+ cfg_drift_enable, cfg_drift_method, cfg_drift_intensity,
+ latent_noise_init, null_mix,
+ dcg_enable, dcg_recenter, dcg_normalization,
+ lcm_enable, lcm_per_channel_shift, lcm_full_tensor_shift,
+ lcm_maximize, lcm_boundary,
+ grain_enable, grain_noise_scale, grain_noise_radius,
+ grain_noise_tail, grain_luma, grain_seed):
+
+ # -------- Latent Mirroring часть --------
+ self.mirror_mode = mirror_mode
+ self.mirror_style = mirror_style
+ self.mirroring_max_step_fraction = mirroring_max_step_fraction
+ self.x_pan = x_pan
+ self.y_pan = y_pan
+ self.mirror_step_mode = mirror_step_mode
+ self.mirror_start_frac = mirror_start_frac
+ self.mirror_end_frac = mirror_end_frac
+ # Advanced step control (from latent_mirroring_advanced)
+ self.mirror_step_control_enabled = bool(mirror_step_control_enabled)
+ self.sc_pan_one_shot = bool(sc_pan_one_shot)
+ self.sc_pan_lock_after_end = bool(sc_pan_lock_after_end)
+ self._pan_applied = False # one-shot flag: reset each generation
+ self._pan_locked = False # lock-after-end flag: reset each generation
+
+ # -------- CFG Drift Correction --------
+ self._cfg_drift_enable = bool(cfg_drift_enable)
+ self._cfg_drift_method = str(cfg_drift_method)
+ self._cfg_drift_intensity = float(cfg_drift_intensity)
+
+ # -------- Latent Noise Init --------
+ self._latent_noise_init = bool(latent_noise_init)
+ self._null_mix = float(null_mix)
+
+ # -------- Diffusion CG --------
+ self._dcg_enable = bool(dcg_enable)
+ self._dcg_recenter = float(dcg_recenter)
+ self._dcg_normalization = float(dcg_normalization)
+
+ # -------- Latent Center / Maximize (F2+F3) --------
+ self._lcm_enable = bool(lcm_enable)
+ self._lcm_per_channel_shift = float(lcm_per_channel_shift)
+ self._lcm_full_tensor_shift = float(lcm_full_tensor_shift)
+ self._lcm_maximize = bool(lcm_maximize)
+ self._lcm_boundary = float(lcm_boundary)
+
+ # -------- Latent Grain (F5/F11/F12) --------
+ self._grain_enable = bool(grain_enable)
+ self._grain_noise_scale = float(grain_noise_scale)
+ self._grain_noise_radius = int(grain_noise_radius)
+ self._grain_noise_tail = float(grain_noise_tail)
+ self._grain_luma = float(grain_luma)
+ self._grain_seed = int(grain_seed)
+ # SD version: v1 (SD1.5) или xl (SDXL)
+ try:
+ self._sd_ver = "xl" if getattr(shared.sd_model, "is_sdxl", False) else "v1"
+ except Exception:
+ self._sd_ver = "v1"
+
+ # Mirroring включается, только если:
+ # - чекбокс Enable Latent Mirroring включён
+ # - и есть хотя бы какой-то эффект (mode или pan)
+ need_mirroring = enable_mirroring and (mirror_mode != 0 or x_pan != 0 or y_pan != 0)
+
+ # denoise_callback нужен либо для mirroring,
+ # либо для Advanced Tiling с отключением на hires-проходе
+ need_denoise_cb = need_mirroring or (tiling_disable_hr and getattr(p, "enable_hr", False))
+ need_denoise_cb = need_denoise_cb or self._cfg_drift_enable
+ need_denoise_cb = need_denoise_cb or self._latent_noise_init
+ need_denoise_cb = need_denoise_cb or self._dcg_enable
+ need_denoise_cb = need_denoise_cb or self._lcm_enable
+ need_denoise_cb = need_denoise_cb or self._grain_enable
+ # BUG FIX: нельзя читать self._latent_zoom_enabled здесь — он выставляется
+ # только ПОСЛЕ этого блока в zoom pre-validation. Читаем сырой параметр use_zoom.
+ need_denoise_cb = need_denoise_cb or bool(use_zoom)
+
+ # Флаг для per-step latent эффектов (CFG drift / DCG / LCM / Grain).
+ # Живёт НЕЗАВИСИМО от run_callback/need_mirroring — эти фичи должны
+ # работать даже когда mirroring отключён.
+ self._run_latent_effects = (
+ self._cfg_drift_enable or
+ self._dcg_enable or
+ self._lcm_enable or
+ self._grain_enable
+ )
+
+ # Экспорт параметров только если Latent Mirroring реально активен
+ if need_mirroring:
+ if mirror_mode != 0:
+ p.extra_generation_params["Mirror Mode"] = mirror_mode
+ p.extra_generation_params["Mirror Style"] = mirror_style
+ if mirror_step_mode == 0:
+ # Оригинальный режим — до max_fraction
+ p.extra_generation_params["Mirroring Max Step Fraction"] = mirroring_max_step_fraction
+ else:
+ # Новый режим — диапазон Start/End в долях
+ p.extra_generation_params["Mirror Start Fraction"] = mirror_start_frac
+ p.extra_generation_params["Mirror End Fraction"] = mirror_end_frac
+ if x_pan != 0:
+ p.extra_generation_params["X Pan"] = x_pan
+ if y_pan != 0:
+ p.extra_generation_params["Y Pan"] = y_pan
+
+ if need_denoise_cb and not hasattr(self, 'callbacks_added'):
+ on_cfg_denoiser(self.denoise_callback)
+ self.callbacks_added = True
+
+ # run_callback управляет только Latent Mirroring
+ self.run_callback = need_mirroring
+
+ # hires-логика для Latent Mirroring (оригинальное поведение)
+ self.enable_hr = getattr(p, 'enable_hr', False) and not disable_hr
+ self.is_hires = False
+
+ # hires-логика для Advanced Tiling (независимо от mirroring)
+ self.tiling_enable_hr = getattr(p, 'enable_hr', False)
+ self.tiling_is_hires = False
+
+ # -------- Advanced Tiling часть --------
+ if not enabled:
+ return
+
+
+ # -------- Обработка режимов Start/End Step для Tiling --------
+ # step_mode: 0 = Absolute Steps, 1 = Fraction of total steps
+ if step_mode == 1:
+ total_steps = max(getattr(p, "steps", 0), 1)
+ # Преобразуем доли в реальные шаги
+ start_step = int(total_steps * step_start_frac)
+ end_step = int(total_steps * step_end_frac)
+
+ # Валидация диапазона
+ if start_step > end_step:
+ start_step, end_step = end_step, start_step
+
+ # Kohaku
+ if use_kohaku:
+ register_kohaku_sampler()
+ if p.sampler_name != 'Kohaku_LoNyu_Yog':
+ print(f"Switching sampler from {p.sampler_name} to Kohaku_LoNyu_Yog")
+ p.sampler_name = 'Kohaku_LoNyu_Yog'
+
+
+
+ # Export panorama / stereo / cubemap settings to metadata (inside process)
+ try:
+ if getattr(p, "extra_generation_params", None) is None:
+ p.extra_generation_params = {}
+ except Exception:
+ pass
+
+ if use_panorama:
+ try:
+ p.extra_generation_params["Panorama Engine"] = str(panorama_engine)
+ if str(panorama_engine).startswith(("B", "C")):
+ p.extra_generation_params["Panorama Antipode Mix"] = float(panorama_antipode_strength)
+ p.extra_generation_params["Panorama Pole Blur"] = float(panorama_pole_blur_strength)
+ p.extra_generation_params["Panorama Pole Blur Radius"] = int(panorama_pole_blur_radius)
+ p.extra_generation_params["Panorama Pole Easing Power"] = float(panorama_pole_ease_power)
+ if str(panorama_engine).startswith("C"):
+ p.extra_generation_params["Panorama Yaw"] = float(panorama_yaw)
+ p.extra_generation_params["Panorama Pitch"] = float(panorama_pitch)
+ p.extra_generation_params["Panorama Roll"] = float(panorama_roll)
+ p.extra_generation_params["Panorama Coord Mode"] = str(panorama_coord_mode)
+ p.extra_generation_params["Panorama Twist"] = float(panorama_twist_deg)
+ p.extra_generation_params["Panorama Twist Power"] = float(panorama_twist_power)
+ p.extra_generation_params["Panorama Swirl"] = float(panorama_swirl_deg)
+ p.extra_generation_params["Panorama Swirl Power"] = float(panorama_swirl_power)
+ p.extra_generation_params["Panorama Polar Scale"] = float(panorama_polar_scale)
+ p.extra_generation_params["Panorama Polar Power"] = float(panorama_polar_power)
+ p.extra_generation_params["Panorama GeoAA Samples"] = int(panorama_geoaa_samples)
+ p.extra_generation_params["Panorama GeoAA Radius"] = float(panorama_geoaa_radius)
+ p.extra_generation_params["Panorama grid_sample Interp"] = str(panorama_grid_interp)
+ p.extra_generation_params["Panorama grid_sample Padding"] = str(panorama_grid_padding)
+ p.extra_generation_params["Panorama Cache Quant"] = float(panorama_cache_angle_quant)
+ except Exception:
+ pass
+
+ if stereo_enabled:
+ try:
+ p.extra_generation_params["Stereoscopic 3D"] = "Enabled"
+ p.extra_generation_params["Stereo Engine"] = str(stereo_engine)
+ p.extra_generation_params["Stereo Output"] = str(stereo_output)
+ p.extra_generation_params["Stereo In-Model"] = bool(stereo_in_model)
+ p.extra_generation_params["Stereo Separation"] = float(stereo_separation)
+ p.extra_generation_params["Stereo Convergence"] = float(stereo_convergence)
+ p.extra_generation_params["Stereo Depth Power"] = float(stereo_depth_power)
+ p.extra_generation_params["Stereo Pole Power"] = float(stereo_pole_power)
+ except Exception:
+ pass
+
+ if use_cubemap:
+ try:
+ p.extra_generation_params["Cubemap Engine"] = str(cubemap_engine)
+ p.extra_generation_params["Cubemap Pad Mode"] = str(cubemap_pad_mode)
+ if str(cubemap_engine).startswith("B"):
+ p.extra_generation_params["Cubemap Seam Width"] = int(cubemap_blend_width)
+ p.extra_generation_params["Cubemap Seam Strength"] = float(cubemap_blend_strength)
+ if str(cubemap_engine).startswith("C"):
+ p.extra_generation_params["Cubemap Yaw"] = float(cubemap_yaw)
+ p.extra_generation_params["Cubemap Pitch"] = float(cubemap_pitch)
+ p.extra_generation_params["Cubemap Roll"] = float(cubemap_roll)
+ p.extra_generation_params["Cubemap Coord Mode"] = str(cubemap_coord_mode)
+ p.extra_generation_params["Cubemap Face Twist"] = float(cubemap_twist_deg)
+ p.extra_generation_params["Cubemap Polar Scale"] = float(cubemap_polar_scale)
+ p.extra_generation_params["Cubemap Polar Power"] = float(cubemap_polar_power)
+ p.extra_generation_params["Cubemap Swirl"] = float(cubemap_swirl_deg)
+ p.extra_generation_params["Cubemap Swirl Power"] = float(cubemap_swirl_power)
+ p.extra_generation_params["Cubemap grid_sample Interp"] = str(cubemap_grid_interp)
+ p.extra_generation_params["Cubemap grid_sample Padding"] = str(cubemap_grid_padding)
+ p.extra_generation_params["Cubemap Cache Quant"] = float(cubemap_cache_angle_quant)
+ p.extra_generation_params["Cubemap GeoAA Samples"] = int(cubemap_geoaa_samples)
+ p.extra_generation_params["Cubemap GeoAA Radius"] = float(cubemap_geoaa_radius)
+ p.extra_generation_params["Cubemap Antipode Mix"] = float(cubemap_antipode_strength)
+ except Exception:
+ pass
+
+ # Cubemap resolution helper (optional)
+ if use_cubemap and isinstance(cubemap_resolution_mode, str) and cubemap_resolution_mode.startswith("Face size"):
+ # Interpret current width/height as a single face, expand to 3x2 net
+ try:
+ p.width = int(p.width) * 3
+ p.height = int(p.height) * 2
+ except Exception:
+ pass
+
+ # Спецрежимы (приоритет: Cubemap > Polar > Panorama > Anisotropic)
+ if use_cubemap:
+ mode_x = mode_y = MODE_CUBEMAP
+ elif use_polar:
+ mode_x = mode_y = MODE_POLAR
+ elif use_panorama:
+ mode_x = mode_y = MODE_PANORAMA
+ elif use_anisotropic:
+ mode_x = mode_y = MODE_ANISOTROPIC
+
+ # ── ZOOM: Pre-validate ONE TIME per generation (FIX замедления) ──────────
+ # Вместо validate_zoom_params() × 150 раз за шаг — делаем это один раз здесь.
+ _zoom_prevalidated = None
+ _zoom_extra_prevalidated = None
+
+ if use_zoom:
+ try:
+ _raw_zoom = {
+ 'zoom_factor': float(zoom_factor),
+ 'zoom_mode': zoom_mode,
+ 'blend_mode': blend_mode_type,
+ 'convergence_point': float(zoom_convergence),
+ 'convergence_y': 0.5,
+ 'depth_power': float(zoom_depth_power),
+ 'pan_x': float(zoom_pan_x),
+ 'pan_y': float(zoom_pan_y),
+ 'noise_strength': float(noise_strength),
+ 'interp_mode': str(interp_mode),
+ 'edge_fade': bool(edge_fade), # роутер читает также старый ключ zoom_in_fade для compat
+ 'variance_correction': bool(variance_correction),
+ 'auto_clamp_pan': bool(auto_clamp_pan),
+ 'adaptive_noise_scale': bool(adaptive_noise_scale),
+ 'debug_mode': bool(debug_mode),
+ 'zoom_fade_to_black': bool(zoom_fade_to_black),
+ 'zoom_fade_strength': float(zoom_fade_strength),
+ 'spiral_rotation': float(spiral_rotation),
+ 'spiral_direction': coerce_spiral_direction(spiral_direction),
+ }
+ _vp = validate_zoom_params(_raw_zoom)
+
+ # Вытаскиваем extra_keys (они не идут в validate_zoom_params напрямую)
+ _extra = {}
+ for _k in ['spiral_rotation', 'spiral_direction',
+ 'gradient_center_x', 'gradient_center_y', 'gradient_radius',
+ 'noise_scale', 'noise_octaves']:
+ if _k in _vp:
+ _extra[_k] = _vp.pop(_k)
+ # zoom_force_original_size: legacy-param из conv-path эпохи.
+ # Latent-path zoom всегда сохраняет [B,C,H,W], флаг больше не нужен.
+ # Оставлен в сигнатуре для обратной совместимости с сохранёнными preset-ами.
+ _extra['fade_to_black'] = bool(zoom_fade_to_black)
+ _extra['fade_strength'] = float(zoom_fade_strength)
+
+ _zoom_prevalidated = _vp
+ _zoom_extra_prevalidated = _extra
+ print("✓ Zoom params pre-validated (will reuse for all conv layers)")
+
+ except Exception as _e:
+ print(f"⚠ Zoom pre-validation failed: {_e} — disabling zoom")
+ use_zoom = False # отключаем zoom если валидация упала
+
+ # ── Сохраняем zoom-параметры для denoise_callback (latent-path) ──────
+ # Zoom живёт в denoise_callback → режимы: once at step 0, once at custom fraction,
+ # или animated range (per-step с easing и from_origin).
+ # Сохраняем ВСЕ параметры, чтобы роутер мог выбирать backend и передавать
+ # нужные аргументы в geometry или canvas backend.
+ # Normalize: strip "[Experimental]" suffix added to Radio labels
+ _zoom_path_raw = str(zoom_path or "Latent")
+ if "Conv" in _zoom_path_raw and "Both" not in _zoom_path_raw:
+ _zoom_path = "Conv"
+ elif "Both" in _zoom_path_raw:
+ _zoom_path = "Both"
+ else:
+ _zoom_path = "Latent"
+ self._latent_zoom_enabled = (
+ bool(use_zoom)
+ and (_zoom_prevalidated is not None)
+ and _zoom_path in ("Latent", "Both")
+ )
+ self._latent_zoom_applied = False
+ self._p_ref = p # для seed lookup в canvas fill
+ # Zoom step control
+ self._latent_zoom_step_control_enabled = bool(zoom_step_control_enabled)
+ self._latent_zoom_apply_mode = str(zoom_apply_mode or "Step 0 (default)")
+ self._latent_zoom_apply_frac = max(0.0, min(1.0, float(zoom_apply_frac or 0.0)))
+ # Animated range — use explicit None-checks: 'x or default' is falsy for 0.0
+ # and would silently replace a valid user value of 0.0 with the non-zero default.
+ _rng_s = max(0.0, min(1.0, float(zoom_range_start_frac if zoom_range_start_frac is not None else 0.0)))
+ _rng_e = max(0.0, min(1.0, float(zoom_range_end_frac if zoom_range_end_frac is not None else 0.35)))
+ if _rng_s > _rng_e:
+ _rng_s, _rng_e = _rng_e, _rng_s
+ self._zoom_range_start_frac = _rng_s
+ self._zoom_range_end_frac = _rng_e
+ self._zoom_factor_start = float(zoom_factor_start if zoom_factor_start is not None else 0.0)
+ self._zoom_factor_end = float(zoom_factor_end if zoom_factor_end is not None else 5.0)
+ self._zoom_easing = str(zoom_easing or "ease_in_out")
+ self._zoom_every_n_steps = max(1, int(zoom_every_n_steps or 1))
+ self._zoom_from_origin = bool(zoom_from_origin if zoom_from_origin is not None else True)
+ self._zoom_lock_after_end = bool(zoom_lock_after_end)
+ self._zoom_origin_tensor = None # stored in denoise_callback at range start
+ self._zoom_origin_stored = False
+
+ # ── Zoom Compose / ROI state ─────────────────────────────────────────
+ self._zoom_compose_mode = str(zoom_compose_mode or "Global")
+ self._roi_shape = str(roi_shape or "ellipse")
+ self._roi_preserve_strength = max(0.0, min(1.0, float(roi_preserve_strength or 1.0)))
+ self._roi_center_x = max(0.0, min(1.0, float(roi_center_x or 0.5)))
+ self._roi_center_y = max(0.0, min(1.0, float(roi_center_y or 0.5)))
+ self._roi_radius_x = max(0.01, min(1.0, float(roi_radius_x or 0.18)))
+ self._roi_radius_y = max(0.01, min(1.0, float(roi_radius_y or 0.18)))
+ self._roi_feather = max(0.0, min(0.5, float(roi_feather or 0.08)))
+ self._roi_fg_zoom_factor = float(roi_fg_zoom_factor or 0.0)
+ self._roi_bg_zoom_factor = float(roi_bg_zoom_factor or 0.0)
+
+ if self._latent_zoom_enabled:
+ _vp_copy = dict(_zoom_prevalidated or {})
+ _ex_copy = dict(_zoom_extra_prevalidated or {})
+ # Используем validate_zoom_params чтобы нормализовать ВСЕ поля сразу,
+ # потом дополняем полями, которые validate не знает (zoom_engine и т.д.)
+ self._latent_zoom_params = validate_zoom_params({
+ 'zoom_engine': str(zoom_engine) if zoom_engine else "auto",
+ 'zoom_factor': float(_vp_copy.get('zoom_factor', zoom_factor)),
+ 'zoom_mode': zoom_mode,
+ 'blend_mode': blend_mode_type,
+ 'convergence_point': float(_vp_copy.get('convergence_point', zoom_convergence)),
+ 'convergence_y': float(_vp_copy.get('convergence_y', 0.5)),
+ 'depth_power': float(_vp_copy.get('depth_power', zoom_depth_power)),
+ 'pan_x': float(_vp_copy.get('pan_x', zoom_pan_x)),
+ 'pan_y': float(_vp_copy.get('pan_y', zoom_pan_y)),
+ 'noise_strength': float(_vp_copy.get('noise_strength', noise_strength)),
+ 'interp_mode': str(_vp_copy.get('interp_mode', interp_mode)),
+ 'edge_fade': bool(_vp_copy.get('edge_fade', _vp_copy.get('zoom_in_fade', edge_fade))),
+ 'variance_correction': bool(_vp_copy.get('variance_correction',variance_correction)),
+ 'auto_clamp_pan': bool(_vp_copy.get('auto_clamp_pan', auto_clamp_pan)),
+ 'adaptive_noise_scale':bool(_vp_copy.get('adaptive_noise_scale',adaptive_noise_scale)),
+ 'debug_mode': bool(_vp_copy.get('debug_mode', debug_mode)),
+ 'zoom_fade_to_black': bool(_vp_copy.get('zoom_fade_to_black', zoom_fade_to_black)),
+ 'zoom_fade_strength': float(_vp_copy.get('zoom_fade_strength',zoom_fade_strength)),
+ 'spiral_rotation': float(_ex_copy.get('spiral_rotation', spiral_rotation)),
+ 'spiral_direction': coerce_spiral_direction(_ex_copy.get('spiral_direction', spiral_direction)),
+ 'gradient_center_x': float(_ex_copy.get('gradient_center_x', 0.5)),
+ 'gradient_center_y': float(_ex_copy.get('gradient_center_y', 0.5)),
+ 'gradient_radius': float(_ex_copy.get('gradient_radius', 1.0)),
+ 'noise_scale': float(_ex_copy.get('noise_scale', 5.0)),
+ 'noise_octaves': int(_ex_copy.get('noise_octaves', 2)),
+ })
+ _backend = resolve_zoom_backend(
+ str(zoom_mode), self._latent_zoom_params.get('zoom_engine', 'auto')
+ )
+ print(f"✓ Latent zoom stored for callback "
+ f"(factor={self._latent_zoom_params.get('zoom_factor', 0):.3f}, "
+ f"mode={zoom_mode}, backend={_backend})")
+ else:
+ self._latent_zoom_params = None
+
+ # ── Export Zoom Step Control metadata to infotext ────────────────────
+ try:
+ if bool(use_zoom):
+ p.extra_generation_params["Zoom Path"] = _zoom_path
+ if self._latent_zoom_enabled:
+ p.extra_generation_params["Latent Zoom"] = "Enabled"
+ if self._latent_zoom_step_control_enabled:
+ p.extra_generation_params["Zoom Step Control"] = True
+ p.extra_generation_params["Zoom Apply Mode"] = self._latent_zoom_apply_mode
+ if self._latent_zoom_apply_mode == "Custom fraction":
+ p.extra_generation_params["Zoom Apply Fraction"] = round(self._latent_zoom_apply_frac, 3)
+ elif self._latent_zoom_apply_mode == "Animated range":
+ p.extra_generation_params["Zoom Range Start"] = round(self._zoom_range_start_frac, 3)
+ p.extra_generation_params["Zoom Range End"] = round(self._zoom_range_end_frac, 3)
+ p.extra_generation_params["Zoom Factor Start"] = round(self._zoom_factor_start, 2)
+ p.extra_generation_params["Zoom Factor End"] = round(self._zoom_factor_end, 2)
+ p.extra_generation_params["Zoom Easing"] = self._zoom_easing
+ p.extra_generation_params["Zoom Every N Steps"] = self._zoom_every_n_steps
+ p.extra_generation_params["Zoom From Origin"] = self._zoom_from_origin
+ # Canvas backend warning in metadata
+ _zp_meta = dict(self._latent_zoom_params or {})
+ _zm_meta = str(_zp_meta.get("zoom_mode", "grid_warp"))
+ _be_meta = resolve_zoom_backend(
+ _zm_meta, _zp_meta.get("zoom_engine", "auto"))
+ if _be_meta != ZOOM_BACKEND_GEOMETRY:
+ p.extra_generation_params["Zoom Range Warning"] = (
+ "canvas backend + animated range: noisy mid-step fill; "
+ "use geometry backend (grid_warp/spiral_zoom/convergence_shift)"
+ )
+ except Exception:
+ pass # metadata export never breaks generation
+
+ # ── Conv-path zoom metadata ───────────────────────────────────────────
+ try:
+ if bool(use_zoom) and _zoom_path in ("Conv", "Both"):
+ p.extra_generation_params["Conv Zoom"] = "Enabled"
+ p.extra_generation_params["Conv Zoom Scale"] = round(
+ max(0.05, min(10.0, 1.0 + float(zoom_factor) * 0.1)), 4)
+ p.extra_generation_params["Conv Zoom Strength"] = float(conv_zoom_strength or 0.5)
+ except Exception:
+ pass
+
+ # ── Zoom Compose / ROI metadata ───────────────────────────────────────
+ try:
+ if (
+ bool(use_zoom)
+ and getattr(self, "_latent_zoom_enabled", False)
+ and _zoom_path in ("Latent", "Both")
+ and self._zoom_compose_mode != "Global"
+ ):
+ p.extra_generation_params["Zoom Compose Mode"] = self._zoom_compose_mode
+ p.extra_generation_params["ROI Shape"] = self._roi_shape
+ p.extra_generation_params["ROI Center X"] = round(self._roi_center_x, 3)
+ p.extra_generation_params["ROI Center Y"] = round(self._roi_center_y, 3)
+ p.extra_generation_params["ROI Radius X"] = round(self._roi_radius_x, 3)
+ p.extra_generation_params["ROI Radius Y"] = round(self._roi_radius_y, 3)
+ p.extra_generation_params["ROI Feather"] = round(self._roi_feather, 3)
+ if self._zoom_compose_mode == "Pinned Subject":
+ p.extra_generation_params["ROI Preserve Strength"] = round(self._roi_preserve_strength, 3)
+ elif self._zoom_compose_mode == "Dual-Transform ROI":
+ p.extra_generation_params["ROI FG Zoom Factor"] = round(self._roi_fg_zoom_factor, 2)
+ p.extra_generation_params["ROI BG Zoom Factor"] = round(self._roi_bg_zoom_factor, 2)
+ except Exception:
+ pass
+
+ params = {
+ 'mode_x': mode_x,
+ 'mode_y': mode_y,
+ 'start_step': start_step,
+ 'end_step': end_step,
+ 'tiling_lock_after_end': bool(tiling_lock_after_end),
+ 'tiling_pan_one_shot': bool(tiling_pan_one_shot),
+ 'multires_enabled': multires,
+ 'multires_strategy': multires_strategy, # NEW
+ 'multires_start': multires_start, # NEW
+ 'multires_end': multires_end, # NEW
+ 'multires_sharpness': multires_sharpness, # NEW
+ # NEW ENHANCED MODES parameters
+ 'voronoi_cells': voronoi_cells,
+ 'voronoi_seed': voronoi_seed,
+ 'perlin_strength': perlin_strength,
+ 'perlin_scale': perlin_scale,
+ 'fractal_iterations': fractal_iterations,
+ 'fractal_scale': fractal_scale,
+ 'adaptive_threshold': adaptive_threshold,
+ 'panorama_engine': panorama_engine,
+ 'panorama_yaw': panorama_yaw,
+ 'panorama_pitch': panorama_pitch,
+ 'panorama_roll': panorama_roll,
+ 'panorama_coord_mode': panorama_coord_mode,
+ 'panorama_polar_scale': panorama_polar_scale,
+ 'panorama_polar_power': panorama_polar_power,
+ 'panorama_twist_deg': panorama_twist_deg,
+ 'panorama_twist_power': panorama_twist_power,
+ 'panorama_swirl_deg': panorama_swirl_deg,
+ 'panorama_swirl_power': panorama_swirl_power,
+ 'panorama_pole_ease_power': panorama_pole_ease_power,
+ 'panorama_antipode_strength': panorama_antipode_strength,
+ 'panorama_pole_blur_strength': panorama_pole_blur_strength,
+ 'panorama_pole_blur_radius': panorama_pole_blur_radius,
+ 'panorama_pole_blur_power': panorama_pole_blur_power,
+ 'panorama_geoaa_samples': panorama_geoaa_samples,
+ 'panorama_geoaa_radius_px': panorama_geoaa_radius,
+ 'panorama_grid_interp': panorama_grid_interp,
+ 'panorama_grid_padding': panorama_grid_padding,
+ 'panorama_cache_angle_quant': panorama_cache_angle_quant,
+ 'blend_enabled': use_blend,
+ 'blend_strength': blend_strength,
+ 'blend_falloff': blend_falloff, # NEW
+ 'blend_sharpness': blend_sharpness, # NEW
+ 'blend_width': blend_width if blend_width > 0 else None, # NEW
+ 'use_zoom': False, # latent-path zoom lives in denoise_callback
+ # ── Conv-path zoom ──────────────────────────────────────────────
+ # scale+crop applied inside patched_forward per-conv, stage-weighted.
+ # Only active when zoom_path == "Conv" or "Both".
+ 'conv_zoom_enabled': bool(use_zoom) and (_zoom_path in ("Conv", "Both")),
+ 'conv_zoom_scale': max(0.05, min(10.0, 1.0 + float(zoom_factor) * 0.1)),
+ 'conv_zoom_strength': max(0.0, min(1.0, float(conv_zoom_strength or 0.5))),
+ # Conv zoom respects Zoom Step Control range (not just tiling range).
+ # If step control is disabled, conv uses tiling start/end_step via fallback.
+ 'conv_zoom_start_step': (
+ int(round((max(int(p.steps or 1), 1) - 1) * float(zoom_range_start_frac if zoom_range_start_frac is not None else 0.0)))
+ if (bool(zoom_step_control_enabled) and str(zoom_apply_mode or "") == "Animated range")
+ else int(start_step)
+ ),
+ 'conv_zoom_end_step': (
+ int(round((max(int(p.steps or 1), 1) - 1) * float(zoom_range_end_frac if zoom_range_end_frac is not None else 0.35)))
+ if (bool(zoom_step_control_enabled) and str(zoom_apply_mode or "") == "Animated range")
+ else int(end_step)
+ ),
+ 'zoom_factor': zoom_factor,
+ 'zoom_mode': zoom_mode,
+ 'blend_mode_type': blend_mode_type,
+ 'noise_strength': noise_strength,
+ 'zoom_pan_x': zoom_pan_x,
+ 'zoom_pan_y': zoom_pan_y,
+ 'spiral_rotation': spiral_rotation,
+ 'spiral_direction': spiral_direction,
+ 'interp_mode': interp_mode,
+ 'edge_fade': edge_fade, # legacy key kept for old tiling-params context
+ 'variance_correction': variance_correction,
+ 'auto_clamp_pan': auto_clamp_pan,
+ 'adaptive_noise_scale': adaptive_noise_scale,
+ 'debug_mode': debug_mode,
+ 'zoom_convergence': zoom_convergence,
+ 'zoom_depth_power': zoom_depth_power,
+ 'zoom_force_original_size': zoom_force_original_size,
+ 'zoom_fade_to_black': zoom_fade_to_black,
+ 'zoom_fade_strength': zoom_fade_strength,
+ '_zoom_prevalidated': _zoom_prevalidated,
+ '_zoom_extra_prevalidated': _zoom_extra_prevalidated,
+ 'cubemap_engine': cubemap_engine,
+ 'cubemap_pad_mode': cubemap_pad_mode,
+ 'cubemap_blend_width': cubemap_blend_width,
+ 'cubemap_blend_strength': cubemap_blend_strength,
+ 'cubemap_yaw': cubemap_yaw,
+ 'cubemap_pitch': cubemap_pitch,
+ 'cubemap_roll': cubemap_roll,
+ 'cubemap_coord_mode': cubemap_coord_mode,
+ 'cubemap_twist_deg': cubemap_twist_deg,
+ 'cubemap_polar_scale': cubemap_polar_scale,
+ 'cubemap_polar_power': cubemap_polar_power,
+ 'cubemap_swirl_deg': cubemap_swirl_deg,
+ 'cubemap_swirl_power': cubemap_swirl_power,
+ 'cubemap_grid_interp': cubemap_grid_interp,
+ 'cubemap_grid_padding': cubemap_grid_padding,
+ 'cubemap_cache_angle_quant': cubemap_cache_angle_quant,
+ 'cubemap_geoaa_samples': cubemap_geoaa_samples,
+ 'cubemap_geoaa_radius_px': cubemap_geoaa_radius,
+ 'cubemap_antipode_strength': cubemap_antipode_strength,
+ 'anisotropic_angle': aniso_angle,
+ 'anisotropic_angle2': (aniso_angle2 if (use_anisotropic and aniso_angle_mix < 1.0) else None),
+ 'anisotropic_angle_mix': aniso_angle_mix,
+ 'stereo_enabled': stereo_enabled,
+ 'stereo_eye': stereo_eye,
+ 'stereo_engine': stereo_engine,
+ 'stereo_output': stereo_output,
+ 'stereo_in_model': stereo_in_model,
+ 'stereo_separation': stereo_separation,
+ 'stereo_convergence': stereo_convergence,
+ 'stereo_depth_power': stereo_depth_power,
+ 'stereo_pole_power': stereo_pole_power,
+ 'tiling_disable_hr': tiling_disable_hr,
+ 'pan_x': float(zoom_pan_x or 0.0),
+ 'pan_y': float(zoom_pan_y or 0.0),
+ 'script_ref': self,
+ }
+
+
+ # Save stereo settings for postprocess
+ try:
+ self._stereo_settings = {
+ 'enabled': bool(stereo_enabled),
+ 'eye': str(stereo_eye),
+ 'engine': str(stereo_engine),
+ 'output': str(stereo_output),
+ 'separation': float(stereo_separation),
+ 'convergence': float(stereo_convergence),
+ 'depth_power': float(stereo_depth_power),
+ 'pole_power': float(stereo_pole_power),
+ }
+ except Exception:
+ self._stereo_settings = {'enabled': False}
+
+ # Патчинг UNet
+ unet = self.get_unet(p)
+ if unet:
+ self.restore_original(unet)
+ count_unet = self.patch_conv_layers(unet, params)
+ print(f"✓ Patched {count_unet} UNet Conv2d layers")
+
+ # Патчинг VAE (Safe / Strict mode)
+ vae_mode = str(patch_vae) if patch_vae else "Off"
+ if vae_mode != "Off" and hasattr(p.sd_model, 'first_stage_model'):
+ vae = p.sd_model.first_stage_model
+ count_vae = self.patch_vae_layers(vae, params, mode=vae_mode)
+ if count_vae > 0:
+ print(f"✓ Patched {count_vae} VAE Conv2d layers ({vae_mode} mode)")
+ else:
+ print(f"⚠ VAE patching ({vae_mode}): no layers patched (all filtered or model structure unknown)")
+
+ mode_str = f"{mode_x}/{mode_y}"
+ if stereo_enabled:
+ mode_str += f" + Stereo({stereo_eye})"
+ if use_blend:
+ mode_str += " + Blend"
+ if use_kohaku:
+ mode_str += " + Kohaku"
+ if enable_mirroring and (mirror_mode != 0 or x_pan != 0 or y_pan != 0):
+ mode_str += " + LatentMirror"
+
+ print(f"✓ Advanced Tiling v3.0: Mode={mode_str}, Steps={start_step}-{end_step}")
+
+ # ====== ПАТЧИНГ СЛОЁВ ======
+
+ def get_unet(self, p):
+ """
+ Universal UNet accessor.
+ Supports Forge (forge_objects.unet), standard A1111
+ (model.diffusion_model) and bare fallback.
+ """
+ if hasattr(p.sd_model, 'forge_objects') and hasattr(p.sd_model.forge_objects, 'unet'):
+ return p.sd_model.forge_objects.unet
+ elif hasattr(p.sd_model, 'model') and hasattr(p.sd_model.model, 'diffusion_model'):
+ return p.sd_model.model.diffusion_model
+ return p.sd_model
+
+ def patch_conv_layers(self, module, params):
+ """
+ Патчинг сверточных слоев с защитой от сбоев (Safe Patching).
+ УЛУЧШЕНО: игнорируем критичные слои в ResNet блоках для избежания ошибок размеров
+ FIX для: RuntimeError: The size of tensor a must match the size of tensor b
+ """
+ count = 0
+ for name, layer in module.named_modules(): # ← используем named_modules для доступа к именам
+ # 1. Пропускаем всё, что не является сверткой (Conv2d)
+ if not isinstance(layer, torch.nn.Conv2d):
+ continue
+
+ # 2. Пропускаем слои 1x1 (они меняют каналы, а не геометрию, тайлинг им не нужен)
+ if layer.kernel_size == (1, 1) or layer.kernel_size == 1:
+ continue
+
+ # ✅ НОВАЯ ЗАЩИТА #1: пропускаем ResNet skip connections
+ # Они критичны для точного совпадения размеров с основной веткой
+ if 'skip_connection' in name.lower() or 'shortcut' in name.lower():
+ continue
+
+ # ✅ НОВАЯ ЗАЩИТА #2: пропускаем критичные блоки VAE decoder
+ # Эти блоки особенно чувствительны к изменениям размеров
+ if 'mid.block' in name or 'decoder.mid' in name:
+ continue
+
+ # 3. Сохраняем оригинал (если еще не сохранили)
+ if layer not in _ORIGINAL_METHODS_CACHE:
+ _ORIGINAL_METHODS_CACHE[layer] = layer._conv_forward
+
+ # === ФУНКЦИЯ-ОБЕРТКА (ЗАМЫКАНИЕ) ===
+ # ИСПРАВЛЕНИЕ late-binding bug: layer и его атрибуты захватываем
+ # как дефолтные аргументы — иначе patched_forward во всех слоях
+ # будет брать stride/padding от ПОСЛЕДНЕГО слоя цикла.
+ def make_patched_method(mod, original_method_ref, layer_name=name):
+ # mod захвачен как аргумент → каждое замыкание держит
+ # собственную ссылку на конкретный Conv2d слой.
+ _stride = mod.stride
+ _padding = mod.padding
+ _dilation = mod.dilation
+ _groups = mod.groups
+ def patched_forward(input_tensor, weight, bias):
+ # ── Conv-path zoom (stage-weighted, N-th root compensated) ─
+ # Compensation: eff_per_conv = target^(stage_w*strength/N_layers)
+ # so that product over all N_layers convs = target_scale exactly.
+ # N_INPUT≈30, N_MID≈3, N_OUT≈30 for SD 1.x
+ # zoom-out (eff<1.0): gentle low-pass — content softens.
+ if params.get('conv_zoom_enabled') and input_tensor is not None:
+ try:
+ _cz_step = (getattr(shared.state, 'sampling_step', 0)
+ if 'shared' in dir() else 0)
+ _cz_s = int(params.get('conv_zoom_start_step', params.get('start_step', 0)))
+ _cz_e = int(params.get('conv_zoom_end_step', params.get('end_step', 9999)))
+ if _cz_s <= _cz_step < _cz_e:
+ _cz_scale = float(params.get('conv_zoom_scale', 1.0))
+ _cz_strength = float(params.get('conv_zoom_strength', 0.5))
+ # Stage weights and estimated layer counts
+ if 'middle_block' in layer_name:
+ _stage_w = 1.0; _n = 3
+ elif 'input_blocks' in layer_name:
+ _stage_w = 0.4; _n = 30
+ elif 'output_blocks' in layer_name:
+ _stage_w = 0.3; _n = 30
+ else:
+ _stage_w = 0.0; _n = 1
+ # N-th root compensation: each conv contributes
+ # scale^(stage_w*strength/N) so total = scale^(stage_w*strength)
+ _exp = _stage_w * _cz_strength / max(_n, 1)
+ _eff = (_cz_scale ** _exp) if _cz_scale > 0 else 1.0
+ if abs(_eff - 1.0) > 1e-5 and input_tensor.ndim == 4:
+ _b, _c, _h, _w = input_tensor.shape
+ _scaled = F.interpolate(
+ input_tensor.float(), scale_factor=_eff,
+ mode='bilinear', align_corners=False
+ ).to(input_tensor.dtype)
+ if _eff > 1.0:
+ # zoom IN: crop center back to _h×_w
+ _dh = (_scaled.shape[2] - _h) // 2
+ _dw = (_scaled.shape[3] - _w) // 2
+ input_tensor = _scaled[
+ :, :, _dh:_dh+_h, _dw:_dw+_w
+ ].contiguous()
+ else:
+ # zoom OUT: upscale small→_h×_w (low-pass effect)
+ input_tensor = F.interpolate(
+ _scaled, size=(_h, _w),
+ mode='bilinear', align_corners=False
+ )
+ except Exception:
+ pass # conv zoom never breaks tiling
+ # ─────────────────────────────────────────────────────────
+ try:
+ # ПОПЫТКА: Запускаем твой кастомный тайлинг
+ return custom_padding_forward(
+ input_tensor, weight, bias,
+ _stride, _padding, _dilation, _groups,
+ params
+ )
+ except RuntimeError as e:
+ # ЕСЛИ ОШИБКА размеров тензоров:
+ # Логируем для отладки и выполняем оригинальный метод
+ if "size of tensor" in str(e).lower():
+ print(f"⚠ Tiling skip ({layer_name}): {str(e)[:80]}")
+ return original_method_ref(input_tensor, weight, bias)
+ except Exception:
+ # Любая другая ошибка - также откатываемся
+ return original_method_ref(input_tensor, weight, bias)
+ return patched_forward
+ # ===================================
+
+ # 4. Подменяем метод
+ layer._conv_forward = make_patched_method(
+ layer, _ORIGINAL_METHODS_CACHE[layer], name
+ )
+ count += 1
+
+ return count
+
+ def patch_vae_layers(self, module, params, mode="Safe"):
+ """
+ Safe VAE patching with mode-specific layer filtering.
+
+ mode="Safe"
+ Patches most VAE Conv2d layers. Skips:
+ - 1×1 kernels (channel-only transforms)
+ - ResNet skip/shortcut connections
+ - All decoder mid-blocks (most sensitive to size mismatches)
+ - Decoder upsample residual paths
+ Every patched layer still has a per-forward try/except fallback
+ to the original method, so a size mismatch never crashes the run.
+
+ mode="Strict"
+ Only patches encoder layers (name contains 'encoder').
+ Decoder is left completely untouched — safest option for models
+ that have unusual decoder skip-connection shapes.
+ """
+ # VAE-specific skip patterns (decoder paths most prone to size mismatches)
+ VAE_SKIP_PATTERNS = (
+ 'skip_connection', 'shortcut', # ResNet skip branches
+ 'mid.block', 'decoder.mid', # mid-blocks (already in base method)
+ 'decoder.up', # upsample blocks in decoder
+ 'decoder.norm_out', # final norm before pixel out
+ 'attn', # attention projections (qkv/proj)
+ )
+
+ count = 0
+ for name, layer in module.named_modules():
+ if not isinstance(layer, torch.nn.Conv2d):
+ continue
+ if layer.kernel_size == (1, 1) or layer.kernel_size == 1:
+ continue
+
+ name_lower = name.lower()
+
+ # Strict: only encoder layers
+ if mode == "Strict":
+ if 'encoder' not in name_lower:
+ continue
+
+ # Safe: skip decoder-specific sensitive paths
+ if any(pat in name_lower for pat in VAE_SKIP_PATTERNS):
+ continue
+
+ if layer not in _ORIGINAL_METHODS_CACHE:
+ _ORIGINAL_METHODS_CACHE[layer] = layer._conv_forward
+
+ def make_patched_method(mod, original_method_ref, layer_name=name):
+ _stride = mod.stride
+ _padding = mod.padding
+ _dilation = mod.dilation
+ _groups = mod.groups
+ def patched_forward(input_tensor, weight, bias):
+ try:
+ return custom_padding_forward(
+ input_tensor, weight, bias,
+ _stride, _padding, _dilation, _groups,
+ params
+ )
+ except RuntimeError as e:
+ if "size of tensor" in str(e).lower():
+ print(f"⚠ VAE tiling skip ({layer_name}): {str(e)[:80]}")
+ return original_method_ref(input_tensor, weight, bias)
+ except Exception:
+ return original_method_ref(input_tensor, weight, bias)
+ return patched_forward
+
+ layer._conv_forward = make_patched_method(
+ layer, _ORIGINAL_METHODS_CACHE[layer], name
+ )
+ count += 1
+
+ return count
+ """Универсальная детекция UNet"""
+ if hasattr(p.sd_model, 'forge_objects') and hasattr(p.sd_model.forge_objects, 'unet'):
+ return p.sd_model.forge_objects.unet
+ elif hasattr(p.sd_model, 'model') and hasattr(p.sd_model.model, 'diffusion_model'):
+ return p.sd_model.model.diffusion_model
+ return p.sd_model
+
+ def postprocess(self, p, processed, *args):
+ """Восстановление"""
+ unet = self.get_unet(p)
+ if unet:
+ self.restore_original(unet)
+
+ if hasattr(p.sd_model, 'first_stage_model'):
+ self.restore_original(p.sd_model.first_stage_model)
+
+
+ # Stereo postprocess output formatting (Side-by-Side by default)
+ try:
+ st = getattr(self, "_stereo_settings", None)
+ if st and st.get("enabled", False):
+ out_mode = str(st.get("output", "Side-by-Side"))
+ imgs = list(getattr(processed, "images", []) or [])
+ infotexts = getattr(processed, "infotexts", None)
+
+ new_imgs = []
+ new_infos = [] if infotexts is not None else None
+
+ for idx_img, im in enumerate(imgs):
+ left, right = _make_stereo_outputs(im, st)
+
+ if out_mode == "Side-by-Side":
+ sbs = Image.new("RGB", (left.width + right.width, left.height))
+ sbs.paste(left, (0, 0))
+ sbs.paste(right, (left.width, 0))
+ new_imgs.append(sbs)
+ if new_infos is not None:
+ new_infos.append(infotexts[idx_img] if idx_img < len(infotexts) else "")
+ elif out_mode == "Left only":
+ new_imgs.append(left)
+ if new_infos is not None:
+ new_infos.append(infotexts[idx_img] if idx_img < len(infotexts) else "")
+ elif out_mode == "Right only":
+ new_imgs.append(right)
+ if new_infos is not None:
+ new_infos.append(infotexts[idx_img] if idx_img < len(infotexts) else "")
+ else:
+ # Both separate
+ new_imgs.extend([left, right])
+ if new_infos is not None:
+ base = infotexts[idx_img] if idx_img < len(infotexts) else ""
+ new_infos.extend([base + " | Stereo: left", base + " | Stereo: right"])
+
+ processed.images = new_imgs
+ if new_infos is not None:
+ processed.infotexts = new_infos
+ except Exception as e:
+ print(f"[Advanced Asymmetric Tiling] Stereo postprocess error: {e}")
+
+ self._stereo_settings = None
+ # Отключаем латентный миррор до следующего запуска
+ self.run_callback = False
+ self.tiling_is_hires = False
+ # Сбрасываем latent zoom state
+ self._latent_zoom_enabled = False
+ self._latent_zoom_applied = False
+ self._latent_zoom_params = None
+ self._latent_zoom_step_control_enabled = False
+ self._latent_zoom_apply_mode = "Step 0 (default)"
+ self._latent_zoom_apply_frac = 0.0
+ # Animated range state
+ self._zoom_origin_tensor = None
+ self._zoom_origin_stored = False
+ self._zoom_canvas_warned = False
+ self._zoom_range_finished_once = False # 🔒 one-pass guard reset
+ # Tiling one-shot pan reset
+ self._tiling_pan_one_shot_done = False
+ # Compose / ROI state reset
+ self._zoom_compose_mode = "Global"
+ self._roi_shape = "ellipse"
+ self._roi_preserve_strength = 1.0
+ self._roi_center_x = 0.5
+ self._roi_center_y = 0.5
+ self._roi_radius_x = 0.18
+ self._roi_radius_y = 0.18
+ self._roi_feather = 0.08
+ self._roi_fg_zoom_factor = 0.0
+ self._roi_bg_zoom_factor = 0.0
+ # Сбрасываем флаг per-step latent эффектов
+ self._run_latent_effects = False
+ # Сбрасываем advanced pan state
+ self._pan_applied = False
+ self._pan_locked = False
+
+ def restore_original(self, module):
+ """Восстановление оригинальных методов"""
+ if not _ORIGINAL_METHODS_CACHE:
+ return
+
+ restored = 0
+ for layer in list(_ORIGINAL_METHODS_CACHE.keys()):
+ if hasattr(layer, '_conv_forward'):
+ layer._conv_forward = _ORIGINAL_METHODS_CACHE[layer]
+ restored += 1
+
+ _ORIGINAL_METHODS_CACHE.clear()
+ _MASK_CACHE.clear()
+ _CUBEMAP_GRID_CACHE.clear()
+ _PANO_GRID_CACHE.clear()
+
+ if restored > 0:
+ print(f"✓ Restored {restored} layers to original state")