Upload asymmetric-tiling-sd-webui-2.0 using SD-Hub

.gitattributes

@@ -179,3 +179,5 @@ sd-webui-llul/images/sample1.jpg filter=lfs diff=lfs merge=lfs -text
 sd-webui-llul/images/sample2.jpg filter=lfs diff=lfs merge=lfs -text
 sd-webui-llul/images/sample3.jpg filter=lfs diff=lfs merge=lfs -text
 sd-webui-llul/images/sample4.jpg filter=lfs diff=lfs merge=lfs -text
+asymmetric-tiling-sd-webui-2.0/Руководство[[:space:]]Advanced[[:space:]]Tiling[[:space:]]v3.0[[:space:]]-[[:space:]]Новые[[:space:]]функции.pdf filter=lfs diff=lfs merge=lfs -text
+asymmetric-tiling-sd-webui-2.0/Руководство[[:space:]]по[[:space:]]новым[[:space:]]функциям.pdf filter=lfs diff=lfs merge=lfs -text

asymmetric-tiling-sd-webui-2.0/LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

asymmetric-tiling-sd-webui-2.0/README.md

@@ -0,0 +1,16 @@
+# Asymmetric Tiling for stable-diffusion-webui
+
+An always visible script extension for [stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui/) to configure seamless image tiling independently for the X and Y axes.
+
+To use, install this repository from the "Extensions" tab in stable-diffusion-webui, restart your server, open the `Asymmetric tiling` foldout on txt2img or img2img, and make it active, and check `Tile X` or `Tile Y` as desired. While this script is active, the `Tiling` checkbox in the main UI will be ignored.
+
+Like existing tiling options this won't guarantee seamless tiling 100% of the time, but it should manage it for most prompts. You can check that images tile seamlessly using online tools like [Seamless Texture Check](https://www.pycheung.com/checker/).
+
+For the old, non-extension version of this script, use the "classic_script" branch.
+
+## X axis tiling examples
+![00817-3274117678-midnight cityscape, stunning environment, wide-angle, massive scale, landscape, panoramic, lush vegetation, idyllic](https://user-images.githubusercontent.com/19196175/195132862-8c050327-92f3-44a4-9c02-0f11cce0b609.png)
+![01064-1316547214-(((domino run))), domino toppling, line of standing dominoes, domino cascade, domino effect, black dominos](https://user-images.githubusercontent.com/19196175/195137782-e72fc69a-14f1-4ae7-bac2-219734509aea.png)
+
+## Y Axis tiling examples
+![00840-2320166501-man climbing ladder, safety diagram](https://user-images.githubusercontent.com/19196175/195132867-1b36848e-135d-4103-8e10-1d760b3a0a4e.png)![01095-949590403-tree, thick branches, photograph, 80mm Sigma f1 4, studio quality, nature photography](https://user-images.githubusercontent.com/19196175/195140638-49b0a4be-fbca-45bc-8e52-6c985202ce29.png)

asymmetric-tiling-sd-webui-2.0/scripts/asymmetric_tiling.py

@@ -0,0 +1,732 @@
+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
+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
+
+# ========================================================================
+# КОНСТАНТЫ И КОНФИГУРАЦИЯ
+# ========================================================================
+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"
+MODE_ANISOTROPIC = "Anisotropic (Directional)"
+MODE_POLAR = "Polar (Sphere Correct)"
+
+# Глобальное хранилище
+_ORIGINAL_METHODS_CACHE = {}
+_MASK_CACHE = {}
+_SAMPLER_REGISTERED = False
+
+# ========================================================================
+# KOHAKU LONYU YOG SAMPLER IMPLEMENTATION
+# ========================================================================
+
+@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
+    
+    Принцип работы:
+    1. Использует геометрические эвристики в 3D подпространстве
+    2. Находит антипод (-x) для определения направления
+    3. Вычисляет градиенты d, d2 в разных точках
+    4. Усредняет (d+d2)/2 для нахождения "вектора вниз" к визуальному многообразию
+    5. Корректирует позицию и вычисляет d3 для финальной траектории
+    6. Применяется только на первой половине шагов (выпуклая область)
+    
+    Теория: Поскольку 3D пространство - подпространство многомерного,
+    все операции в 3D осуществимы в высокоразмерном пространстве латентов.
+    """
+    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"):
+        # Ancestral noise injection (опционально)
+        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:
+            # Шаг 1: Находим антипод (-x)
+            # Это ключевая идея: рассматриваем противоположную точку
+            x_antipode = -x
+            
+            # Шаг 2: Вычисляем градиент d2 в антиподе
+            denoised2 = model(x_antipode, sigma_hat * s_in, **extra_args)
+            d2 = to_d(x_antipode, sigma_hat, denoised2)
+            
+            # Шаг 3: Геометрическая дедукция
+            # Вектор (d+d2)/2 указывает "вниз" к визуальному многообразию
+            v_down = (d + d2) / 2
+            
+            # Шаг 4: Коррекция позиции (Lookahead)
+            # Двигаемся к точке, которая ближе к целевой области A
+            x_closer = x + v_down * dt
+            
+            # Шаг 5: Вычисляем скорость d3 в уточненной точке
+            denoised3 = model(x_closer, sigma_hat * s_in, **extra_args)
+            d3 = to_d(x_closer, sigma_hat, denoised3)
+            
+            # Шаг 6: Финальная траектория
+            # (d+d3)/2 дает более точное направление к истинной цели
+            real_d = (d + d3) / 2
+            x = x + real_d * dt
+            
+            # Добавляем ancestral шум
+            if sigma_up > 0:
+                x = x + noise_sampler(sigmas[i], sigmas[i + 1]) * s_noise * sigma_up
+        
+        # ====== СТАНДАРТНЫЙ EULER (Вторая половина) ======
+        else:
+            # На поздних шагах геометрический метод может отклоняться
+            # Причина: траектория становится невыпуклой из-за деталей
+            x = x + d * dt
+            
+            if sigma_up > 0:
+                x = x + noise_sampler(sigmas[i], sigmas[i + 1]) * s_noise * sigma_up
+        
+        # Callback для мониторинга
+        if callback is not None:
+            callback({
+                'x': x, 
+                'i': i, 
+                'sigma': sigmas[i], 
+                'sigma_hat': sigma_hat, 
+                'denoised': denoised
+            })
+    
+    return x
+
+# ========================================================================
+# РАСШИРЕННЫЕ ФУНКЦИИ ПАДДИНГА
+# ========================================================================
+
+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):
+    """
+    Анизотропный паддинг - разное поведение по диагоналям.
+    Эмулирует направленные материалы (дерево, металл, волокна).
+    
+    Args:
+        angle_deg: Угол направления волокон/текстуры (0-360)
+    """
+    b, c, h, w = input_tensor.shape
+    
+    # Преобразуем угол в радианы
+    angle_rad = math.radians(angle_deg)
+    
+    # Создаем направленную маску весов
+    # Вычисляем "силу" паддинга в зависимости от направления
+    y_coords = torch.linspace(-1, 1, h, device=input_tensor.device).view(1, 1, h, 1)
+    x_coords = torch.linspace(-1, 1, w, device=input_tensor.device).view(1, 1, 1, w)
+    
+    # Проекция на направление волокон
+    directional_strength = torch.abs(
+        x_coords * math.cos(angle_rad) + y_coords * math.sin(angle_rad)
+    )
+    
+    # Вдоль волокон - circular, поперек - reflect
+    # Сначала применяем базовый circular паддинг
+    padded = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+    
+    # Создаем альтернативный reflect паддинг
+    padded_reflect = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='reflect')
+    
+    # Смешиваем на основе направления
+    directional_strength_expanded = directional_strength.expand(b, c, h + 2*pad_h, w + 2*pad_w)
+    
+    # Альфа-блендинг: вдоль направления больше circular, поперек больше reflect
+    alpha = directional_strength_expanded.clamp(0, 1)
+    result = padded * alpha + padded_reflect * (1 - alpha)
+    
+    return result
+
+def compute_polar_padding(input_tensor, pad_h, pad_w):
+    """
+    Полярный паддинг для сферических проекций.
+    Корректирует переход через полюса с учетом топологии сферы.
+    
+    При переходе через Северный полюс:
+    - Сдвиг на W/2 (противоположная сторона сферы)
+    - Отражение (инверсия широты)
+    """
+    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)  # Сдвиг на 180°
+    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
+
+def compute_stereoscopic_padding(input_tensor, pad_h, pad_w, eye='left', 
+                                 convergence=0.05, separation=0.065):
+    """
+    Стереоскопический паддинг для 3D изображений.
+    
+    Args:
+        eye: 'left' или 'right' - какой глаз
+        convergence: Точка схождения (0-1, где 0.5 - центр)
+        separation: Межзрачковое расстояние в долях от ширины
+    """
+    b, c, h, w = input_tensor.shape
+    
+    # Вычисляем сдвиг в зависимости от глаза
+    # Левый глаз видит правую часть объектов, правый - левую
+    shift_amount = int(w * separation)
+    
+    if eye == 'left':
+        # Левый глаз: сдвиг вправо
+        shifted = torch.roll(input_tensor, shifts=shift_amount, dims=3)
+    else:
+        # Правый глаз: сдвиг влево
+        shifted = torch.roll(input_tensor, shifts=-shift_amount, dims=3)
+    
+    # Создаем карту глубины на основе положения пикселя
+    # Центр имеет меньший сдвиг (ближе), края больший (дальше)
+    x_coords = torch.linspace(0, 1, w, device=input_tensor.device).view(1, 1, 1, w)
+    depth_map = torch.abs(x_coords - convergence).expand(b, c, h, w)
+    
+    # Смешиваем оригинал и сдвинутый на основе глубины
+    # Ближние объекты - больше сдвиг, дальние - меньше
+    alpha = depth_map.clamp(0, 1)
+    stereo_adjusted = input_tensor * (1 - alpha) + shifted * alpha
+    
+    # Применяем стандартный circular паддинг
+    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 compute_blend_padding(input_tensor, pad_h, pad_w, blend_strength=0.1):
+    """Мягкое смешивание краев (из v2.0)"""
+    b, c, h, w = input_tensor.shape
+    padded = F.pad(input_tensor, (pad_w, pad_w, pad_h, pad_h), mode='circular')
+    
+    blend_w = int(w * blend_strength)
+    blend_h = int(h * blend_strength)
+    
+    if blend_h > 0:
+        # Вертикальное затухание
+        top_mask = torch.linspace(0, 1, blend_h, device=input_tensor.device)
+        top_mask = top_mask.view(1, 1, blend_h, 1).expand(b, c, blend_h, w + 2*pad_w)
+        padded[:, :, pad_h:pad_h+blend_h, :] *= top_mask
+        
+        bottom_mask = torch.linspace(1, 0, blend_h, device=input_tensor.device)
+        bottom_mask = bottom_mask.view(1, 1, blend_h, 1).expand(b, c, blend_h, w + 2*pad_w)
+        padded[:, :, pad_h+h-blend_h:pad_h+h, :] *= bottom_mask
+    
+    if blend_w > 0:
+        # Горизонтальное затухание
+        left_mask = torch.linspace(0, 1, blend_w, device=input_tensor.device)
+        left_mask = left_mask.view(1, 1, 1, blend_w).expand(b, c, h + 2*pad_h, blend_w)
+        padded[:, :, :, pad_w:pad_w+blend_w] *= left_mask
+        
+        right_mask = torch.linspace(1, 0, blend_w, device=input_tensor.device)
+        right_mask = right_mask.view(1, 1, 1, blend_w).expand(b, c, h + 2*pad_h, blend_w)
+        padded[:, :, :, pad_w+w-blend_w:pad_w+w] *= right_mask
+    
+    return padded
+
+# ========================================================================
+# ГЛАВНАЯ ФУНКЦИЯ ПАДДИНГА
+# ========================================================================
+
+def custom_padding_forward(input_tensor, weight, bias, stride, padding, dilation, groups, params):
+    """
+    Универсальная функция паддинга с поддержкой всех режимов v3.0
+    """
+    try:
+        # Проверка шагов
+        current_step = getattr(shared.state, 'sampling_step', 0)
+        if not (params['start_step'] <= current_step <= params['end_step']):
+            return F.conv2d(input_tensor, weight, bias, stride, padding, dilation, groups)
+
+        # Вычисление размеров паддинга
+        k_h, k_w = weight.shape[2], weight.shape[3]
+        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
+
+        x = input_tensor
+        mode_x = params['mode_x']
+        mode_y = params['mode_y']
+        
+        # ====== СПЕЦИАЛЬНЫЕ РЕЖИМЫ ======
+        
+        # Стереоскопия
+        if params.get('stereo_enabled', False):
+            eye = params.get('stereo_eye', 'left')
+            convergence = params.get('stereo_convergence', 0.5)
+            separation = params.get('stereo_separation', 0.065)
+            x = compute_stereoscopic_padding(x, req_pad_h, req_pad_w, eye, convergence, separation)
+        
+        # Анизотропный
+        elif mode_x == MODE_ANISOTROPIC or mode_y == MODE_ANISOTROPIC:
+            angle = params.get('anisotropic_angle', 45)
+            x = compute_anisotropic_padding(x, req_pad_h, req_pad_w, angle)
+        
+        # Полярный (сферический)
+        elif mode_x == MODE_POLAR or mode_y == MODE_POLAR:
+            x = compute_polar_padding(x, req_pad_h, req_pad_w)
+        
+        # Панорама
+        elif mode_x == MODE_PANORAMA or mode_y == MODE_PANORAMA:
+            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')
+        
+        # Blend
+        elif mode_x == MODE_BLEND or mode_y == MODE_BLEND:
+            blend_str = params.get('blend_strength', 0.1)
+            x = compute_blend_padding(x, req_pad_h, req_pad_w, blend_str)
+        
+        # Стандартные режимы (раздельно по осям)
+        else:
+            # Ось 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 = F.pad(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 = F.pad(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)
+        
+        # Мультиразрешение (адаптивная интенсивность)
+        if params.get('multires_enabled', False):
+            step_ratio = current_step / max(params['end_step'], 1)
+            if step_ratio < 0.3:
+                x_default = F.pad(input_tensor, (req_pad_w, req_pad_w, req_pad_h, req_pad_h), 
+                                 mode='constant', value=0)
+                alpha = step_ratio * 3
+                x = x * alpha + x_default * (1 - alpha)
+
+        # Выполнение свертки
+        return F.conv2d(x, weight, bias, stride, 0, dilation, groups)
+        
+    except Exception as e:
+        print(f"Advanced Tiling v3 Error: {e}")
+        return F.conv2d(input_tensor, weight, bias, stride, padding, dilation, groups)
+
+# ========================================================================
+# РЕГИСТРАЦИЯ KOHAKU SAMPLER
+# ========================================================================
+
+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
+    
+    # Добавляем функцию в k_diffusion.sampling
+    if not hasattr(k_diffusion.sampling, 'sample_kohaku_lonyu_yog'):
+        setattr(k_diffusion.sampling, 'sample_kohaku_lonyu_yog', sample_kohaku_lonyu_yog)
+    
+    # Создаем SamplerData
+    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!")
+
+# ========================================================================
+# КЛАСС СКРИПТА
+# ========================================================================
+
+class AdvancedTilingScriptV3(scripts.Script):
+    def title(self):
+        return "Advanced Tiling v3.0 PRO (Kohaku + Stereo + Aniso)"
+
+    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], 
+                            value=MODE_CIRCULAR
+                        )
+                        mode_y = gr.Dropdown(
+                            label="Mode Y", 
+                            choices=[MODE_OFF, MODE_CIRCULAR, MODE_MIRROR, MODE_HEXAGONAL], 
+                            value=MODE_CIRCULAR
+                        )
+                    
+                    with gr.Row():
+                        multires = gr.Checkbox(label="Multi-Resolution Mode", value=False)
+                        use_blend = gr.Checkbox(label="Soft Blend Edges", value=False)
+                        blend_strength = gr.Slider(0.0, 0.5, step=0.05, label="Blend Strength", value=0.1)
+                
+                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.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)")
+                
+                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_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.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)
+            
+            with gr.Row():
+                patch_vae = gr.Checkbox(label="Patch VAE Decoder", value=True,
+                                       info="Fix seams in final pixel decode")
+            
+            # Preview Tool
+            with gr.Accordion("🔍 Preview & Info", open=False):
+                with gr.Tabs():
+                    with gr.Tab("Visual Preview"):
+                        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_anisotropic, aniso_angle, 
+                                   stereo_enabled, stereo_eye],
+                            outputs=preview_img
+                        )
+                    
+                    with gr.Tab("Kohaku Info"):
+                        gr.Markdown("""
+                        ## 🔬 Kohaku_LoNyu_Yog Принцип работы
+                        
+                        **Геометрическая интерпретация:**
+                        1. Трёхмерное пространство - подпространство многомерного латентного
+                        2. Находим антипод `-x` (противоположная точка)
+                        3. Вычисляем градиенты `d` и `d2`
+                        4. `(d+d2)/2` - вектор к визуальному многообразию
+                        5. Корректируем позицию: `x_new = x + (d+d2)/2 * dt`
+                        6. Финальный градиент `d3` в новой точке
+                        7. Итоговый шаг: `(d+d3)/2`
+                        
+                        **Применение только на первой половине шагов** - на поздних стадиях
+                        траектория становится невыпуклой из-за деталей, метод отклоняется.
+                        
+                        **NFE (Function Evaluations):** ~3-4 на шаг (дороже стандартного Euler)
+                        **Рекомендуемые шаги:** 8-12 (вместо 20-30)
+                        """)
+
+        return [enabled, mode_x, mode_y, start_step, end_step, multires,
+                use_panorama, use_polar, use_blend, blend_strength, 
+                use_anisotropic, aniso_angle,
+                stereo_enabled, stereo_eye, stereo_separation, stereo_convergence,
+                patch_vae, use_kohaku]
+
+    def generate_preview(self, mx, my, use_aniso, aniso_angle, stereo, eye):
+        """Генерация preview с учетом новых режимов"""
+        h, w = 256, 256
+        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 i in range(h):
+                    for j in range(w):
+                        # Создаем направленный паттерн
+                        dist = abs((j-w/2)*np.cos(angle_rad) + (i-h/2)*np.sin(angle_rad))
+                        tile[i, j] = tile[i, j] * (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)
+
+        # Сборка 2x2
+        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
+
+    def process(self, p, enabled, mode_x, mode_y, start_step, end_step, multires,
+                use_panorama, use_polar, use_blend, blend_strength,
+                use_anisotropic, aniso_angle,
+                stereo_enabled, stereo_eye, stereo_separation, stereo_convergence,
+                patch_vae, use_kohaku):
+        
+        if not enabled:
+            return
+        
+        # Валидация
+        if start_step > end_step:
+            start_step, end_step = end_step, start_step
+        
+        # Регистрация Kohaku сэмплера
+        if use_kohaku:
+            register_kohaku_sampler()
+            # Автоматически переключаем на Kohaku если выбран другой
+            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'
+        
+        # Применение специальных режимов
+        if use_panorama:
+            mode_x = mode_y = MODE_PANORAMA
+        if use_polar:
+            mode_x = mode_y = MODE_POLAR
+        if use_blend:
+            mode_x = mode_y = MODE_BLEND
+        if use_anisotropic:
+            mode_x = mode_y = MODE_ANISOTROPIC
+        
+        # Параметры
+        params = {
+            'mode_x': mode_x,
+            'mode_y': mode_y,
+            'start_step': start_step,
+            'end_step': end_step,
+            'multires_enabled': multires,
+            'blend_strength': blend_strength,
+            'anisotropic_angle': aniso_angle,
+            'stereo_enabled': stereo_enabled,
+            'stereo_eye': stereo_eye,
+            'stereo_separation': stereo_separation,
+            'stereo_convergence': stereo_convergence
+        }
+        
+        # Патчинг 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
+        if patch_vae and hasattr(p.sd_model, 'first_stage_model'):
+            vae = p.sd_model.first_stage_model
+            count_vae = self.patch_conv_layers(vae, params)
+            print(f"✓ Patched {count_vae} VAE Conv2d layers")
+        
+        mode_str = f"{mode_x}/{mode_y}"
+        if stereo_enabled:
+            mode_str += f" + Stereo({stereo_eye})"
+        if use_kohaku:
+            mode_str += " + Kohaku"
+        
+        print(f"✓ Advanced Tiling v3.0: Mode={mode_str}, Steps={start_step}-{end_step}")
+
+    def patch_conv_layers(self, module, params):
+        """Патчинг с исправленным замыканием"""
+        count = 0
+        for layer in module.modules():
+            if isinstance(layer, torch.nn.Conv2d):
+                if layer.kernel_size == (1, 1) or layer.kernel_size == 1:
+                    continue
+                
+                if layer not in _ORIGINAL_METHODS_CACHE:
+                    _ORIGINAL_METHODS_CACHE[layer] = layer._conv_forward
+                
+                def make_patched(mod):
+                    def patched(input, weight, bias):
+                        return custom_padding_forward(
+                            input, weight, bias,
+                            mod.stride, mod.padding, mod.dilation, mod.groups,
+                            params
+                        )
+                    return patched
+                
+                layer._conv_forward = make_patched(layer)
+                count += 1
+        
+        return count
+
+    def get_unet(self, p):
+        """Универсальная детекция 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)
+
+    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()
+        
+        if restored > 0:
+            print(f"✓ Restored {restored} layers to original state")

asymmetric-tiling-sd-webui-2.0/Руководство Advanced Tiling v3.0 - Новые функции.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53b070cef1e7c4538d178cc577397b5571dfd041707a607ae0a0738545bf633b
+size 1214274

asymmetric-tiling-sd-webui-2.0/Руководство по новым функциям.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ddaf444239f26df5f49f65ff0bb28ae3fade21ca765e6de9b8c990940f3e21eb
+size 985644