Upload advanced_zoom_extension__FINAL_FIX (3).py

asymmetric-tiling-sd-webui-2.0/scripts/advanced_zoom_extension__FINAL_FIX (3).py

@@ -0,0 +1,1211 @@
+"""
+╔══════════════════════════════════════════════════════════════════════════════╗
+║     ADVANCED ZOOM SYSTEM V3.2.1 - ФИНАЛЬНОЕ ИСПРАВЛЕНИЕ!                    ║
+║          ПРОСТОЕ И НАДЕЖНОЕ РЕШЕНИЕ - БЕЗ БАГОВ!                            ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+
+КРИТИЧЕСКОЕ ИСПРАВЛЕНИЕ (V3.2.0 → V3.2.1):
+✅ УПРОЩЕННОЕ РЕШЕНИЕ - убрана вся сложная логика!
+   - Проблема V3.2.0: expand_as вызывал ошибки размеров тензоров
+   - Решение V3.2.1: прямой F.pad() БЕЗ сложного позиционирования
+   - Результат: работает СТАБИЛЬНО без expand errors!
+
+✅ УБРАНЫ ПРОБЛЕМНЫЕ ЧАСТИ:
+   - ❌ Убран create_adaptive_latent_noise (причина шума)
+   - ❌ Убрана сложная логика convergence/paste позиционирования
+   - ❌ Убран expand_as (причина size mismatch errors)
+   - ✅ Оставлен только простой F.pad() + broadcasting
+
+БЫЛО (V3.2.0 - БАГИ):
+❌ Zoom Out → padding → fade_mask.expand_as(canvas) → 
+   → "expanded size must match" ERROR!
+
+СТАЛО (V3.2.1 - БЕЗ БАГОВ):
+✅ Zoom Out → F.pad(content_small) → прямой broadcasting →
+   → РАБОТАЕТ СТАБИЛЬНО!
+
+ИСПРАВЛЕНИЯ (V3.1.2 → V3.2.1):
+✅ DTYPE MISMATCH FIX - убрана конверсия в float32 из safe_interpolate
+   - Проблема: "Input type (float) and bias type (c10::Half)" 
+   - Решение: работаем напрямую с исходным dtype (float16)
+   - F.interpolate нативно поддерживает float16 без overflow
+
+✅ EXPAND DIAGNOSTICS - детальная диагностика для ошибок expand
+   - Добавлены warning-и при несовпадении размеров
+   - Проверка размеров в create_distance_map перед кэшированием
+   - Детальный лог в create_adaptive_latent_noise
+
+✅ PARAMETER VALIDATION - проверка входных параметров
+   - Валидация padding в apply_outpaint_zoom
+   - Проверка размеров перед всеми expand операциями
+   - Безопасный fallback через broadcast_to
+
+ИСПРАВЛЕННЫЕ ПРОБЛЕМЫ (V3.1.2):
+🐛 Input type (float) and bias type (c10::Half) → FIXED (убрана конверсия)
+🐛 Expand size mismatch errors → DIAGNOSED (добавлена диагностика)
+🐛 Кэш возвращает неправильные размеры → VALIDATED (проверка перед return)
+
+КРИТИЧНЫЕ ИСПРАВЛЕНИЯ (V3.1 → V3.1.1):
+✅ FLOAT16 EPSILON FIX - адаптивный epsilon (1e-3 для float16, 1e-6 для float32)
+✅ EDGE_SMOOTHING FIX - правильный expand до (b,c,H,W) вместо (b,c,1,W)
+✅ SAFE_INTERPOLATE - функция для безопасной интерполяции
+✅ ALIGN_CORNERS FIX - правильная обработка без None
+✅ VARIANCE_CORRECTION - адаптивный epsilon + надежный broadcast
+✅ SPIRAL_ZOOM - адаптивный epsilon для всех sqrt/division
+✅ NOISE_BLEND - адаптивный epsilon + оптимизированная формула
+✅ EXTRA_PARAMS - правильная передача параметров в gradient_radial/noise_blend
+✅ DIVISION BY ZERO - защита во всех критичных местах
+
+ИСПРАВЛЕНИЯ (V3.0 → V3.1 COMPLETE):
+✅ QUANTILE FIX - правильная обработка dtype + умное сэмплирование (>10M)
+✅ TENSOR SIZE FIX - исправлена ошибка "expanded size must match existing size"
+✅ SPIRAL ZOOM - полная реализация без багов + валидация параметров
+✅ GRADIENT_RADIAL - новый режим блендинга с радиальным градиентом
+✅ NOISE_BLEND - новый режим блендинга с процедурным шумом
+✅ WARNINGS - всегда видны, детальная диагностика
+✅ SHAPE VALIDATION - проверка размеров на каждом шаге
+✅ ПОЛНАЯ ИНТЕГРАЦИЯ с asymmetric_tiling_UNIFIED (15).py
+
+НОВЫЕ ФУНКЦИИ (V3.1.2):
+🆕 Детальная диагностика expand errors
+🆕 Валидация параметров в apply_outpaint_zoom
+🆕 Проверка размеров distance_map перед кэшированием
+
+НОВЫЕ ФУНКЦИИ (V3.1.1):
+🆕 get_adaptive_epsilon(dtype) - автоматический выбор epsilon
+🆕 safe_interpolate() - безопасная интерполяция
+
+НОВЫЕ РЕЖИМЫ (V3.1):
+🆕 SPIRAL_ZOOM - спиральный зум с вращением
+🆕 GRADIENT_RADIAL - радиальный градиент для плавных переходов
+🆕 NOISE_BLEND - процедурный шум для органичных границ
+
+СОВМЕСТИМОСТЬ:
+✅ Полная интеграция с asymmetric_tiling_UNIFIED (15).py
+✅ Поддержка всех параметров из V3.0
+✅ Обратная совместимость со всеми режимами
+✅ extra_params поддержка для расширяемости
+✅ FLOAT16 СОВМЕСТИМОСТЬ - все критичные исправления применены
+✅ RUNTIME ERROR HANDLING - детальная диагностика и fallback
+
+ПРОИЗВОДИТЕЛЬНОСТЬ (V3.1.2):
+⚡ Умное кэширование (distance maps, noise patterns)
+⚡ Сэмплирование только для огромных тензоров (>10M элементов)
+⚡ Оптимизированные математические операции
+⚡ Минимальное использование памяти
+⚡ Безопасная работа с float16 без overflow/underflow
+⚡ Детальная диагностика для отладки
+"""
+
+import torch
+import torch.nn.functional as F
+import math
+from enum import Enum
+from collections import OrderedDict
+
+# ═══════════════════════════════════════════════════════════════════════════
+# УТИЛИТА ДЛЯ FLOAT16 СОВМЕСТИМОСТИ (V3.1.1 - НОВОЕ)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def get_adaptive_epsilon(dtype):
+    """
+    Возвращает подходящий epsilon для данного dtype.
+    
+    V3.1.1: КРИТИЧНОЕ ДЛЯ FLOAT16
+    Float16 имеет минимальное значение ~6e-5, поэтому 1e-6 вызывает underflow.
+    
+    Args:
+        dtype: torch.dtype тензора
+    
+    Returns:
+        float: безопасный epsilon для данного типа
+    """
+    if dtype == torch.float16:
+        return 1e-3  # Безопасный epsilon для float16
+    elif dtype == torch.float32:
+        return 1e-6  # Стандартный epsilon для float32
+    else:  # float64
+        return 1e-12  # Высокая точность для float64
+
+# ═══════════════════════════════════════════════════════════════════════════
+# ENUMS
+# ═══════════════════════════════════════════════════════════════════════════
+
+class ZoomMode(Enum):
+    OUTPAINT_ZOOM = "outpaint_zoom"            # Оптимизирован для outpainting (рекомендуется!)
+    BLEND_TRANSITION = "blend_transition"       # Плавный переход с blending
+    CONVERGENCE_SHIFT = "convergence_shift"     # Legacy сдвиг
+    GRID_WARP = "grid_warp"                     # Геометрический zoom
+    HYBRID = "hybrid"                           # Комбинация
+    SPIRAL_ZOOM = "spiral_zoom"                 # 🆕 V3.1: Спиральный zoom с вращением
+
+class BlendMode(Enum):
+    CIRCULAR_REFLECT = "circular_reflect"       # Бесшовный + отражение
+    CIRCULAR_CONSTANT = "circular_constant"     # Бесшовный + константа
+    REFLECT_CONSTANT = "reflect_constant"       # Отражение + константа
+    POLAR_CIRCULAR = "polar_circular"          # Полярное + бесшовный
+    MIRROR_CIRCULAR = "mirror_circular"        # Зеркало + бесшовный
+    ANISO_CIRCULAR = "aniso_circular"          # Анизотропный + бесшовный
+    CUSTOM = "custom"                           # Пользовательский
+    GRADIENT_RADIAL = "gradient_radial"        # 🆕 V3.1: Радиальный градиент
+    NOISE_BLEND = "noise_blend"                # 🆕 V3.1: Блендинг с процедурным шумом
+
+# ═══════════════════════════════════════════���═══════════════════════════════
+# КЭШИРОВАНИЕ (V3.0 - УЛУЧШЕНО)
+# ═══════════════════════════════════════════════════════════════════════════
+
+class DistanceMapCache:
+    """Кэш для distance maps с LRU вытеснением"""
+    def __init__(self, max_size=20):
+        self.cache = OrderedDict()
+        self.max_size = max_size
+    
+    def get(self, key):
+        if key in self.cache:
+            self.cache.move_to_end(key)
+            return self.cache[key]
+        return None
+    
+    def set(self, key, value):
+        if key in self.cache:
+            self.cache.move_to_end(key)
+        else:
+            if len(self.cache) >= self.max_size:
+                self.cache.popitem(last=False)
+            self.cache[key] = value
+
+_DISTANCE_MAP_CACHE = DistanceMapCache()
+
+# ═══════════════════════════════════════════════════════════════════════════
+# УТИЛИТЫ ДЛЯ ЛАТЕНТНОГО ШУМА (V3.0 - УЛУЧШЕНО)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def compute_latent_statistics(input_tensor, percentile_clip=True):
+    """
+    Вычисляет статистику латентов для правильной генерации шума.
+    
+    V3.0: Добавлен percentile_clip для робастности
+    
+    Args:
+        input_tensor: входной тензор латентов
+        percentile_clip: использовать percentile вместо min/max
+    
+    Returns:
+        dict: {'mean': float, 'std': float, 'min': float, 'max': float}
+    """
+    stats = {
+        'mean': input_tensor.mean().item(),
+        'std': input_tensor.std().item(),
+    }
+    
+    if percentile_clip:
+        # V3.1 FIX: Правильная обработка quantile() dtype
+        flat = input_tensor.flatten()
+        
+        # V3.1.1 FIX: Явная конверсия в float32 (вместо неявного .float())
+        if flat.dtype not in [torch.float32, torch.float64]:
+            flat = flat.to(torch.float32)  # Более явный и безопасный вариант
+        
+        # Умное сэмплирование ТОЛЬКО для очень больших тензоров (>10M элементов)
+        if flat.numel() > 10_000_000:
+            indices = torch.randperm(flat.numel(), device=flat.device)[:1_000_000]
+            flat = flat[indices]
+        
+        try:
+            stats['min'] = torch.quantile(flat, 0.01).item()
+            stats['max'] = torch.quantile(flat, 0.99).item()
+        except RuntimeError as e:
+            # Fallback: используем сортировку для робастного percentile
+            sorted_flat = torch.sort(flat)[0]
+            idx_01 = max(0, int(0.01 * len(sorted_flat)))
+            idx_99 = min(len(sorted_flat) - 1, int(0.99 * len(sorted_flat)))
+            stats['min'] = sorted_flat[idx_01].item()
+            stats['max'] = sorted_flat[idx_99].item()
+    else:
+        stats['min'] = input_tensor.min().item()
+        stats['max'] = input_tensor.max().item()
+    
+    return stats
+
+
+def create_distance_map(canvas_h, canvas_w, content_box, device, dtype):
+    """
+    Создает карту расстояний от контента с кэшированием.
+    
+    V3.0: Добавлено кэширование для оптимизации
+    V3.1.2: Добавлена диагностика размеров
+    
+    Args:
+        canvas_h, canvas_w: размеры холста
+        content_box: (y1, y2, x1, x2) где размещен контент
+        
+    Returns:
+        torch.Tensor (1, 1, canvas_h, canvas_w): карта расстояний [0, 1]
+    """
+    # Проверяем кэш
+    cache_key = (canvas_h, canvas_w, content_box, str(device), str(dtype))
+    cached = _DISTANCE_MAP_CACHE.get(cache_key)
+    if cached is not None:
+        # V3.1.2: Проверка размеров из кэша
+        if cached.shape != (1, 1, canvas_h, canvas_w):
+            print(f"⚠️  [Distance Map Cache] Size mismatch! Expected (1,1,{canvas_h},{canvas_w}), got {cached.shape}")
+            # Пересоздаем вместо использования неправильного кэша
+        else:
+            return cached
+    
+    y1, y2, x1, x2 = content_box
+    
+    # Создаем координатные сетки
+    y_coords = torch.arange(canvas_h, device=device, dtype=dtype).view(-1, 1).expand(canvas_h, canvas_w)
+    x_coords = torch.arange(canvas_w, device=device, dtype=dtype).view(1, -1).expand(canvas_h, canvas_w)
+    
+    # Расстояние до ближайшей точки контента
+    dist_y = torch.maximum(
+        torch.clamp(y1 - y_coords, min=0),
+        torch.clamp(y_coords - y2, min=0)
+    )
+    dist_x = torch.maximum(
+        torch.clamp(x1 - x_coords, min=0),
+        torch.clamp(x_coords - x2, min=0)
+    )
+    
+    # Евклидово расстояние
+    distance = torch.sqrt(dist_x ** 2 + dist_y ** 2)
+    
+    # V3.1.1 FIX: Защита от деления на 0 для float16 (было: может быть 0)
+    max_dist = max(math.sqrt(canvas_h**2 + canvas_w**2) * 0.5, get_adaptive_epsilon(dtype))
+    distance_norm = torch.clamp(distance / max_dist, 0, 1)
+    
+    result = distance_norm.unsqueeze(0).unsqueeze(0)
+    
+    # V3.1.2: Финальная проверка размера перед кэшированием
+    expected_shape = (1, 1, canvas_h, canvas_w)
+    if result.shape != expected_shape:
+        raise RuntimeError(f"Distance map size error! Expected {expected_shape}, got {result.shape}")
+    
+    # Сохраняем в кэш
+    _DISTANCE_MAP_CACHE.set(cache_key, result)
+    
+    return result
+
+
+def create_adaptive_latent_noise(canvas_shape, content_box, zoom_factor, input_stats, 
+                                 device, dtype, blend_mode='circular_reflect',
+                                 noise_strength=1.0, adaptive_scale=True):
+    """
+    Создает адаптивный латентный шум для outpainting.
+    
+    V3.0 УЛУЧШЕНИЯ:
+    - Увеличена базовая сила шума с 0.1 до 1.0 (параметр noise_strength)
+    - Adaptive scaling в зависимости от zoom_factor
+    - Более правильная статистика для coherent generation
+    
+    Args:
+        canvas_shape: (b, c, canvas_h, canvas_w)
+        content_box: (y1, y2, x1, x2)
+        zoom_factor: сила зума
+        input_stats: статистика входных латентов
+        device, dtype: torch параметры
+        blend_mode: режим блендинга
+        noise_strength: базовая сила шума (0.5-1.5, default: 1.0)
+        adaptive_scale: адаптировать силу по zoom_factor
+    
+    Returns:
+        torch.Tensor: шумовой тензор правильной статистики
+    """
+    b, c, canvas_h, canvas_w = canvas_shape
+    
+    # 1. Базовый шум N(0,1) - стандартное распределение
+    base_noise = torch.randn(b, c, canvas_h, canvas_w, device=device, dtype=dtype)
+    
+    # 2. Применяем статистику входных латентов
+    # V3.0: Используем std напрямую, а не масштабируем дополнительно
+    base_noise = base_noise * input_stats['std'] + input_stats['mean']
+    
+    # 3. Distance map (сила шума зависит от расстояния)
+    distance_map = create_distance_map(canvas_h, canvas_w, content_box, device, dtype)
+    
+    # 4. V3.0: ИСПРАВЛЕНО - адаптивная сила на основе zoom_factor
+    if adaptive_scale:
+        # Для сильного zoom out нужен менее агрессивный шум
+        # Для слабого zoom out нужен более сильный шум для лучшей генерации
+        zoom_scale = 1.0 - min(abs(zoom_factor) * 0.05, 0.3)
+    else:
+        zoom_scale = 1.0
+    
+    # 5. Итоговая сила шума
+    # V3.0: noise_strength теперь 1.0 по умолчанию (было 0.03)
+    final_strength = noise_strength * zoom_scale
+    
+    # 6. Адаптивная сила = base * distance
+    # Далеко от контента = сильнее шум (для лучшей генерации)
+    adaptive_strength = final_strength * (0.5 + distance_map * 1.5)
+    
+    # 7. V3.1 FIX: Применяем адаптивную силу с правильным broadcast
+    # Убеждаемся что размеры совпадают
+    if adaptive_strength.shape != base_noise.shape:
+        # V3.1.2: Детальная диагностика
+        print(f"⚠️  [Adaptive Noise] Shape mismatch detected!")
+        print(f"    adaptive_strength: {adaptive_strength.shape}")
+        print(f"    base_noise: {base_noise.shape}")
+        print(f"    distance_map: {distance_map.shape}")
+        print(f"    canvas: {canvas_h}x{canvas_w}, content_box: {content_box}")
+        
+        # V3.1.1 FIX: Более надежный expand с fallback
+        try:
+            adaptive_strength = adaptive_strength.expand(b, c, canvas_h, canvas_w)
+            print(f"    ✓ Expand succeeded to {adaptive_strength.shape}")
+        except RuntimeError as e:
+            print(f"    ⚠️  Expand failed: {e}")
+            # Fallback: принудительный reshape
+            adaptive_strength = adaptive_strength.reshape(1, 1, canvas_h, canvas_w).expand(b, c, canvas_h, canvas_w)
+            print(f"    ✓ Fallback reshape succeeded to {adaptive_strength.shape}")
+    
+    adaptive_noise = base_noise * adaptive_strength
+    
+    # 8. V3.0: Опциональная периодичность для circular режимов
+    if 'circular' in blend_mode:
+        # Делаем шум более плавным на границах для бесшовности
+        edge_smoothing = 0.9 + 0.1 * torch.cos(
+            torch.linspace(0, 2*math.pi, canvas_w, device=device, dtype=dtype)
+        ).view(1, 1, 1, -1)
+        # V3.1.1 FIX: КРИТИЧНО - Правильный expand до ПОЛНОГО размера (b, c, canvas_h, canvas_w)
+        # Было: expand(b, c, 1, canvas_w) что вызывало ошибку broadcast!
+        edge_smoothing = edge_smoothing.expand(b, c, canvas_h, canvas_w)
+        adaptive_noise = adaptive_noise * edge_smoothing
+    
+    return adaptive_noise
+
+
+def apply_variance_correction(blended_tensor, mask, debug=False):
+    """
+    V3.0: НОВАЯ ФУНКЦИЯ - Коррекция variance для устранения серости.
+    V3.1: Исправлена ошибка размеров при expand
+    V3.1.1: Адаптивный epsilon для float16
+    
+    Основана на blend_with_variance_fix из improved_tiling_functions.
+    Исправляет цветовые артефакты на швах при блендинге.
+    
+    Args:
+        blended_tensor: результат блендинга
+        mask: маска блендинга
+        debug: вывод диагностики
+    
+    Returns:
+        torch.Tensor: скорректированный тензор
+    """
+    dtype = blended_tensor.dtype
+    eps = get_adaptive_epsilon(dtype)  # V3.1.1 FIX: Адаптивный epsilon
+    
+    # Коррекция дисперсии
+    variance_fix = torch.sqrt(mask**2 + (1 - mask)**2 + eps)
+    
+    # V3.1.1 FIX: Более надежный expand с broadcast_to
+    if variance_fix.shape != blended_tensor.shape:
+        target_shape = blended_tensor.shape
+        try:
+            variance_fix = torch.broadcast_to(variance_fix, target_shape)
+        except RuntimeError:
+            # Fallback: расширяем через expand
+            if len(variance_fix.shape) == 4:
+                variance_fix = variance_fix.expand(target_shape)
+            else:
+                variance_fix = variance_fix.reshape(1, 1, -1, 1).expand(target_shape)
+    
+    corrected = blended_tensor / variance_fix
+    
+    if debug:
+        print(f"[Variance Correction] Original std: {blended_tensor.std().item():.4f}, "
+              f"Corrected std: {corrected.std().item():.4f}")
+    
+    return corrected
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 1. УЛУЧШЕННЫЙ LEGACY METHOD (V3.0)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_legacy_shift_zoom(input_tensor, zoom_factor, convergence=0.5, power=1.0, 
+                           pan_x=0.0, pan_y=0.0, auto_clamp_pan=True, debug=False):
+    """
+    V3.0 УЛУЧШЕНИЯ:
+    - Добавлен auto_clamp_pan для безопасного pan
+    - Debug mode для диагностики
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    # V3.0: Auto-clamp pan для предотвращения потери контента
+    if auto_clamp_pan:
+        pan_x = max(-0.5, min(0.5, pan_x))
+        pan_y = max(-0.5, min(0.5, pan_y))
+    
+    # 1. Применяем Pan
+    if pan_x != 0 or pan_y != 0:
+        shift_x = int(w * pan_x)
+        shift_y = int(h * pan_y)
+        input_tensor = torch.roll(input_tensor, shifts=(shift_y, shift_x), dims=(2, 3))
+        
+        if debug:
+            print(f"[Legacy Shift Zoom] Pan applied: X={shift_x}px, Y={shift_y}px")
+
+    if abs(zoom_factor) < 0.001:
+        return input_tensor
+
+    # Максимальный сдвиг
+    max_shift_w = w // 4
+    max_shift_h = h // 4
+    
+    shift_px_w = int(max_shift_w * (zoom_factor / 5.0))
+    shift_px_h = int(max_shift_h * (zoom_factor / 5.0))
+
+    # Правильная форма тензоров
+    x_1d = torch.linspace(0, 1, w, device=device, dtype=dtype)
+    x = x_1d.view(1, 1, 1, w).expand(b, c, h, w)
+    
+    # Расстояние от convergence point
+    dist_x = torch.abs(x - convergence)
+    
+    # Power - это "Mask Sharpness"
+    mask_w = torch.pow(torch.clamp(dist_x * 2.0, 0, 1), power)
+
+    # ZOOM OUT
+    if zoom_factor < 0:
+        left_mask = (x < convergence).to(dtype=dtype)
+        right_mask = (x >= convergence).to(dtype=dtype)
+        
+        shifted_left = torch.roll(input_tensor, shifts=shift_px_w, dims=3)
+        shifted_right = torch.roll(input_tensor, shifts=-shift_px_w, dims=3)
+        
+        result = shifted_left * left_mask + shifted_right * right_mask
+        return result
+
+    # ZOOM IN
+    else:
+        shifted = torch.roll(input_tensor, shifts=shift_px_w, dims=3)
+        result = input_tensor * (1.0 - mask_w) + shifted * mask_w
+        return result
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 2. УЛУЧШЕННЫЙ GRID WARP (V3.0)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_grid_warp_zoom(input_tensor, zoom_factor, convergence=0.5, power=1.0, 
+                        pan_x=0.0, pan_y=0.0, convergence_y=0.5, 
+                        interp_mode='bilinear', debug=False):
+    """
+    V3.0 УЛУЧШЕНИЯ:
+    - Добавлен параметр interp_mode ('bilinear', 'bicubic', 'nearest')
+    - Scale clamping для предотвращения NaN
+    - Debug mode
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    # V3.0: Scale clamping для безопасности
+    scale = 1.0 + (zoom_factor * 0.1)
+    scale = torch.clamp(torch.tensor(scale, device=device), min=0.1, max=10.0).item()
+    
+    if debug:
+        print(f"[Grid Warp] Scale: {scale:.4f}, Interp: {interp_mode}")
+    
+    y_coords = torch.linspace(-1, 1, h, device=device, dtype=dtype)
+    x_coords = torch.linspace(-1, 1, w, device=device, dtype=dtype)
+    
+    y_grid, x_grid = torch.meshgrid(y_coords, x_coords, indexing='ij')
+    
+    # Convergence определяет центр
+    center_x = (convergence - 0.5) * 2.0
+    center_y = (convergence_y - 0.5) * 2.0
+    
+    # Pan
+    offset_x = pan_x * 2.0
+    offset_y = pan_y * 2.0
+    
+    # Zoom относительно convergence point
+    x_new = (x_grid - center_x) / scale + center_x - offset_x
+    y_new = (y_grid - center_y) / scale + center_y - offset_y
+    
+    grid = torch.stack((x_new, y_new), dim=-1)
+    grid = grid.unsqueeze(0).expand(b, -1, -1, -1)
+    
+    # V3.0: Поддержка разных режимов интерполяции
+    if interp_mode not in ['bilinear', 'nearest']:
+        interp_mode = 'bilinear'  # Fallback (bicubic не поддерживается в grid_sample)
+    
+    return F.grid_sample(
+        input_tensor, 
+        grid, 
+        mode=interp_mode,
+        padding_mode='zeros',
+        align_corners=True
+    )
+
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 2.5. БЕЗОПАСНАЯ ИНТЕРПОЛЯЦИЯ ДЛЯ FLOAT16 (V3.1.1 - НОВОЕ)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def safe_interpolate(tensor, size, mode='bilinear'):
+    """
+    Безопасная интерполяция с правильной обработкой align_corners.
+    
+    V3.1.1: НОВАЯ ФУНКЦИЯ
+    V3.1.2: КРИТИЧНОЕ ИСПРАВЛЕНИЕ - НЕ конвертируем dtype!
+    - Работает напрямую с любым dtype (float16/float32/float64)
+    - Правильно обрабатывает align_corners (не использует None)
+    - F.interpolate нативно поддерживает float16
+    
+    ВАЖНО: НЕ конвертируем в float32, т.к. это вызывает ошибку
+    "Input type (float) and bias type (c10::Half) should be the same"
+    когда используется внутри моделей с параметрами в float16.
+    
+    Args:
+        tensor: входной тензор
+        size: целевой размер (H, W) 
+        mode: режим интерполяции ('bilinear', 'bicubic', 'nearest')
+    
+    Returns:
+        torch.Tensor: интерполированный тензор в исходном dtype
+    """
+    # V3.1.2 FIX: НЕ конвертируем dtype - работаем напрямую!
+    # F.interpolate нативно поддерживает float16 и не вызывает overflow
+    
+    # FIX: Правильная обработка align_corners (не использовать None!)
+    interpolate_kwargs = {
+        'size': size,
+        'mode': mode,
+    }
+    if mode != 'nearest':
+        interpolate_kwargs['align_corners'] = True
+    
+    result = F.interpolate(tensor, **interpolate_kwargs)
+    
+    return result
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3. ПОЛНОСТЬЮ ПЕРЕРАБОТАННЫЙ OUTPAINT ZOOM (V3.0)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_outpaint_zoom(input_tensor, zoom_factor, pad_h, pad_w,
+                       convergence=0.5, convergence_y=0.5,
+                       fade_strength=0.3, depth_power=1.0,
+                       pan_x=0.0, pan_y=0.0,
+                       fade_to_black=False, fade_edge_strength=0.15,
+                       blend_mode='circular_reflect',
+                       noise_strength=1.0, 
+                       interp_mode='bilinear',
+                       zoom_in_fade=True,
+                       variance_correction=True,
+                       auto_clamp_pan=True,
+                       adaptive_noise_scale=True,
+                       debug=False,
+                       extra_params=None):
+    """
+    V3.5 FIX: Исправлен краш маски при Zoom In / Pan
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    if debug:
+        print(f"\n[Outpaint Zoom] Input: {h}x{w}, Pad: {pad_h}x{pad_w}, Factor: {zoom_factor}")
+    
+    # Валидация padding
+    pad_h = max(0, pad_h)
+    pad_w = max(0, pad_w)
+    
+    is_zooming = abs(zoom_factor) > 0.001
+    is_panning = abs(pan_x) > 0.001 or abs(pan_y) > 0.001
+    
+    if not is_zooming and not is_panning:
+        return F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+    
+    # Валидация interp_mode
+    if interp_mode not in ['bilinear', 'bicubic', 'nearest']:
+        interp_mode = 'bilinear'
+
+    # ----------------------
+    # ZOOM OUT (Отдаление)
+    # ----------------------
+    if zoom_factor < 0:
+        # (Код Zoom Out без изменений - он работает отлично)
+        if blend_mode == 'gradient_radial':
+            g_cx = extra_params.get('gradient_center_x', 0.5) if extra_params else 0.5
+            g_cy = extra_params.get('gradient_center_y', 0.5) if extra_params else 0.5
+            g_rad = extra_params.get('gradient_radius', 1.0) if extra_params else 1.0
+            return apply_gradient_radial_blend(input_tensor, pad_h, pad_w, g_cx, g_cy, g_rad, debug)
+            
+        elif blend_mode == 'noise_blend':
+            n_scale = extra_params.get('noise_scale', 5.0) if extra_params else 5.0
+            n_oct = int(extra_params.get('noise_octaves', 2)) if extra_params else 2
+            return apply_noise_blend(input_tensor, pad_h, pad_w, n_scale, n_oct, debug)
+        
+        # Standard Zoom Out
+        scale = 1.0 + abs(zoom_factor) * 0.1
+        scale = max(1.0, min(scale, 4.0))
+        new_h = max(int(h / scale), 16)
+        new_w = max(int(w / scale), 16)
+        
+        content_small = safe_interpolate(input_tensor, size=(new_h, new_w), mode=interp_mode)
+        
+        # Padding Mode logic
+        b_str = str(blend_mode).lower()
+        if 'circular' in b_str: p_mode = 'circular'
+        elif 'reflect' in b_str or 'mirror' in b_str: p_mode = 'reflect'
+        else: p_mode = 'circular'
+        
+        canvas = F.pad(content_small, (pad_w, pad_w, pad_h, pad_h), mode=p_mode)
+        
+        # Pan logic for Zoom Out
+        if abs(pan_x) > 0.001 or abs(pan_y) > 0.001:
+            if auto_clamp_pan:
+                pan_x = max(-0.5, min(0.5, pan_x))
+                pan_y = max(-0.5, min(0.5, pan_y))
+            shift_y = int(pan_y * canvas.shape[2] * 0.5)
+            shift_x = int(pan_x * canvas.shape[3] * 0.5)
+            if shift_x != 0 or shift_y != 0:
+                canvas = torch.roll(canvas, shifts=(shift_y, shift_x), dims=(2, 3))
+
+        # Fade to black edges
+        if fade_to_black and fade_edge_strength > 0:
+            ch, cw = canvas.shape[2], canvas.shape[3]
+            ef_h, ef_w = int(ch*fade_edge_strength), int(cw*fade_edge_strength)
+            if ef_h > 0 and ef_w > 0:
+                fh = torch.linspace(0, 1, ef_h, device=device, dtype=dtype)
+                fw = torch.linspace(0, 1, ef_w, device=device, dtype=dtype)
+                canvas[:,:,:ef_h,:] *= fh.view(1,1,-1,1)
+                canvas[:,:,-ef_h:,:] *= fh.flip(0).view(1,1,-1,1)
+                canvas[:,:,:,:ef_w] *= fw.view(1,1,1,-1)
+                canvas[:,:,:,-ef_w:] *= fw.flip(0).view(1,1,1,-1)
+        
+        return canvas
+    
+    # ----------------------
+    # ZOOM IN / PAN (Приближение)
+    # ----------------------
+    else:
+        scale = 1.0 + zoom_factor * 0.1
+        new_h = int(h * scale)
+        new_w = int(w * scale)
+        
+        content_large = safe_interpolate(input_tensor, size=(new_h, new_w), mode=interp_mode)
+        
+        focus_x = int(new_w * convergence) - w // 2
+        focus_y = int(new_h * convergence_y) - h // 2
+        
+        if auto_clamp_pan:
+            max_px = (new_w - w) / w * 0.5
+            max_py = (new_h - h) / h * 0.5
+            pan_x = max(-max_px, min(max_px, pan_x))
+            pan_y = max(-max_py, min(max_py, pan_y))
+        
+        shift_y = int(pan_y * h * 0.5)
+        shift_x = int(pan_x * w * 0.5)
+        
+        crop_y = max(0, min(new_h - h, focus_y + shift_y))
+        crop_x = max(0, min(new_w - w, focus_x + shift_x))
+        
+        cropped = content_large[:, :, crop_y:crop_y+h, crop_x:crop_x+w]
+        
+        # Fade Logic
+        fade_mask = None
+        if zoom_in_fade and fade_strength > 0:
+            fh_in = int(h * fade_strength * 0.5)
+            fw_in = int(w * fade_strength * 0.5)
+            if fh_in > 0 and fw_in > 0:
+                fade_mask = torch.ones(1, 1, h, w, device=device, dtype=dtype)
+                lx = torch.linspace(0, 1, fw_in, device=device, dtype=dtype)
+                ly = torch.linspace(0, 1, fh_in, device=device, dtype=dtype)
+                cx = torch.pow(lx, depth_power)
+                cy = torch.pow(ly, depth_power)
+                
+                fade_mask[:,:,:,:fw_in] *= cx.view(1,1,1,-1)
+                fade_mask[:,:,:,-fw_in:] *= cx.flip(0).view(1,1,1,-1)
+                fade_mask[:,:,:fh_in,:] *= cy.view(1,1,-1,1)
+                fade_mask[:,:,-fh_in:,:] *= cy.flip(0).view(1,1,-1,1)
+                
+                cropped = cropped * fade_mask.expand_as(cropped)
+
+        # Padding
+        padded = F.pad(cropped, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+        
+        # --- ФИКС ДЛЯ TEST 6 & 7 (Correction Mask Size) ---
+        if variance_correction and zoom_in_fade:
+            if fade_mask is not None:
+                correction_mask = fade_mask
+            else:
+                correction_mask = torch.ones(1, 1, h, w, device=device, dtype=dtype)
+            
+            # ВАЖНО: Мы должны добавить паддинг к маске, чтобы она совпадала с padded картинкой!
+            # Иначе: padded (576px) vs mask (512px) -> CRASH
+            correction_mask = F.pad(correction_mask, (pad_w, pad_w, pad_h, pad_h), mode='constant', value=1.0)
+            
+            padded = apply_variance_correction(padded, correction_mask, debug=debug)
+            
+        return padded
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3.5. SPIRAL ZOOM (V3.1 - НОВАЯ ФУНКЦИЯ БЕЗ БАГОВ)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_spiral_zoom(input_tensor, zoom_factor, pad_h, pad_w,
+                     spiral_rotation=0.5, 
+                     spiral_direction=1.0,
+                     interp_mode='bilinear', 
+                     debug=False, 
+                     **kwargs):
+    """
+    Спиральный зум с эффектом вращения.
+    
+    V3.1: ПОЛНАЯ РЕАЛИЗАЦИЯ БЕЗ БАГОВ
+    - Правильная валидация параметров
+    - Безопасная обработка особых случаев (dx=dy=0)
+    - Проверка размеров на всех этапах
+    
+    V3.1.1: КРИТИЧНЫЕ ИСПРАВЛЕНИЯ ДЛЯ FLOAT16
+    - Адаптивный epsilon для всех sqrt/division операций
+    
+    Args:
+        input_tensor: входной латент (B, C, H, W)
+        zoom_factor: сила зума (-5.0 до 5.0)
+        pad_h, pad_w: размеры паддинга
+        spiral_rotation: сила вращения (0.0 до 2.0)
+            - 0.0 = без вращения (обычный зум)
+            - 0.5 = слабое вращение
+            - 1.0 = среднее вращение  
+            - 2.0 = сильное вращение
+        spiral_direction: направление (1.0 = по часовой, -1.0 = против)
+        interp_mode: режим интерполяции ('bilinear', 'bicubic', 'nearest')
+        debug: вывод отладочной информации
+    
+    Returns:
+        torch.Tensor: трансформированный и padded тензор
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    # V3.1.1 FIX: Получаем адаптивный epsilon для данного dtype
+    eps = get_adaptive_epsilon(dtype)
+    
+    # V3.1: Валидация параметров
+    spiral_rotation = float(max(0.0, min(2.0, spiral_rotation)))
+    spiral_direction = 1.0 if spiral_direction >= 0 else -1.0
+    zoom_factor = float(max(-5.0, min(5.0, zoom_factor)))
+    
+    if debug:
+        print(f"\n{'='*70}")
+        print(f"[Spiral Zoom V3.1.1]")
+        print(f"  Input shape: {input_tensor.shape}")
+        print(f"  Zoom Factor: {zoom_factor:.2f}")
+        print(f"  Rotation: {spiral_rotation:.2f} ({'clockwise' if spiral_direction > 0 else 'counter-clockwise'})")
+        print(f"  Interp mode: {interp_mode}")
+        print(f"  Epsilon: {eps} (for {dtype})")
+        print(f"{'='*70}\n")
+    
+    # Центр изображения
+    center_y = (h - 1) / 2.0
+    center_x = (w - 1) / 2.0
+    
+    # Создаем координатные сетки
+    y_coords = torch.arange(h, device=device, dtype=dtype).view(-1, 1).expand(h, w)
+    x_coords = torch.arange(w, device=device, dtype=dtype).view(1, -1).expand(h, w)
+    
+    # Смещение от центра
+    dy = y_coords - center_y
+    dx = x_coords - center_x
+    
+    # V3.1.1 FIX: Полярные координаты с адаптивным epsilon
+    r = torch.sqrt(dx**2 + dy**2 + eps)
+    theta = torch.atan2(dy, dx)
+    
+    # Спиральная трансформация
+    # 1. Zoom scale
+    zoom_scale = 1.0 + zoom_factor * 0.1
+    
+    # 2. Rotation - зависит от расстояния от центра
+    max_radius = math.sqrt(h**2 + w**2) / 2.0
+    # V3.1.1 FIX: Адаптивный epsilon для division
+    normalized_r = torch.clamp(r / (max_radius + eps), 0.0, 1.0)
+    
+    # Угол вращения увеличивается с расстоянием от центра (спиральный эффект)
+    rotation_angle = spiral_direction * spiral_rotation * normalized_r * math.pi
+    
+    # 3. Применяем трансформацию
+    new_theta = theta + rotation_angle
+    new_r = r * zoom_scale
+    
+    # Обратно в декартовы координаты
+    new_x = center_x + new_r * torch.cos(new_theta)
+    new_y = center_y + new_r * torch.sin(new_theta)
+    
+    # Нормализация для grid_sample [-1, 1]
+    grid_x = 2.0 * new_x / max(w - 1, 1) - 1.0
+    grid_y = 2.0 * new_y / max(h - 1, 1) - 1.0
+    
+    # V3.1 FIX: Clamp grid values для предотвращения выхода за границы
+    grid_x = torch.clamp(grid_x, -1.0, 1.0)
+    grid_y = torch.clamp(grid_y, -1.0, 1.0)
+    
+    # Собираем grid
+    grid = torch.stack([grid_x, grid_y], dim=-1).unsqueeze(0).to(dtype)
+    
+    # V3.1: Валидация размеров grid
+    expected_grid_shape = (1, h, w, 2)
+    if grid.shape != expected_grid_shape:
+        raise ValueError(f"Grid shape mismatch! Expected {expected_grid_shape}, got {grid.shape}")
+    
+    # Применяем деформацию
+    warped = F.grid_sample(
+        input_tensor,
+        grid.expand(b, -1, -1, -1),
+        mode=interp_mode,
+        padding_mode='zeros',
+        align_corners=True
+    )
+    
+    # V3.1: Проверка после warp
+    if warped.shape != input_tensor.shape:
+        raise ValueError(f"Warped shape mismatch! Expected {input_tensor.shape}, got {warped.shape}")
+    
+    # Паддинг
+    padded = F.pad(warped, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+    
+    # V3.1: Финальная проверка размеров
+    expected_padded_shape = (b, c, h + 2*pad_h, w + 2*pad_w)
+    if padded.shape != expected_padded_shape:
+        raise ValueError(f"Padded shape mismatch! Expected {expected_padded_shape}, got {padded.shape}")
+    
+    if debug:
+        print(f"[Spiral Zoom] Input shape: {input_tensor.shape}")
+        print(f"[Spiral Zoom] Output shape: {padded.shape}")
+        print(f"[Spiral Zoom] ✓ All shape checks passed")
+    
+    return padded
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3.6. GRADIENT RADIAL BLENDING (V3.1 - НОВАЯ ФУНКЦИЯ)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_gradient_radial_blend(input_tensor, pad_h, pad_w, 
+                                gradient_center_x=0.5, gradient_center_y=0.5,
+                                gradient_radius=1.0, debug=False):
+    """
+    Радиальный градиент для плавных переходов от центра к краям.
+    
+    V3.1: НОВАЯ ФУНКЦИЯ
+    
+    Args:
+        input_tensor: входной латент (B, C, H, W)
+        pad_h, pad_w: размеры паддинга
+        gradient_center_x: центр по X (0.0-1.0, default 0.5)
+        gradient_center_y: центр по Y (0.0-1.0, default 0.5)
+        gradient_radius: радиус градиента (0.1-2.0, default 1.0)
+        debug: вывод отладки
+    
+    Returns:
+        torch.Tensor: padded тензор с радиальным градиентом
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    # Валидация параметров
+    gradient_center_x = float(max(0.0, min(1.0, gradient_center_x)))
+    gradient_center_y = float(max(0.0, min(1.0, gradient_center_y)))
+    gradient_radius = float(max(0.1, min(2.0, gradient_radius)))
+    
+    if debug:
+        print(f"[Gradient Radial] Center: ({gradient_center_x:.2f}, {gradient_center_y:.2f}), "
+              f"Radius: {gradient_radius:.2f}")
+    
+    # Размеры с паддингом
+    canvas_h = h + 2 * pad_h
+    canvas_w = w + 2 * pad_w
+    
+    # Координаты центра градиента
+    center_y = gradient_center_y * canvas_h
+    center_x = gradient_center_x * canvas_w
+    
+    # Создаем координатную сетку
+    y = torch.arange(canvas_h, device=device, dtype=dtype).view(-1, 1)
+    x = torch.arange(canvas_w, device=device, dtype=dtype).view(1, -1)
+    
+    # Расстояние от центра (нормализованное)
+    max_dist = math.sqrt(canvas_h**2 + canvas_w**2) / 2.0
+    dist = torch.sqrt((y - center_y)**2 + (x - center_x)**2) / max_dist
+    
+    # Радиальный градиент [0, 1]
+    gradient = torch.clamp(1.0 - (dist / gradient_radius), 0.0, 1.0)
+    gradient = gradient.unsqueeze(0).unsqueeze(0)  # (1, 1, canvas_h, canvas_w)
+    
+    # Circular padding для входного тензора
+    padded = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+    
+    # V3.1.2 FIX: Проверяем размеры перед expand
+    expected_shape = (b, c, canvas_h, canvas_w)
+    if padded.shape != expected_shape:
+        raise RuntimeError(
+            f"[Gradient Radial] Padded shape mismatch! "
+            f"Expected {expected_shape}, got {padded.shape}"
+        )
+    
+    # Применяем градиент (плавный переход к circular padding на краях)
+    # V3.1.2 FIX: Безопасный expand с проверкой
+    try:
+        gradient_expanded = gradient.expand(b, c, canvas_h, canvas_w)
+    except RuntimeError as e:
+        print(f"⚠️  [Gradient Radial] Expand failed: {e}")
+        print(f"    Gradient shape: {gradient.shape}, Target: {expected_shape}")
+        # Fallback: используем broadcast_to
+        gradient_expanded = torch.broadcast_to(gradient, expected_shape)
+    
+    result = padded * gradient_expanded
+    
+    if debug:
+        print(f"[Gradient Radial] Gradient range: [{gradient.min().item():.3f}, {gradient.max().item():.3f}]")
+    
+    return result
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3.7. NOISE BLEND (V3.1 - НОВАЯ ФУНКЦИЯ)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def apply_noise_blend(input_tensor, pad_h, pad_w, noise_scale=5.0, 
+                     noise_octaves=2, debug=False):
+    """
+    Блендинг с процедурным шумом для органичных границ.
+    
+    V3.1: НОВАЯ ФУНКЦИЯ
+    V3.1.1: КРИТИЧНЫЕ ИСПРАВЛЕНИЯ ДЛЯ FLOAT16
+    - Адаптивный epsilon для нормализации
+    - Упрощенная формула для blend (оптимизация)
+    
+    Args:
+        input_tensor: входной латент (B, C, H, W)
+        pad_h, pad_w: размеры паддинга
+        noise_scale: масштаб шума (1.0-10.0, default 5.0)
+        noise_octaves: количество октав шума (1-4, default 2)
+        debug: вывод отладки
+    
+    Returns:
+        torch.Tensor: padded тензор с noise blending
+    """
+    b, c, h, w = input_tensor.shape
+    device = input_tensor.device
+    dtype = input_tensor.dtype
+    
+    # V3.1.1 FIX: Получаем адаптивный epsilon
+    eps = get_adaptive_epsilon(dtype)
+    
+    # Валидация параметров
+    noise_scale = float(max(1.0, min(10.0, noise_scale)))
+    noise_octaves = int(max(1, min(4, noise_octaves)))
+    
+    if debug:
+        print(f"[Noise Blend] Scale: {noise_scale:.2f}, Octaves: {noise_octaves}, Epsilon: {eps}")
+    
+    # Размеры с паддингом
+    canvas_h = h + 2 * pad_h
+    canvas_w = w + 2 * pad_w
+    
+    # Создаем координатную сетку
+    y = torch.arange(canvas_h, device=device, dtype=dtype).view(-1, 1)
+    x = torch.arange(canvas_w, device=device, dtype=dtype).view(1, -1)
+    
+    # Многооктавный Perlin-style шум
+    noise_mask = torch.zeros(canvas_h, canvas_w, device=device, dtype=dtype)
+    amplitude = 1.0
+    frequency = 1.0
+    
+    for octave in range(noise_octaves):
+        # Простой процедурный шум через sin/cos
+        phase_x = x * frequency * noise_scale / canvas_w * 2 * math.pi
+        phase_y = y * frequency * noise_scale / canvas_h * 2 * math.pi
+        
+        octave_noise = torch.sin(phase_x + octave) * torch.cos(phase_y + octave * 0.7)
+        noise_mask = noise_mask + octave_noise * amplitude
+        
+        amplitude *= 0.5
+        frequency *= 2.0
+    
+    # V3.1.1 FIX: Нормализация в [0, 1] с адаптивным epsilon
+    noise_mask = (noise_mask - noise_mask.min()) / (noise_mask.max() - noise_mask.min() + eps)
+    
+    # Расстояние от контента (для комбинирования с шумом)
+    content_box = (pad_h, pad_h + h, pad_w, pad_w + w)
+    distance = create_distance_map(canvas_h, canvas_w, content_box, device, dtype)
+    
+    # V3.1.1 FIX: Явное преобразование размеров для ясности
+    distance_2d = distance.squeeze(0).squeeze(0)  # (canvas_h, canvas_w)
+    
+    # Комбинируем distance с noise (больше шума на краях)
+    blend_mask = 0.7 * distance_2d + 0.3 * noise_mask
+    blend_mask = torch.clamp(blend_mask, 0.0, 1.0).unsqueeze(0).unsqueeze(0)
+    
+    # Circular padding
+    padded = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+    
+    # V3.1.1 FIX: Упрощенная формула для blend
+    # Было: padded * (1.0 - blend_mask) + padded * blend_mask * 0.5
+    # Упрощено: padded * (1.0 - 0.5 * blend_mask)
+    blend_mask_expanded = blend_mask.expand(b, c, canvas_h, canvas_w)
+    result = padded * (1.0 - 0.5 * blend_mask_expanded)
+    
+    if debug:
+        print(f"[Noise Blend] Mask range: [{blend_mask.min().item():.3f}, {blend_mask.max().item():.3f}]")
+    
+    return result
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 4. ГЛАВНАЯ ФУНКЦИЯ (V3.0 - УЛУЧШЕНО)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def validate_zoom_params(params):
+    """
+    V3.0: Добавлены новые параметры
+    """
+    z_mode = params.get('zoom_mode', 'outpaint_zoom')
+    try: 
+        zoom_mode = ZoomMode(z_mode)
+    except: 
+        zoom_mode = ZoomMode.OUTPAINT_ZOOM
+        
+    b_mode = params.get('blend_mode', 'circular_reflect')
+    try: 
+        blend_mode = BlendMode(b_mode)
+    except: 
+        blend_mode = BlendMode.CIRCULAR_REFLECT
+
+    return {
+        # Базовые параметры
+        'zoom_factor': float(params.get('zoom_factor', 0.0)),
+        'zoom_mode': zoom_mode,
+        'blend_mode': blend_mode,
+        'convergence_point': float(params.get('convergence_point', 0.5)),
+        'convergence_y': float(params.get('convergence_y', 0.5)),
+        'depth_power': float(params.get('depth_power', 1.0)),
+        'blend_falloff': str(params.get('blend_falloff', 'smoothstep')),
+        'blend_sharpness': float(params.get('blend_sharpness', 1.0)),
+        'blend_width': params.get('blend_width', None),
+        'pan_x': float(params.get('x_pan', 0.0)),
+        'pan_y': float(params.get('y_pan', 0.0)),
+        'fade_to_black': bool(params.get('zoom_fade_to_black', False)),
+        'fade_strength': float(params.get('zoom_fade_strength', 0.3)),
+        'fade_edge_strength': float(params.get('fade_edge_strength', 0.15)),
+        
+        # V3.0: Новые параметры
+        'noise_strength': float(params.get('noise_strength', 1.0)),
+        'interp_mode': str(params.get('interp_mode', 'bilinear')),
+        'zoom_in_fade': bool(params.get('zoom_in_fade', True)),
+        'variance_correction': bool(params.get('variance_correction', True)),
+        'auto_clamp_pan': bool(params.get('auto_clamp_pan', True)),
+        'adaptive_noise_scale': bool(params.get('adaptive_noise_scale', True)),
+        'debug': bool(params.get('debug_mode', False)),
+        
+        # V3.1: Новые параметры для spiral_zoom
+        'spiral_rotation': float(params.get('spiral_rotation', 0.5)),
+        'spiral_direction': float(params.get('spiral_direction', 1.0)),
+        
+        # V3.1: Новые параметры для gradient_radial
+        'gradient_center_x': float(params.get('gradient_center_x', 0.5)),
+        'gradient_center_y': float(params.get('gradient_center_y', 0.5)),
+        'gradient_radius': float(params.get('gradient_radius', 1.0)),
+        
+        # V3.1: Новые параметры для noise_blend
+        'noise_scale': float(params.get('noise_scale', 5.0)),
+        'noise_octaves': int(params.get('noise_octaves', 2)),
+    }
+
+
+def apply_unified_zoom(input_tensor, pad_h, pad_w, zoom_factor=0.0, 
+                      zoom_mode=ZoomMode.OUTPAINT_ZOOM, 
+                      blend_mode=BlendMode.CIRCULAR_REFLECT,
+                      convergence_point=0.5, convergence_y=0.5,
+                      depth_power=1.0,
+                      blend_falloff='smoothstep', blend_sharpness=1.0, 
+                      blend_width=None, 
+                      pan_x=0.0, pan_y=0.0,
+                      fade_to_black=False, fade_strength=0.3,
+                      fade_edge_strength=0.15,
+                      noise_strength=1.0,
+                      interp_mode='bilinear',
+                      zoom_in_fade=True,
+                      variance_correction=True,
+                      auto_clamp_pan=True,
+                      adaptive_noise_scale=True,
+                      debug=False,
+                      extra_params=None):
+    """
+    V3.5 - UNIFIED ZOOM (Фикс Grid Warp + Hybrid Mode)
+    """
+    is_active = (abs(zoom_factor) > 0.001) or (abs(pan_x) > 0.001) or (abs(pan_y) > 0.001)
+    force_original_size = True
+    if extra_params and 'force_original_size' in extra_params:
+        force_original_size = bool(extra_params['force_original_size'])
+
+    target_h, target_w = input_tensor.shape[2], input_tensor.shape[3]
+    
+    if not is_active:
+        return input_tensor
+    
+    result = None
+
+    if zoom_mode == ZoomMode.OUTPAINT_ZOOM:
+        result = apply_outpaint_zoom(
+            input_tensor, zoom_factor, pad_h, pad_w,
+            convergence=convergence_point, convergence_y=convergence_y,
+            fade_strength=fade_strength, depth_power=depth_power,
+            pan_x=pan_x, pan_y=pan_y,
+            fade_to_black=fade_to_black, fade_edge_strength=fade_edge_strength,
+            blend_mode=blend_mode.value if isinstance(blend_mode, BlendMode) else str(blend_mode),
+            noise_strength=noise_strength, interp_mode=interp_mode,
+            zoom_in_fade=zoom_in_fade, variance_correction=variance_correction,
+            auto_clamp_pan=auto_clamp_pan, adaptive_noise_scale=adaptive_noise_scale,
+            debug=debug, extra_params=extra_params
+        )
+    
+    elif zoom_mode == ZoomMode.GRID_WARP:
+        x_warped = apply_grid_warp_zoom(
+            input_tensor, zoom_factor, convergence_point, depth_power,
+            pan_x, pan_y, convergence_y, interp_mode=interp_mode, debug=debug
+        )
+        # FIX: mode='zeros' не существует. Используем constant + value=0
+        result = F.pad(x_warped, (pad_w, pad_w, pad_h, pad_h), mode='constant', value=0)
+    
+    elif zoom_mode == ZoomMode.SPIRAL_ZOOM:
+        s_rot = extra_params.get('spiral_rotation', 0.5) if extra_params else 0.5
+        s_dir = extra_params.get('spiral_direction', 1.0) if extra_params else 1.0
+        result = apply_spiral_zoom(
+            input_tensor, zoom_factor, pad_h, pad_w,
+            spiral_rotation=s_rot, spiral_direction=s_dir,
+            interp_mode=interp_mode, debug=debug
+        )
+    
+    else: # Legacy
+        x_shifted = apply_legacy_shift_zoom(
+            input_tensor, zoom_factor, convergence_point, depth_power, 
+            pan_x, pan_y, auto_clamp_pan=auto_clamp_pan, debug=debug
+        )
+        result = F.pad(x_shifted, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+
+    # ФИНАЛЬНЫЙ ФИКС РАЗМЕРА
+    if force_original_size:
+        if result.shape[2] != target_h or result.shape[3] != target_w:
+            if debug: print(f"[Unified Zoom] Resizing back: {result.shape} -> {input_tensor.shape}")
+            result = F.interpolate(result, size=(target_h, target_w), mode='bilinear', align_corners=True)
+    else:
+        if debug and (result.shape[2] != target_h or result.shape[3] != target_w):
+             print(f"[Unified Zoom] Expanding Canvas: {input_tensor.shape} -> {result.shape}")
+
+    return result