Upload sd-webui-convenience-util using SD-Hub

sd-webui-convenience-util/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

sd-webui-convenience-util/scripts/build_sdxl_catalog.py

@@ -0,0 +1,593 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+SDXL Resolution Catalog Builder (with short-side packages & favorites/tags)
+Python 3.10+ (stdlib only)
+
+Назначение:
+  • Генерирует/расширяет каталог разрешений (SDXL/SD) с категориями:
+      - по аспектам (и портретные зеркала),
+      - по диапазонам мегапикселей (MP bands),
+      - по ориентации (landscape/portrait/square),
+      - по короткой стороне через именованные пакеты,
+      - с тегами/избранным.
+  • Экспортирует:
+      - sdxl_resolutions_by_aspect.txt   (читаемо + Flat list WxH),
+      - sdxl_resolutions_catalog.csv,
+      - sdxl_resolutions_catalog.json,
+      - sdxl_resolutions_catalog.yaml    (простой YAML без внешних пакетов).
+
+Почему без dataclasses:
+  В окружениях A1111 модульные загрузчики иногда импортируют скрипт так,
+  что в момент декоратора @dataclass модуль ещё не в sys.modules — это
+  ломает внутреннюю логику dataclasses в Py3.10. Мы избегаем этого, используя
+  обычный класс с __slots__.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import json
+import os
+import re
+import csv
+from math import gcd
+from typing import Iterable, List, Tuple, Dict, Optional
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Модель данных (без dataclasses: совместимо с импортом в A1111)
+# ──────────────────────────────────────────────────────────────────────────────
+
+class ResItem:
+    __slots__ = ("width", "height", "mp", "aspect", "orientation", "packages", "tags", "bucket_aspect")
+
+    def __init__(self,
+                 width: int,
+                 height: int,
+                 mp: float,
+                 aspect: str,
+                 orientation: str,
+                 packages: Optional[List[str]] = None,
+                 tags: Optional[List[str]] = None,
+                 bucket_aspect: Optional[str] = None):
+        self.width = int(width)
+        self.height = int(height)
+        self.mp = float(mp)
+        self.aspect = aspect                 # фактическая кратная дробь, например "1024:1536" → "2:3"
+        self.orientation = orientation
+        self.packages = list(packages or [])
+        self.tags = list(tags or [])
+        self.bucket_aspect = bucket_aspect or aspect  # целевой "ключ" секции (напр. "3:2"), если попали по tolerance
+
+    def to_dict(self) -> Dict:
+        return {
+            "width": self.width,
+            "height": self.height,
+            "mp": round(self.mp, 3),
+            "aspect": self.aspect,
+            "orientation": self.orientation,
+            "packages": list(self.packages),
+            "tags": list(self.tags),
+            "bucket_aspect": self.bucket_aspect,
+        }
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Утилиты
+# ──────────────────────────────────────────────────────────────────────────────
+
+def simplified_ratio(width: int, height: int) -> str:
+    if width <= 0 or height <= 0:
+        return "—"
+    g = gcd(width, height)
+    return f"{width // g}:{height // g}"
+
+def orientation_of(w: int, h: int) -> str:
+    if w == h:
+        return "square"
+    return "landscape" if w > h else "portrait"
+
+def megapixels(w: int, h: int) -> float:
+    return round((w * h) / 1_000_000.0, 3)
+
+def parse_wxh_pairs(text: str) -> List[Tuple[int, int]]:
+    """Достаёт все пары WxH (3-4 цифры) из произвольного текста; порядок сохраняем, дубли убираем."""
+    dims: List[Tuple[int, int]] = []
+    seen: set[Tuple[int, int]] = set()
+    for w, h in re.findall(r"(\d{3,4})x(\d{3,4})", text):
+        pair = (int(w), int(h))
+        if pair not in seen:
+            seen.add(pair)
+            dims.append(pair)
+    return dims
+
+def load_existing_dims(path: Optional[str]) -> List[Tuple[int, int]]:
+    if not path or not os.path.isfile(path):
+        return []
+    try:
+        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+            return parse_wxh_pairs(f.read())
+    except Exception:
+        return []
+
+def nearly_equal_ratio(w: int, h: int, ax: int, ay: int, tol: float) -> bool:
+    """Проверка близости w:h к ax:ay с допуском tol (например, 0.02 ~ 2%)."""
+    if w <= 0 or h <= 0 or ax <= 0 or ay <= 0:
+        return False
+    return abs((w / h) - (ax / ay)) <= tol
+
+def generate_grid(min_size: int, max_size: int, step: int) -> Iterable[Tuple[int, int]]:
+    sizes = list(range(min_size, max_size + 1, step))
+    for w in sizes:
+        for h in sizes:
+            yield w, h
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Парсеры CLI-аргументов (пакеты/теги)
+# ──────────────────────────────────────────────────────────────────────────────
+
+def parse_shortside_packs(s: str) -> Dict[str, List[int]]:
+    """
+    "name1:512,768,1024; name2:1152,1216,1344" -> {"name1":[512,768,1024], "name2":[...]}
+    """
+    packs: Dict[str, List[int]] = {}
+    if not s.strip():
+        return packs
+    for block in re.split(r"[;]+", s):
+        block = block.strip()
+        if not block:
+            continue
+        m = re.match(r"([^:]+):(.+)$", block)
+        if not m:
+            raise ValueError(f"Bad shortside pack: {block!r}. Expected 'name:val,val,...'")
+        name = m.group(1).strip()
+        vals = [int(x) for x in re.split(r"[,\s]+", m.group(2).strip()) if x.isdigit()]
+        if not vals:
+            raise ValueError(f"Empty values for pack {name!r}")
+        packs[name] = sorted(set(vals))
+    return packs
+
+def parse_favorites_inline(s: str) -> Dict[Tuple[int, int], List[str]]:
+    """
+    "1024x1536|fav,hero; 1152x1152|square; 1536x1024" ->
+      {(1024,1536): ['fav','hero'], (1152,1152): ['square'], (1536,1024): ['favorite']}
+    """
+    out: Dict[Tuple[int, int], List[str]] = {}
+    if not s.strip():
+        return out
+    for block in re.split(r"[;]+", s):
+        block = block.strip()
+        if not block:
+            continue
+        m = re.match(r"(\d{3,4})x(\d{3,4})(?:\s*\|\s*(.+))?$", block)
+        if not m:
+            raise ValueError(f"Bad favorites item: {block!r}. Expected 'WxH|tag1,tag2' or 'WxH'")
+        w, h = int(m.group(1)), int(m.group(2))
+        tags = []
+        if m.group(3):
+            tags = [t.strip() for t in re.split(r"[,\s]+", m.group(3)) if t.strip()]
+        if not tags:
+            tags = ["favorite"]
+        out[(w, h)] = sorted(set(tags))
+    return out
+
+def parse_favorites_file(path: Optional[str]) -> Dict[Tuple[int, int], List[str]]:
+    """
+    Файл, по строкам:
+      1024x1536 | fav,hero
+      1152x1152 | square
+      1536x1024
+    """
+    out: Dict[Tuple[int, int], List[str]] = {}
+    if not path or not os.path.isfile(path):
+        return out
+    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            m = re.match(r"(\d{3,4})x(\d{3,4})(?:\s*\|\s*(.+))?$", line)
+            if not m:
+                mm = re.search(r"(\d{3,4})x(\d{3,4})", line)
+                if not mm:
+                    continue
+                w, h = int(mm.group(1)), int(mm.group(2))
+                tags = ["favorite"]
+            else:
+                w, h = int(m.group(1)), int(m.group(2))
+                tags = []
+                if m.group(3):
+                    tags = [t.strip() for t in re.split(r"[,\s]+", m.group(3)) if t.strip()]
+                if not tags:
+                    tags = ["favorite"]
+            out[(w, h)] = sorted(set(tags))
+    return out
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Генерация/фильтрация каталога
+# ──────────────────────────────────────────────────────────────────────────────
+
+def build_catalog(
+    min_size: int,
+    max_size: int,
+    step: int,
+    multiple: int,
+    aspects: List[Tuple[int, int]],
+    tolerance: float,
+    merge_extra: List[Tuple[int, int]] | None = None,
+    min_mp: float = 0.0,
+    max_mp: float = 999.0,
+    shortside_packs: Dict[str, List[int]] | None = None,
+    favorites: Dict[Tuple[int, int], List[str]] | None = None,
+) -> List[ResItem]:
+    """
+    Генерирует сетку размеров, фильтрует по кратности/аспектам, размечает пакеты и теги.
+    ВАЖНО: пары, попавшие к аспекту по tolerance, в отчёте группируются в секции этого аспекта.
+    """
+    out: List[ResItem] = []
+    seen: set[Tuple[int, int]] = set()
+    packs = shortside_packs or {}
+    favs = favorites or {}
+
+    def packages_for(w: int, h: int) -> List[str]:
+        short = min(w, h)
+        res: List[str] = []
+        for name, values in packs.items():
+            if short in values:
+                res.append(name)
+        return sorted(set(res))
+
+    def tags_for(w: int, h: int) -> List[str]:
+        return favs.get((w, h), [])
+
+    def add_pair(w: int, h: int, bucket: str):
+        key = (w, h)
+        if key in seen:
+            return
+        mp = megapixels(w, h)
+        if mp < min_mp or mp > max_mp:
+            return
+        item = ResItem(
+            width=w,
+            height=h,
+            mp=mp,
+            aspect=simplified_ratio(w, h),
+            orientation=orientation_of(w, h),
+            packages=packages_for(w, h),
+            tags=tags_for(w, h),
+            bucket_aspect=bucket,
+        )
+        out.append(item)
+        seen.add(key)
+
+    # 1) Основная решётка
+    for w, h in generate_grid(min_size, max_size, step):
+        if multiple > 1 and (w % multiple != 0 or h % multiple != 0):
+            continue
+        # найдём первый подходящий аспект (точный или с допуском)
+        bucket: Optional[str] = None
+        for ax, ay in aspects:
+            if (w * ay) == (h * ax):  # точная кратность
+                bucket = f"{ax}:{ay}"
+                break
+            if nearly_equal_ratio(w, h, ax, ay, tolerance) or nearly_equal_ratio(w, h, ay, ax, tolerance):
+                bucket = f"{ax}:{ay}"
+                break
+        if not bucket:
+            continue
+        add_pair(w, h, bucket)
+
+    # 2) Слияние с существующим .txt
+    for w, h in merge_extra or []:
+        if multiple > 1 and (w % multiple != 0 or h % multiple != 0):
+            continue
+        bucket: Optional[str] = None
+        for ax, ay in aspects:
+            if (w * ay) == (h * ax) or nearly_equal_ratio(w, h, ax, ay, tolerance) or nearly_equal_ratio(w, h, ay, ax, tolerance):
+                bucket = f"{ax}:{ay}"
+                break
+        if not bucket:
+            continue
+        add_pair(w, h, bucket)
+
+    # Стабильная сортировка: по MP → ширине → высоте
+    out.sort(key=lambda r: (r.mp, r.width, r.height))
+    return out
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Экспорт
+# ──────────────────────────────────────────────────────────────────────────────
+
+def dump_txt_structured(
+    items: List[ResItem],
+    aspects: List[Tuple[int, int]],
+    mp_bands: List[Tuple[float, float]],
+    out_path: str,
+    header_title: str,
+    shortside_packs: Dict[str, List[int]],
+) -> None:
+    """
+    Структурированный .txt:
+      • Сводка
+      • Секции по аспектам → MP-бэндам → ориентациям (помечаем ★[tags] и {packages})
+      • Секция «Short-side packages»
+      • В конце — Flat list (только WxH)
+    """
+    # Группировка по "целевым" аспектам (ax:ay). Зеркала не создают новых ключей.
+    by_aspect: Dict[str, List[ResItem]] = {f"{ax}:{ay}": [] for (ax, ay) in aspects}
+    for it in items:
+        key = it.bucket_aspect
+        if key not in by_aspect:
+            by_aspect[key] = []
+        by_aspect[key].append(it)
+
+    def aspect_value(s: str) -> float:
+        try:
+            a, b = s.split(":")
+            return int(a) / int(b)
+        except Exception:
+            return 0.0
+
+    ordered_aspects = sorted(by_aspect.keys(), key=aspect_value)
+
+    def band_name(lo: float, hi: float) -> str:
+        return f"{lo:.2g}MP+" if hi >= 999 else f"{lo:.2g}–{hi:.2g}MP"
+
+    def mirror_label(s: str) -> str:
+        parts = s.split(":")
+        if len(parts) == 2:
+            return f"{parts[1]}:{parts[0]}"
+        return s
+
+    now = dt.datetime.now().strftime("%Y-%m-%d %H:%M")
+
+    with open(out_path, "w", encoding="utf-8") as f:
+        f.write(f"# {header_title}\n")
+        f.write(f"# Generated: {now}\n")
+        f.write("# File format: human-friendly sections + raw WxH pairs (backward-compatible)\n\n")
+
+        # Summary
+        total = len(items)
+        fav_total = sum(1 for it in items if it.tags)
+        f.write("## Summary\n")
+        f.write(f"- Total items: {total}\n")
+        f.write(f"- Favorites / tagged: {fav_total}\n")
+        f.write(f"- Aspects covered: {', '.join(ordered_aspects)}\n")
+        f.write(f"- MP bands: {', '.join([band_name(lo, hi) for lo, hi in mp_bands])}\n")
+        if shortside_packs:
+            f.write(f"- Short-side packs: {', '.join(f'{n}({len(v)})' for n, v in shortside_packs.items())}\n")
+        f.write("\n---\n\n")
+
+        # Секции по аспектам
+        for asp_key in ordered_aspects:
+            bucket = by_aspect[asp_key]
+            if not bucket:
+                continue
+            f.write(f"## Aspect {asp_key} / {mirror_label(asp_key)}\n\n")
+            for (lo, hi) in mp_bands:
+                band_items = [it for it in bucket if (it.mp >= lo and it.mp <= hi)]
+                if not band_items:
+                    continue
+                f.write(f"### MP band: {band_name(lo, hi)}\n\n")
+                for ori in ("landscape", "portrait", "square"):
+                    sub = [it for it in band_items if it.orientation == ori]
+                    if not sub:
+                        continue
+                    f.write(f"**{ori}**\n")
+                    line: List[str] = []
+                    for it in sub:
+                        label = f"{it.width}x{it.height}"
+                        if it.tags:
+                            label += " ★"
+                            label += f"[{','.join(it.tags)}]"
+                        if it.packages:
+                            label += f" {{{','.join(it.packages)}}}"
+                        line.append(label)
+                        if len(line) >= 6:
+                            f.write("- " + ", ".join(line) + "\n")
+                            line = []
+                    if line:
+                        f.write("- " + ", ".join(line) + "\n")
+                    f.write("\n")
+            f.write("\n")
+
+        # Пакеты по короткой стороне
+        if shortside_packs:
+            f.write("\n---\n\n")
+            f.write("## Short-side packages\n\n")
+            for name, values in shortside_packs.items():
+                f.write(f"### {name}\n")
+                pack_items = [it for it in items if name in it.packages]
+                if not pack_items:
+                    f.write("- (empty)\n\n")
+                    continue
+                # Группировка: short_side -> [items]
+                ss_map: Dict[int, List[ResItem]] = {}
+                for it in pack_items:
+                    short = min(it.width, it.height)
+                    ss_map.setdefault(short, []).append(it)
+                for short in sorted(ss_map.keys()):
+                    f.write(f"**short={short}**\n")
+                    group = sorted(ss_map[short], key=lambda r: (r.mp, r.orientation, r.width, r.height))
+                    line: List[str] = []
+                    for it in group:
+                        label = f"{it.width}x{it.height}"
+                        if it.tags:
+                            label += " ★"
+                            label += f"[{','.join(it.tags)}]"
+                        line.append(label)
+                        if len(line) >= 8:
+                            f.write("- " + ", ".join(line) + "\n")
+                            line = []
+                    if line:
+                        f.write("- " + ", ".join(line) + "\n")
+                    f.write("\n")
+
+        # Плоский список (для старых парсеров)
+        f.write("\n---\n")
+        f.write("# Flat list (WxH only)\n")
+        for it in items:
+            f.write(f"{it.width}x{it.height}\n")
+
+def dump_csv(items: List[ResItem], out_path: str) -> None:
+    with open(out_path, "w", newline="", encoding="utf-8") as f:
+        w = csv.writer(f)
+        w.writerow(["width", "height", "mp", "aspect", "orientation", "packages", "tags", "bucket_aspect"])
+        for it in items:
+            w.writerow([
+                it.width, it.height, round(it.mp, 3), it.aspect, it.orientation,
+                ";".join(it.packages), ";".join(it.tags), it.bucket_aspect
+            ])
+
+def dump_json(items: List[ResItem], out_path: str) -> None:
+    data = [it.to_dict() for it in items]
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+def dump_yaml(items: List[ResItem], out_path: str) -> None:
+    """Простой YAML без внешних либ."""
+    def esc(s: str) -> str:
+        return s.replace('\\', '\\\\').replace('"', '\\"')
+    with open(out_path, "w", encoding="utf-8") as f:
+        f.write("items:\n")
+        for it in items:
+            d = it.to_dict()
+            packs = ", ".join([f"\"{esc(p)}\"" for p in d["packages"]])
+            tags = ", ".join([f"\"{esc(t)}\"" for t in d["tags"]])
+            f.write("  - {\n")
+            f.write(f"      width: {d['width']},\n")
+            f.write(f"      height: {d['height']},\n")
+            f.write(f"      mp: {round(d['mp'], 3)},\n")
+            f.write(f"      aspect: \"{esc(d['aspect'])}\",\n")
+            f.write(f"      orientation: \"{esc(d['orientation'])}\",\n")
+            f.write(f"      packages: [{packs}],\n")
+            f.write(f"      tags: [{tags}],\n")
+            f.write(f"      bucket_aspect: \"{esc(d['bucket_aspect'])}\"\n")
+            f.write("    }\n")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# CLI
+# ──────────────────────────────────────────────────────────────────────────────
+
+def parse_aspects(s: str) -> List[Tuple[int, int]]:
+    out: List[Tuple[int, int]] = []
+    for tok in re.split(r"[;,]+", s):
+        tok = tok.strip()
+        if not tok:
+            continue
+        m = re.match(r"(\d+)\s*:\s*(\d+)$", tok)
+        if not m:
+            raise ValueError(f"Bad aspect token: {tok!r}")
+        out.append((int(m.group(1)), int(m.group(2))))
+    if not out:
+        raise ValueError("No aspects provided.")
+    return out
+
+def parse_bands(s: str) -> List[Tuple[float, float]]:
+    out: List[Tuple[float, float]] = []
+    for tok in re.split(r"[;,]+", s):
+        tok = tok.strip()
+        if not tok:
+            continue
+        m = re.match(r"(\d+(?:\.\d+)?)\s*-\s*(\d+(?:\.\d+)?)$", tok)
+        if not m:
+            raise ValueError(f"Bad mp band: {tok!r}, expected like '1-2'")
+        lo, hi = float(m.group(1)), float(m.group(2))
+        if lo > hi:
+            lo, hi = hi, lo
+        out.append((lo, hi))
+    if not out:
+        raise ValueError("No mp bands provided.")
+    return out
+
+def main():
+    ap = argparse.ArgumentParser(description="Build expanded SDXL resolution catalog.")
+    ap.add_argument("--min", dest="min_size", type=int, default=512, help="Minimum side, px")
+    ap.add_argument("--max", dest="max_size", type=int, default=4096, help="Maximum side, px")
+    ap.add_argument("--step", type=int, default=64, help="Grid step, px")
+    ap.add_argument("--multiple", type=int, default=64, help="Required multiple for both sides, px")
+    ap.add_argument("--tolerance", type=float, default=0.02, help="Aspect tolerance (e.g., 0.02 ~ 2%)")
+    ap.add_argument("--aspects", type=str,
+                    default="1:1,3:2,2:3,4:3,3:4,5:4,4:5,7:4,4:7,16:9,9:16,21:9,9:21",
+                    help="Comma-separated list like '1:1,16:9,9:16'")
+    ap.add_argument("--mp-bands", type=str, default="0-1,1-2,2-3,3-4,4-6,6-8",
+                    help="Comma-separated MP bands, e.g. '0-1,1-2,2-3'")
+    ap.add_argument("--merge", type=str, default="", help="Optional path to existing .txt with WxH to merge")
+    ap.add_argument("--out-dir", type=str, default=".", help="Output directory")
+
+    # Новые аргументы:
+    ap.add_argument("--shortside-packs", type=str, default="",
+                    help="Short-side packages: 'name:512,768; name2:1024,1152'")
+    ap.add_argument("--favorites", type=str, default="",
+                    help="Inline favorites/tags: '1024x1536|fav,hero; 1152x1152|square; 1536x1024'")
+    ap.add_argument("--favorites-file", type=str, default="",
+                    help="File with favorites (WxH | tags) per line")
+
+    args = ap.parse_args()
+
+    # Валидации/приведения
+    min_size = max(128, int(args.min_size))
+    max_size = min(8192, max(min_size, int(args.max_size)))
+    step = max(8, int(args.step))
+    multiple = max(1, int(args.multiple))
+    tol = max(0.0, float(args.tolerance))
+    aspects = parse_aspects(args.aspects)
+    bands = parse_bands(args.mp_bands)
+    merge_dims = load_existing_dims(args.merge)
+
+    shortside_packs = parse_shortside_packs(args.shortside_packs)
+    favorites_inline = parse_favorites_inline(args.favorites)
+    favorites_file = parse_favorites_file(args.favorites_file)
+    favorites: Dict[Tuple[int, int], List[str]] = dict(favorites_file)
+    favorites.update(favorites_inline)  # inline приоритетнее
+
+    # Сборка каталога
+    items = build_catalog(
+        min_size=min_size,
+        max_size=max_size,
+        step=step,
+        multiple=multiple,
+        aspects=aspects,
+        tolerance=tol,
+        merge_extra=merge_dims,
+        min_mp=min(b[0] for b in bands) if bands else 0.0,
+        max_mp=max(b[1] for b in bands) if bands else 999.0,
+        shortside_packs=shortside_packs,
+        favorites=favorites,
+    )
+
+    # Пути
+    os.makedirs(args.out_dir, exist_ok=True)
+    out_txt = os.path.join(args.out_dir, "sdxl_resolutions_by_aspect.txt")
+    out_csv = os.path.join(args.out_dir, "sdxl_resolutions_catalog.csv")
+    out_json = os.path.join(args.out_dir, "sdxl_resolutions_catalog.json")
+    out_yaml = os.path.join(args.out_dir, "sdxl_resolutions_catalog.yaml")
+
+    # Заголовок
+    header_title = (
+        f"SDXL Resolution Catalog — range {min_size}..{max_size} step={step} "
+        f"multiple={multiple} tol={tol} (aspects: {', '.join([f'{a}:{b}' for a,b in aspects])})"
+    )
+
+    # Экспорт
+    dump_txt_structured(items, aspects, bands, out_txt, header_title, shortside_packs)
+    dump_csv(items, out_csv)
+    dump_json(items, out_json)
+    dump_yaml(items, out_yaml)
+
+    # Короткий отчёт
+    print(f"[OK] Items: {len(items)}")
+    print(f"[OK] Wrote: {out_txt}")
+    print(f"[OK] Wrote: {out_csv}")
+    print(f"[OK] Wrote: {out_json}")
+    print(f"[OK] Wrote: {out_yaml}")
+
+
+if __name__ == "__main__":
+    main()

sd-webui-convenience-util/scripts/conv_ui.py

@@ -0,0 +1,592 @@
+# Image Ratio & Resolution Catalog Pro — enhanced
+# Python 3.10+; gradio >= 3.32; pillow >= 9.0
+
+from __future__ import annotations
+
+import math
+import re
+import os
+import io
+from math import gcd, lcm
+from typing import List, Tuple, Literal, Dict, Optional
+
+import gradio as gr
+from PIL import Image
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Базовые утилиты
+# ──────────────────────────────────────────────────────────────────────────────
+
+RoundingMode = Literal["round", "floor", "ceil"]
+ModelFamily = Literal["SDXL (native~1024)", "SD 1.x (native~512)", "SD 2.x (native~768)"]
+
+DEFAULT_MODEL_FAMILY: ModelFamily = "SDXL (native~1024)"
+
+def ensure_multiple(value: int, multiple: int, mode: RoundingMode = "round") -> int:
+    if multiple <= 1:
+        return max(1, value)
+    q, r = divmod(value, multiple)
+    if r == 0:
+        return max(multiple, value)
+    if mode == "floor":
+        return max(multiple, q * multiple)
+    if mode == "ceil":
+        return (q + 1) * multiple
+    lower = q * multiple
+    upper = (q + 1) * multiple
+    return upper if (value - lower) >= (upper - value) else lower
+
+def simplified_ratio(width: int, height: int) -> str:
+    if width <= 0 or height <= 0:
+        return "—"
+    g = gcd(width, height)
+    return f"{width // g}:{height // g}"
+
+def megapixels(width: int, height: int) -> float:
+    return round((width * height) / 1_000_000.0, 3)
+
+def parse_dims(text: str) -> List[Tuple[int, int]]:
+    """Вытягивает все пары 'WxH' из произвольного текста."""
+    dims: List[Tuple[int, int]] = []
+    for w, h in re.findall(r"(\d{3,4})x(\d{3,4})", text):
+        dims.append((int(w), int(h)))
+    # удалим дубликаты, сохраняя порядок
+    seen = set()
+    uniq: List[Tuple[int, int]] = []
+    for d in dims:
+        if d not in seen:
+            seen.add(d)
+            uniq.append(d)
+    return uniq
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Автоподбор кратности (multiple)
+# ──────────────────────────────────────────────────────────────────────────────
+
+def pick_base_multiple_by_model(model_family: ModelFamily, target_max_side: Optional[int] = None) -> int:
+    """
+    Эвристика:
+      - SDXL: кратность 64 (родной 1024, датасеты шагом 64).
+      - SD 2.x: минимум 16..32, чаще 32 в HD.
+      - SD 1.x: минимум 8..16, чаще 32 в HD.
+    """
+    if model_family == "SDXL (native~1024)":
+        base = 64
+    elif model_family == "SD 2.x (native~768)":
+        base = 32
+    else:  # SD 1.x
+        base = 32
+    if target_max_side and target_max_side >= 1536:
+        base = max(base, 64)
+    return base
+
+def combine_multiples(base_multiple: int, diffusion_tile: int = 0, vae_tile: int = 0) -> int:
+    """
+    Объединяем ограничения: НОК(base_multiple, diffusion_tile, vae_tile).
+    Нули игнорируются. Жёстко ограничим верх до 256.
+    """
+    m = base_multiple
+    for x in (diffusion_tile, vae_tile):
+        if isinstance(x, int) and x >= 8:
+            m = lcm(m, x)
+    return max(8, min(m, 256))
+
+def explain_auto_multiple(model_family: ModelFamily, max_side: Optional[int], m_base: int, m_final: int,
+                          diffusion_tile: int, vae_tile: int) -> str:
+    reasons = [f"модель: {model_family} -> base={m_base}"]
+    if max_side:
+        reasons.append(f"размер цели: ~{max_side}px")
+    if diffusion_tile:
+        reasons.append(f"diffusion tile={diffusion_tile}")
+    if vae_tile:
+        reasons.append(f"VAE tile={vae_tile}")
+    if m_final != m_base:
+        reasons.append(f"НОК -> {m_final}")
+    return " | ".join(reasons)
+
+def autopick_multiple(model_family: ModelFamily,
+                      diffusion_tile: int,
+                      vae_tile: int,
+                      width_hint: Optional[int],
+                      height_hint: Optional[int]) -> Tuple[int, str]:
+    max_side = None
+    if width_hint and height_hint:
+        max_side = max(width_hint, height_hint)
+    m_base = pick_base_multiple_by_model(model_family, max_side)
+    m_final = combine_multiples(m_base, diffusion_tile, vae_tile)
+    return m_final, explain_auto_multiple(model_family, max_side, m_base, m_final, diffusion_tile, vae_tile)
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Ресайзы по изображению
+# ──────────────────────────────────────────────────────────────────────────────
+
+def resize_by_shorter_side(image: Image.Image, target_shorter: int, multiple: int, mode: RoundingMode) -> Tuple[int, int]:
+    w, h = image.size
+    if w <= 0 or h <= 0 or target_shorter <= 0:
+        return w, h
+    scale = target_shorter / min(w, h)
+    new_w = ensure_multiple(int(round(w * scale)), multiple, mode)
+    new_h = ensure_multiple(int(round(h * scale)), multiple, mode)
+    return new_w, new_h
+
+def resize_to_pixel_count(image: Image.Image, target_pixels: int, multiple: int, mode: RoundingMode) -> Tuple[int, int]:
+    w, h = image.size
+    if w <= 0 or h <= 0 or target_pixels <= 0:
+        return w, h
+    scale = math.sqrt(target_pixels / (w * h))
+    new_w = ensure_multiple(int(round(w * scale)), multiple, mode)
+    new_h = ensure_multiple(int(round(h * scale)), multiple, mode)
+    return new_w, new_h
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Каталог разрешений: загрузка/генерация/фильтрация
+# ──────────────────────────────────────────────────────────────────────────────
+
+def load_catalog_from_file(path: str) -> List[Tuple[int, int]]:
+    if not os.path.isfile(path):
+        return []
+    try:
+        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+            text = f.read()
+        return parse_dims(text)
+    except Exception:
+        return []
+
+_GRID_CACHE: Dict[Tuple[int, int, int], List[Tuple[int, int]]] = {}
+
+def generate_grid_catalog(min_size: int, max_size: int, step: int) -> List[Tuple[int, int]]:
+    """Генерация полной решётки кратных 'step' размеров в диапазоне [min_size, max_size], с кэшем."""
+    key = (min_size, max_size, step)
+    cached = _GRID_CACHE.get(key)
+    if cached is not None:
+        return cached
+    sizes = list(range(min_size, max_size + 1, step))
+    out: List[Tuple[int, int]] = []
+    for w in sizes:
+        for h in sizes:
+            out.append((w, h))
+    _GRID_CACHE[key] = out
+    return out
+
+def orientation_of(w: int, h: int) -> str:
+    if w == h:
+        return "square"
+    return "landscape" if w > h else "portrait"
+
+def aspect_tuple(w: int, h: int) -> Tuple[int, int]:
+    g = gcd(w, h)
+    return (w // g, h // g)
+
+def _parse_aspect_tokens(aspect_str: str) -> List[Tuple[int, int, bool, float]]:
+    """
+    Поддерживаем токены:
+      - 'A:B'         → точное совпадение
+      - '~A:B'        → приблизительное (±0.02 по умолчанию)
+      - 'A:B@0.03'    → точный A:B, но с допуском 0.03 (редкий кейс)
+      - '~A:B@0.015'  → приблизительный матч с явным допуском
+    Возвращает список (ax, ay, approx, tol).
+    """
+    out: List[Tuple[int, int, bool, float]] = []
+    if not aspect_str.strip():
+        return out
+    tokens = [t.strip() for t in re.split(r"[;,]+", aspect_str) if t.strip()]
+    for t in tokens:
+        approx = t.startswith("~")
+        if approx:
+            t = t[1:].strip()
+        tol = 0.02 if approx else 0.0
+        m = re.match(r"(\d+)\s*:\s*(\d+)(?:\s*@\s*(0\.\d+))?$", t)
+        if not m:
+            # проигнорируем кривые токены
+            continue
+        ax, ay = int(m.group(1)), int(m.group(2))
+        if m.group(3):
+            tol = float(m.group(3))
+        out.append((ax, ay, approx or tol > 0.0, tol))
+    return out
+
+def filter_catalog(catalog: List[Tuple[int, int]],
+                   min_width: int, max_width: int,
+                   min_height: int, max_height: int,
+                   min_mp: float, max_mp: float,
+                   multiple: int,
+                   orientation: str,           # any|square|landscape|portrait
+                   aspect_str: str,            # "", "16:9, 4:3", "~3:2", "21:9@0.03"
+                   limit: int,
+                   sort_key: str,             # "MP", "Width", "Height"
+                   sort_desc: bool) -> List[Dict]:
+    aspect_tokens = _parse_aspect_tokens(aspect_str)
+
+    rows: List[Dict] = []
+    for (w, h) in catalog:
+        if w < min_width or w > max_width:
+            continue
+        if h < min_height or h > max_height:
+            continue
+        if multiple > 1 and (w % multiple != 0 or h % multiple != 0):
+            continue
+        mp = (w * h) / 1_000_000.0
+        if mp < min_mp or mp > max_mp:
+            continue
+        ori = orientation_of(w, h)
+        if orientation != "any" and ori != orientation:
+            continue
+
+        # аспект-фильтр
+        if aspect_tokens:
+            w0, h0 = aspect_tuple(w, h)
+            ok = False
+            for ax, ay, approx, tol in aspect_tokens:
+                if approx:
+                    if abs((w / h) - (ax / ay)) <= (tol if tol > 0 else 0.02):
+                        ok = True
+                        break
+                else:
+                    if (w0, h0) == (ax, ay):
+                        ok = True
+                        break
+            if not ok:
+                continue
+
+        rows.append({
+            "Width": w,
+            "Height": h,
+            "Aspect": f"{aspect_tuple(w,h)[0]}:{aspect_tuple(w,h)[1]}",
+            "Orientation": ori,
+            "MP": round(mp, 3)
+        })
+
+    # сортировка
+    key = {
+        "MP": lambda r: r["MP"],
+        "Width": lambda r: r["Width"],
+        "Height": lambda r: r["Height"],
+    }.get(sort_key, lambda r: (r["MP"], r["Width"], r["Height"]))
+    rows.sort(key=key, reverse=sort_desc)
+
+    return rows[:limit]
+
+def stringify_wh_list(rows: List[Dict]) -> str:
+    return "\n".join(f"{r['Width']}x{r['Height']}" for r in rows)
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Gradio UI
+# ──────────────────────────────────────────────────────────────────────────────
+
+DEFAULT_SHORT_PRESETS = ["512", "768", "896"]
+DEFAULT_PIXEL_BASES = ["512", "640", "768", "832", "896", "1024", "1152", "1216", "1344", "1536"]
+
+ROUNDING_CHOICES: List[RoundingMode] = ["round", "floor", "ceil"]
+
+def _parse_int_list(str_list: List[str]) -> List[int]:
+    out: List[int] = []
+    for s in str_list or []:
+        m = re.search(r"\d+", s)
+        if m:
+            out.append(int(m.group(0)))
+    return out
+
+# ——— Вычисления по загруженному изображению ——————————————————————————————
+
+def calculate_all(
+    image: Image.Image,
+    shorters_raw: List[str],
+    bases_raw: List[str],
+    use_autopick: bool,
+    model_family: ModelFamily,
+    diffusion_tile: int,
+    vae_tile: int,
+    manual_multiple: int,
+    rounding_mode: RoundingMode,
+):
+    if image is None:
+        raise gr.Error("Загрузите изображение слева.")
+
+    w, h = image.size
+
+    if use_autopick:
+        m_auto, reason = autopick_multiple(model_family, diffusion_tile, vae_tile, w, h)
+        rounding_multiple = m_auto
+        reason_text = f"Auto multiple = **{m_auto}** — {reason}"
+    else:
+        rounding_multiple = manual_multiple
+        reason_text = f"Manual multiple = **{manual_multiple}**"
+
+    shorters = _parse_int_list(shorters_raw) or _parse_int_list(DEFAULT_SHORT_PRESETS)
+    bases = _parse_int_list(bases_raw) or _parse_int_list(DEFAULT_PIXEL_BASES)
+
+    rows = []
+
+    # Короткая сторона
+    for s in shorters:
+        nw, nh = resize_by_shorter_side(image, s, rounding_multiple, rounding_mode)
+        rows.append({
+            "Preset": f"short={s}",
+            "Width": nw,
+            "Height": nh,
+            "Aspect": simplified_ratio(nw, nh),
+            "Pixels": nw * nh,
+            "MP": megapixels(nw, nh),
+        })
+
+    # По количеству пикселей (N^2)
+    for base in bases:
+        target_pixels = base * base
+        nw, nh = resize_to_pixel_count(image, target_pixels, rounding_multiple, rounding_mode)
+        rows.append({
+            "Preset": f"{base}² ({target_pixels:,})",
+            "Width": nw,
+            "Height": nh,
+            "Aspect": simplified_ratio(nw, nh),
+            "Pixels": nw * nh,
+            "MP": megapixels(nw, nh),
+        })
+
+    original_info = f"Original: {w}x{h}  |  Aspect {simplified_ratio(w, h)}  |  {megapixels(w, h)} MP"
+    return rows, stringify_wh_list(rows), original_info, reason_text
+
+# ——— Каталог: загрузка/фильтр/экспорт ——————————————————————————————————————
+
+CATALOG_PATH = os.path.join(os.getcwd(), "sdxl_resolutions_by_aspect.txt")  # ищем и в /mnt/data
+_LOADED_CATALOG: Optional[List[Tuple[int, int]]] = None
+
+def _load_or_generate(default_step: int) -> Tuple[List[Tuple[int, int]], str]:
+    global _LOADED_CATALOG
+    if _LOADED_CATALOG is None:
+        candidates = [
+            CATALOG_PATH,
+            os.path.join(os.getcwd(), "data", "sdxl_resolutions_by_aspect.txt"),
+            "/mnt/data/sdxl_resolutions_by_aspect.txt",
+        ]
+        for p in candidates:
+            cat = load_catalog_from_file(p)
+            if cat:
+                _LOADED_CATALOG = cat
+                return _LOADED_CATALOG, f"Catalog: loaded from file ({len(cat)} items)."
+        _LOADED_CATALOG = []
+    return _LOADED_CATALOG, f"Catalog: no file, you can GENERATE grid (step {default_step})."
+
+def catalog_filter_action(
+    use_file_catalog: bool,
+    generate_min: int,
+    generate_max: int,
+    generate_step: int,
+    filter_min_w: int,
+    filter_max_w: int,
+    filter_min_h: int,
+    filter_max_h: int,
+    filter_min_mp: float,
+    filter_max_mp: float,
+    filter_multiple: int,
+    filter_orientation: str,
+    filter_aspects: str,
+    filter_limit: int,
+    sort_key: str,
+    sort_desc: bool,
+):
+    base_list, inf = _load_or_generate(generate_step)
+    if use_file_catalog and base_list:
+        catalog = base_list
+        source = inf.replace("Catalog:", "Source:")
+    else:
+        # safety
+        generate_min = max(128, generate_min)
+        generate_max = min(4096, max(generate_min, generate_max))
+        generate_step = max(8, generate_step)
+        sizes = list(range(generate_min, generate_max + 1, generate_step))
+        est = len(sizes) ** 2
+        if est > 20000:
+            # при слишком больших объёмах — подрежем диапазон по центру
+            mid = (generate_min + generate_max) // 2
+            half = max(generate_step * 5, (generate_max - generate_min) // 6)
+            generate_min = max(128, mid - half)
+            generate_max = min(4096, mid + half)
+        catalog = generate_grid_catalog(generate_min, generate_max, generate_step)
+        source = f"Source: generated grid {generate_min}..{generate_max} step={generate_step} ({len(catalog)} combos)"
+
+    rows = filter_catalog(
+        catalog=catalog,
+        min_width=filter_min_w, max_width=filter_max_w,
+        min_height=filter_min_h, max_height=filter_max_h,
+        min_mp=filter_min_mp, max_mp=filter_max_mp,
+        multiple=filter_multiple,
+        orientation=filter_orientation,
+        aspect_str=filter_aspects,
+        limit=filter_limit,
+        sort_key=sort_key,
+        sort_desc=sort_desc,
+    )
+    return rows, stringify_wh_list(rows), source
+
+def _rows_to_csv_bytes(rows: List[Dict]) -> bytes:
+    import csv
+    from io import StringIO
+    buf = StringIO()
+    w = csv.writer(buf)
+    w.writerow(["Width", "Height", "Aspect", "Orientation", "MP"])
+    for r in rows:
+        w.writerow([r["Width"], r["Height"], r["Aspect"], r["Orientation"], r["MP"]])
+    return buf.getvalue().encode("utf-8")
+
+def _rows_to_json_bytes(rows: List[Dict]) -> bytes:
+    import json
+    return json.dumps(rows, ensure_ascii=False, indent=2).encode("utf-8")
+
+def export_rows(rows: List[Dict], kind: str):
+    """Возвращает tuple(filename, bytes) для gr.File()"""
+    if not rows:
+        raise gr.Error("Нет данных для экспорта — сначала примените фильтр.")
+    if kind == "csv":
+        data = _rows_to_csv_bytes(rows)
+        name = "filtered_catalog.csv"
+    else:
+        data = _rows_to_json_bytes(rows)
+        name = "filtered_catalog.json"
+    path = os.path.join(os.getcwd(), name)
+    with open(path, "wb") as f:
+        f.write(data)
+    return path
+
+# ──────────────────────────────────────────────────────────────────────────────
+# UI
+# ──────────────────────────────────────────────────────────────────────────────
+
+def on_ui_tab_called():
+    with gr.Blocks() as ui:
+        gr.Markdown("### 📐 Image Ratio & Resolution Catalog Pro  \n"
+                    "Используйте файл SDXL пресетов, либо генерируйте сетку.  "
+                    "Аспекты поддерживают токены `16:9, ~3:2, 21:9@0.03, ~9:16@0.015`.")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                image = gr.Image(type="pil", source="upload", label="Изображение")
+                original_info = gr.Markdown("")
+
+            with gr.Column(scale=1):
+                # Авто/ручная кратность
+                use_autopick = gr.Checkbox(value=True, label="Auto multiple (рекомендуется)")
+                model_family = gr.Radio(
+                    choices=["SDXL (native~1024)", "SD 1.x (native~512)", "SD 2.x (native~768)"],
+                    value=DEFAULT_MODEL_FAMILY,
+                    label="Model family (ручной выбор)"
+                )
+                with gr.Row():
+                    diffusion_tile = gr.Number(value=0, precision=0, label="Diffusion tile (px, 0=нет)")
+                    vae_tile = gr.Number(value=0, precision=0, label="VAE tile (px, 0=нет)")
+                manual_multiple = gr.Slider(minimum=8, maximum=256, step=8, value=64, label="Manual multiple")
+                rounding_mode = gr.Radio(choices=["round", "floor", "ceil"], value="round", label="Режим округления")
+                auto_reason = gr.Markdown("")
+
+        with gr.Row():
+            with gr.Column():
+                shorters = gr.CheckboxGroup(
+                    choices=DEFAULT_SHORT_PRESETS,
+                    value=DEFAULT_SHORT_PRESETS,
+                    label="Цели по короткой стороне (px)",
+                )
+                pixel_bases = gr.CheckboxGroup(
+                    choices=DEFAULT_PIXEL_BASES,
+                    value=DEFAULT_PIXEL_BASES,
+                    label="Цели по общему числу пикселей (берётся N²)",
+                )
+                run_btn = gr.Button("Рассчитать", variant="primary")
+
+            with gr.Column():
+                results = gr.Dataframe(
+                    headers=["Preset", "Width", "Height", "Aspect", "Pixels", "MP"],
+                    datatype=["str", "number", "number", "str", "number", "number"],
+                    label="Результаты",
+                    interactive=False,
+                    wrap=True,
+                    overflow_row_behaviour="paginate",
+                )
+                copy_box = gr.Textbox(label="Список WxH (для копирования)", lines=8, interactive=False)
+
+        # Каталог разрешений (импорт/генерация/фильтры)
+        gr.Markdown("---")
+        gr.Markdown("#### Каталог разрешений (импорт из файла или генерация сетки)")
+
+        with gr.Row():
+            use_file_catalog = gr.Checkbox(value=True, label="Использовать файл, если найден (SDXL пресеты)")
+            generate_min = gr.Slider(minimum=128, maximum=4096, step=8, value=512, label="Generate: min")
+            generate_max = gr.Slider(minimum=128, maximum=4096, step=8, value=2048, label="Generate: max")
+            generate_step = gr.Slider(minimum=8, maximum=256, step=8, value=64, label="Generate: step")
+
+        with gr.Row():
+            filter_min_w = gr.Slider(minimum=128, maximum=4096, step=8, value=512, label="min Width")
+            filter_max_w = gr.Slider(minimum=128, maximum=4096, step=8, value=2048, label="max Width")
+            filter_min_h = gr.Slider(minimum=128, maximum=4096, step=8, value=512, label="min Height")
+            filter_max_h = gr.Slider(minimum=128, maximum=4096, step=8, value=2048, label="max Height")
+
+        with gr.Row():
+            filter_min_mp = gr.Number(value=0.0, label="min MP")
+            filter_max_mp = gr.Number(value=8.0, label="max MP")
+            filter_multiple = gr.Slider(minimum=8, maximum=256, step=8, value=64, label="Требуемая кратность")
+            filter_orientation = gr.Dropdown(choices=["any", "square", "landscape", "portrait"], value="any", label="Ориентация")
+            filter_aspects = gr.Textbox(value="", label="Аспекты (пример: '16:9, ~3:2, 21:9@0.03')")
+
+        with gr.Row():
+            filter_limit = gr.Slider(minimum=10, maximum=5000, step=10, value=500, label="Лимит результатов")
+            sort_key = gr.Dropdown(choices=["MP", "Width", "Height"], value="MP", label="Сортировать по")
+            sort_desc = gr.Checkbox(value=True, label="По убыванию")
+            apply_filters = gr.Button("Применить фильтры", variant="primary")
+
+        catalog_df = gr.Dataframe(
+            headers=["Width", "Height", "Aspect", "Orientation", "MP"],
+            datatype=["number", "number", "str", "str", "number"],
+            label="Каталог (фильтрованный)",
+            interactive=False,
+            wrap=True,
+            overflow_row_behaviour="paginate",
+        )
+        catalog_copy = gr.Textbox(label="Список WxH (для копирования)", lines=12, interactive=False)
+        catalog_source = gr.Markdown("")
+
+        with gr.Row():
+            export_csv_btn = gr.Button("Скачать CSV")
+            export_json_btn = gr.Button("Скачать JSON")
+            exported_file = gr.File(label="Экспорт", visible=True)
+
+        # — Автозапуски/связи —
+        def _toggle_manual(m_use_auto: bool):
+            return gr.update(interactive=not m_use_auto)
+
+        use_autopick.change(fn=_toggle_manual, inputs=[use_autopick], outputs=[manual_multiple])
+
+        for trigger in (image.upload, run_btn.click):
+            trigger(
+                fn=calculate_all,
+                inputs=[image, shorters, pixel_bases, use_autopick, model_family, diffusion_tile, vae_tile, manual_multiple, rounding_mode],
+                outputs=[results, copy_box, original_info, auto_reason],
+                show_progress=False,
+            )
+
+        apply_filters.click(
+            fn=catalog_filter_action,
+            inputs=[
+                use_file_catalog, generate_min, generate_max, generate_step,
+                filter_min_w, filter_max_w, filter_min_h, filter_max_h,
+                filter_min_mp, filter_max_mp, filter_multiple,
+                filter_orientation, filter_aspects, filter_limit,
+                sort_key, sort_desc
+            ],
+            outputs=[catalog_df, catalog_copy, catalog_source],
+            show_progress=False
+        )
+
+        export_csv_btn.click(lambda rows: export_rows(rows, "csv"), inputs=[catalog_df], outputs=[exported_file])
+        export_json_btn.click(lambda rows: export_rows(rows, "json"), inputs=[catalog_df], outputs=[exported_file])
+
+    return (ui, "calculator+", "calculator_plus_interface"),
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Регистрация в A1111 или автономный запуск
+# ──────────────────────────────────────────────────────────────────────────────
+try:
+    from modules import script_callbacks  # type: ignore
+    script_callbacks.on_ui_tabs(on_ui_tab_called)
+except (ImportError, ModuleNotFoundError):
+    if __name__ == "__main__":
+        interface, _, _ = on_ui_tab_called()[0]
+        interface.launch()

sd-webui-convenience-util/scripts/sdxl_resolutions_by_aspect.txt

@@ -0,0 +1,2289 @@
+Stable Diffusion XL – Полный список разрешений (512–2048, шаг 64)
+
+Всего комбинаций: 625
+
+======================================================================
+
+
+=== Квадратное ===
+
+
+Соотношение 1:1:
+
+512x512, 576x576, 640x640, 704x704, 768x768, 832x832, 896x896, 960x960, 1024x1024, 1088x1088, 1152x1152, 1216x1216, 1280x1280, 1344x1344, 1408x1408, 1472x1472, 1536x1536, 1600x1600, 1664x1664, 1728x1728, 1792x1792, 1856x1856, 1920x1920, 1984x1984, 2048x2048
+
+
+=== Альбомное (Landscape) ===
+
+
+Соотношение 32:31:
+
+2048x1984
+
+
+Соотношение 31:30:
+
+1984x1920
+
+
+Соотношение 30:29:
+
+1920x1856
+
+
+Соотношение 29:28:
+
+1856x1792
+
+
+Соотношение 28:27:
+
+1792x1728
+
+
+Соотношение 27:26:
+
+1728x1664
+
+
+Соотношение 26:25:
+
+1664x1600
+
+
+Соотношение 25:24:
+
+1600x1536
+
+
+Соотношение 24:23:
+
+1536x1472
+
+
+Соотношение 23:22:
+
+1472x1408
+
+
+Соотношение 22:21:
+
+1408x1344
+
+
+Соотношение 21:20:
+
+1344x1280
+
+
+Соотношение 20:19:
+
+1280x1216
+
+
+Соотношение 19:18:
+
+1216x1152
+
+
+Соотношение 18:17:
+
+1152x1088
+
+
+Соотношение 17:16:
+
+1088x1024
+
+
+Соотношение 16:15:
+
+1024x960, 2048x1920
+
+
+Соотношение 31:29:
+
+1984x1856
+
+
+Соотношение 15:14:
+
+960x896, 1920x1792
+
+
+Соотношение 29:27:
+
+1856x1728
+
+
+Соотношение 14:13:
+
+896x832, 1792x1664
+
+
+Соотношение 27:25:
+
+1728x1600
+
+
+Соотношение 13:12:
+
+832x768, 1664x1536
+
+
+Соотношение 25:23:
+
+1600x1472
+
+
+Соотношение 12:11:
+
+768x704, 1536x1408
+
+
+Соотношение 23:21:
+
+1472x1344
+
+
+Соотношение 11:10:
+
+704x640, 1408x1280
+
+
+Соотношение 32:29:
+
+2048x1856
+
+
+Соотношение 21:19:
+
+1344x1216
+
+
+Соотношение 31:28:
+
+1984x1792
+
+
+Соотношение 10:9:
+
+640x576, 1280x1152, 1920x1728
+
+
+Соотношение 29:26:
+
+1856x1664
+
+
+Соотношение 19:17:
+
+1216x1088
+
+
+Соотношение 28:25:
+
+1792x1600
+
+
+Соотношение 9:8:
+
+576x512, 1152x1024, 1728x1536
+
+
+Соотношение 26:23:
+
+1664x1472
+
+
+Соотношение 17:15:
+
+1088x960
+
+
+Соотношение 25:22:
+
+1600x1408
+
+
+Соотношение 8:7:
+
+1024x896, 1536x1344, 2048x1792
+
+
+Соотношение 31:27:
+
+1984x1728
+
+
+Соотношение 23:20:
+
+1472x1280
+
+
+Соотношение 15:13:
+
+960x832, 1920x1664
+
+
+Соотношение 22:19:
+
+1408x1216
+
+
+Соотношение 29:25:
+
+1856x1600
+
+
+Соотношение 7:6:
+
+896x768, 1344x1152, 1792x1536
+
+
+Соотношение 27:23:
+
+1728x1472
+
+
+Соотношение 20:17:
+
+1280x1088
+
+
+Соотношение 13:11:
+
+832x704, 1664x1408
+
+
+Соотношение 32:27:
+
+2048x1728
+
+
+Соотношение 19:16:
+
+1216x1024
+
+
+Соотношение 25:21:
+
+1600x1344
+
+
+Соотношение 31:26:
+
+1984x1664
+
+
+Соотношение 6:5:
+
+768x640, 1152x960, 1536x1280, 1920x1600
+
+
+Соотношение 29:24:
+
+1856x1536
+
+
+Соотношение 23:19:
+
+1472x1216
+
+
+Соотношение 17:14:
+
+1088x896
+
+
+Соотношение 28:23:
+
+1792x1472
+
+
+Соотношение 11:9:
+
+704x576, 1408x1152
+
+
+Соотношение 27:22:
+
+1728x1408
+
+
+Соотношение 16:13:
+
+1024x832, 2048x1664
+
+
+Соотношение 21:17:
+
+1344x1088
+
+
+Соотношение 26:21:
+
+1664x1344
+
+
+Соотношение 31:25:
+
+1984x1600
+
+
+Соотношение 5:4:
+
+640x512, 960x768, 1280x1024, 1600x1280, 1920x1536
+
+
+Соотношение 29:23:
+
+1856x1472
+
+
+Соотношение 24:19:
+
+1536x1216
+
+
+Соотношение 19:15:
+
+1216x960
+
+
+Соотношение 14:11:
+
+896x704, 1792x1408
+
+
+Соотношение 23:18:
+
+1472x1152
+
+
+Соотношение 32:25:
+
+2048x1600
+
+
+Соотношение 9:7:
+
+1152x896, 1728x1344
+
+
+Соотношение 31:24:
+
+1984x1536
+
+
+Соотношение 22:17:
+
+1408x1088
+
+
+Соотношение 13:10:
+
+832x640, 1664x1280
+
+
+Соотношение 30:23:
+
+1920x1472
+
+
+Соотношение 17:13:
+
+1088x832
+
+
+Соотношение 21:16:
+
+1344x1024
+
+
+Соотношение 25:19:
+
+1600x1216
+
+
+Соотношение 29:22:
+
+1856x1408
+
+
+Соотношение 4:3:
+
+768x576, 1024x768, 1280x960, 1536x1152, 1792x1344, 2048x1536
+
+
+Соотношение 31:23:
+
+1984x1472
+
+
+Соотношение 27:20:
+
+1728x1280
+
+
+Соотношение 23:17:
+
+1472x1088
+
+
+Соотношение 19:14:
+
+1216x896
+
+
+Соотношение 15:11:
+
+960x704, 1920x1408
+
+
+Соотношение 26:19:
+
+1664x1216
+
+
+Соотношение 11:8:
+
+704x512, 1408x1024
+
+
+Соотношение 29:21:
+
+1856x1344
+
+
+Соотношение 18:13:
+
+1152x832
+
+
+Соотношение 25:18:
+
+1600x1152
+
+
+Соотношение 32:23:
+
+2048x1472
+
+
+Соотношение 7:5:
+
+896x640, 1344x960, 1792x1280
+
+
+Соотношение 31:22:
+
+1984x1408
+
+
+Соотношение 24:17:
+
+1536x1088
+
+
+Соотношение 17:12:
+
+1088x768
+
+
+Соотношение 27:19:
+
+1728x1216
+
+
+Соотношение 10:7:
+
+1280x896, 1920x1344
+
+
+Соотношение 23:16:
+
+1472x1024
+
+
+Соотношение 13:9:
+
+832x576, 1664x1152
+
+
+Соотношение 29:20:
+
+1856x1280
+
+
+Соотношение 16:11:
+
+1024x704, 2048x1408
+
+
+Соотношение 19:13:
+
+1216x832
+
+
+Соотношение 22:15:
+
+1408x960
+
+
+Соотношение 25:17:
+
+1600x1088
+
+
+Соотношение 28:19:
+
+1792x1216
+
+
+Соотношение 31:21:
+
+1984x1344
+
+
+Соотношение 3:2:
+
+768x512, 960x640, 1152x768, 1344x896, 1536x1024, 1728x1152, 1920x1280
+
+
+Соотношение 32:21:
+
+2048x1344
+
+
+Соотношение 29:19:
+
+1856x1216
+
+
+Соотношение 26:17:
+
+1664x1088
+
+
+Соотношение 23:15:
+
+1472x960
+
+
+Соотношение 20:13:
+
+1280x832
+
+
+Соотношение 17:11:
+
+1088x704
+
+
+Соотношение 31:20:
+
+1984x1280
+
+
+Соотношение 14:9:
+
+896x576, 1792x1152
+
+
+Соотношение 25:16:
+
+1600x1024
+
+
+Соотношение 11:7:
+
+1408x896
+
+
+Соотношение 30:19:
+
+1920x1216
+
+
+Соотношение 19:12:
+
+1216x768
+
+
+Соотношение 27:17:
+
+1728x1088
+
+
+Соотношение 8:5:
+
+1024x640, 1536x960, 2048x1280
+
+
+Соотношение 29:18:
+
+1856x1152
+
+
+Соотношение 21:13:
+
+1344x832
+
+
+Соотношение 13:8:
+
+832x512, 1664x1024
+
+
+Соотношение 31:19:
+
+1984x1216
+
+
+Соотношение 18:11:
+
+1152x704
+
+
+Соотношение 23:14:
+
+1472x896
+
+
+Соотношение 28:17:
+
+1792x1088
+
+
+Соотношение 5:3:
+
+960x576, 1280x768, 1600x960, 1920x1152
+
+
+Соотношение 32:19:
+
+2048x1216
+
+
+Соотношение 27:16:
+
+1728x1024
+
+
+Соотношение 22:13:
+
+1408x832
+
+
+Соотношение 17:10:
+
+1088x640
+
+
+Соотношение 29:17:
+
+1856x1088
+
+
+Соотношение 12:7:
+
+1536x896
+
+
+Соотношение 31:18:
+
+1984x1152
+
+
+Соотношение 19:11:
+
+1216x704
+
+
+Соотношение 26:15:
+
+1664x960
+
+
+Соотношение 7:4:
+
+896x512, 1344x768, 1792x1024
+
+
+Соотношение 30:17:
+
+1920x1088
+
+
+Соотношение 23:13:
+
+1472x832
+
+
+Соотношение 16:9:
+
+1024x576, 2048x1152
+
+
+Соотношение 25:14:
+
+1600x896
+
+
+Соотношение 9:5:
+
+1152x640, 1728x960
+
+
+Соотношение 29:16:
+
+1856x1024
+
+
+Соотношение 20:11:
+
+1280x704
+
+
+Соотношение 31:17:
+
+1984x1088
+
+
+Соотношение 11:6:
+
+1408x768
+
+
+Соотношение 24:13:
+
+1536x832
+
+
+Соотношение 13:7:
+
+1664x896
+
+
+Соотношение 28:15:
+
+1792x960
+
+
+Соотношение 15:8:
+
+960x512, 1920x1024
+
+
+Соотношение 32:17:
+
+2048x1088
+
+
+Соотношение 17:9:
+
+1088x576
+
+
+Соотношение 19:10:
+
+1216x640
+
+
+Соотношение 21:11:
+
+1344x704
+
+
+Соотношение 23:12:
+
+1472x768
+
+
+Соотношение 25:13:
+
+1600x832
+
+
+Соотношение 27:14:
+
+1728x896
+
+
+Соотношение 29:15:
+
+1856x960
+
+
+Соотношение 31:16:
+
+1984x1024
+
+
+Соотношение 2:1:
+
+1024x512, 1152x576, 1280x640, 1408x704, 1536x768, 1664x832, 1792x896, 1920x960, 2048x1024
+
+
+Соотношение 31:15:
+
+1984x960
+
+
+Соотношение 29:14:
+
+1856x896
+
+
+Соотношение 27:13:
+
+1728x832
+
+
+Соотношение 25:12:
+
+1600x768
+
+
+Соотношение 23:11:
+
+1472x704
+
+
+Соотношение 21:10:
+
+1344x640
+
+
+Соотношение 19:9:
+
+1216x576
+
+
+Соотношение 17:8:
+
+1088x512
+
+
+Соотношение 32:15:
+
+2048x960
+
+
+Соотношение 15:7:
+
+1920x896
+
+
+Соотношение 28:13:
+
+1792x832
+
+
+Соотношение 13:6:
+
+1664x768
+
+
+Соотношение 24:11:
+
+1536x704
+
+
+Соотношение 11:5:
+
+1408x640
+
+
+Соотношение 31:14:
+
+1984x896
+
+
+Соотношение 20:9:
+
+1280x576
+
+
+Соотношение 29:13:
+
+1856x832
+
+
+Соотношение 9:4:
+
+1152x512, 1728x768
+
+
+Соотношение 25:11:
+
+1600x704
+
+
+Соотношение 16:7:
+
+2048x896
+
+
+Соотношение 23:10:
+
+1472x640
+
+
+Соотношение 30:13:
+
+1920x832
+
+
+Соотношение 7:3:
+
+1344x576, 1792x768
+
+
+Соотношение 26:11:
+
+1664x704
+
+
+Соотношение 19:8:
+
+1216x512
+
+
+Соотношение 31:13:
+
+1984x832
+
+
+Соотношение 12:5:
+
+1536x640
+
+
+Соотношение 29:12:
+
+1856x768
+
+
+Соотношение 22:9:
+
+1408x576
+
+
+Соотношение 27:11:
+
+1728x704
+
+
+Соотношение 32:13:
+
+2048x832
+
+
+Соотношение 5:2:
+
+1280x512, 1600x640, 1920x768
+
+
+Соотношение 28:11:
+
+1792x704
+
+
+Соотношение 23:9:
+
+1472x576
+
+
+Соотношение 31:12:
+
+1984x768
+
+
+Соотношение 13:5:
+
+1664x640
+
+
+Соотношение 21:8:
+
+1344x512
+
+
+Соотношение 29:11:
+
+1856x704
+
+
+Соотношение 8:3:
+
+1536x576, 2048x768
+
+
+Соотношение 27:10:
+
+1728x640
+
+
+Соотношение 30:11:
+
+1920x704
+
+
+Соотношение 11:4:
+
+1408x512
+
+
+Соотношение 25:9:
+
+1600x576
+
+
+Соотношение 14:5:
+
+1792x640
+
+
+Соотношение 31:11:
+
+1984x704
+
+
+Соотношение 23:8:
+
+1472x512
+
+
+Соотношение 26:9:
+
+1664x576
+
+
+Соотношение 29:10:
+
+1856x640
+
+
+Соотношение 32:11:
+
+2048x704
+
+
+Соотношение 3:1:
+
+1536x512, 1728x576, 1920x640
+
+
+Соотношение 31:10:
+
+1984x640
+
+
+Соотношение 28:9:
+
+1792x576
+
+
+Соотношение 25:8:
+
+1600x512
+
+
+Соотношение 16:5:
+
+2048x640
+
+
+Соотношение 29:9:
+
+1856x576
+
+
+Соотношение 13:4:
+
+1664x512
+
+
+Соотношение 10:3:
+
+1920x576
+
+
+Соотношение 27:8:
+
+1728x512
+
+
+Соотношение 31:9:
+
+1984x576
+
+
+Соотношение 7:2:
+
+1792x512
+
+
+Соотношение 32:9:
+
+2048x576
+
+
+Соотношение 29:8:
+
+1856x512
+
+
+Соотношение 15:4:
+
+1920x512
+
+
+Соотношение 31:8:
+
+1984x512
+
+
+Соотношение 4:1:
+
+2048x512
+
+
+=== Портретное (Portrait) ===
+
+
+Соотношение 1:4:
+
+512x2048
+
+
+Соотношение 8:31:
+
+512x1984
+
+
+Соотношение 4:15:
+
+512x1920
+
+
+Соотношение 8:29:
+
+512x1856
+
+
+Соотношение 9:32:
+
+576x2048
+
+
+Соотношение 2:7:
+
+512x1792
+
+
+Соотношение 9:31:
+
+576x1984
+
+
+Соотношение 8:27:
+
+512x1728
+
+
+Соотношение 3:10:
+
+576x1920
+
+
+Соотношение 4:13:
+
+512x1664
+
+
+Соотношение 9:29:
+
+576x1856
+
+
+Соотношение 5:16:
+
+640x2048
+
+
+Соотношение 8:25:
+
+512x1600
+
+
+Соотношение 9:28:
+
+576x1792
+
+
+Соотношение 10:31:
+
+640x1984
+
+
+Соотношение 1:3:
+
+512x1536, 576x1728, 640x1920
+
+
+Соотношение 11:32:
+
+704x2048
+
+
+Соотношение 10:29:
+
+640x1856
+
+
+Соотношение 9:26:
+
+576x1664
+
+
+Соотношение 8:23:
+
+512x1472
+
+
+Соотношение 11:31:
+
+704x1984
+
+
+Соотношение 5:14:
+
+640x1792
+
+
+Соотношение 9:25:
+
+576x1600
+
+
+Соотношение 4:11:
+
+512x1408
+
+
+Соотношение 11:30:
+
+704x1920
+
+
+Соотношение 10:27:
+
+640x1728
+
+
+Соотношение 3:8:
+
+576x1536, 768x2048
+
+
+Соотношение 11:29:
+
+704x1856
+
+
+Соотношение 8:21:
+
+512x1344
+
+
+Соотношение 5:13:
+
+640x1664
+
+
+Соотношение 12:31:
+
+768x1984
+
+
+Соотношение 9:23:
+
+576x1472
+
+
+Соотношение 11:28:
+
+704x1792
+
+
+Соотношение 2:5:
+
+512x1280, 640x1600, 768x1920
+
+
+Соотношение 13:32:
+
+832x2048
+
+
+Соотношение 11:27:
+
+704x1728
+
+
+Соотношение 9:22:
+
+576x1408
+
+
+Соотношение 12:29:
+
+768x1856
+
+
+Соотношение 5:12:
+
+640x1536
+
+
+Соотношение 13:31:
+
+832x1984
+
+
+Соотношение 8:19:
+
+512x1216
+
+
+Соотношение 11:26:
+
+704x1664
+
+
+Соотношение 3:7:
+
+576x1344, 768x1792
+
+
+Соотношение 13:30:
+
+832x1920
+
+
+Соотношение 10:23:
+
+640x1472
+
+
+Соотношение 7:16:
+
+896x2048
+
+
+Соотношение 11:25:
+
+704x1600
+
+
+Соотношение 4:9:
+
+512x1152, 768x1728
+
+
+Соотношение 13:29:
+
+832x1856
+
+
+Соотношение 9:20:
+
+576x1280
+
+
+Соотношение 14:31:
+
+896x1984
+
+
+Соотношение 5:11:
+
+640x1408
+
+
+Соотношение 11:24:
+
+704x1536
+
+
+Соотношение 6:13:
+
+768x1664
+
+
+Соотношение 13:28:
+
+832x1792
+
+
+Соотношение 7:15:
+
+896x1920
+
+
+Соотношение 15:32:
+
+960x2048
+
+
+Соотношение 8:17:
+
+512x1088
+
+
+Соотношение 9:19:
+
+576x1216
+
+
+Соотношение 10:21:
+
+640x1344
+
+
+Соотношение 11:23:
+
+704x1472
+
+
+Соотношение 12:25:
+
+768x1600
+
+
+Соотношение 13:27:
+
+832x1728
+
+
+Соотношение 14:29:
+
+896x1856
+
+
+Соотношение 15:31:
+
+960x1984
+
+
+Соотношение 1:2:
+
+512x1024, 576x1152, 640x1280, 704x1408, 768x1536, 832x1664, 896x1792, 960x1920, 1024x2048
+
+
+Соотношение 16:31:
+
+1024x1984
+
+
+Соотношение 15:29:
+
+960x1856
+
+
+Соотношение 14:27:
+
+896x1728
+
+
+Соотношение 13:25:
+
+832x1600
+
+
+Соотношение 12:23:
+
+768x1472
+
+
+Соотношение 11:21:
+
+704x1344
+
+
+Соотношение 10:19:
+
+640x1216
+
+
+Соотношение 9:17:
+
+576x1088
+
+
+Соотношение 17:32:
+
+1088x2048
+
+
+Соотношение 8:15:
+
+512x960, 1024x1920
+
+
+Соотношение 15:28:
+
+960x1792
+
+
+Соотношение 7:13:
+
+896x1664
+
+
+Соотношение 13:24:
+
+832x1536
+
+
+Соотношение 6:11:
+
+768x1408
+
+
+Соотношение 17:31:
+
+1088x1984
+
+
+Соотношение 11:20:
+
+704x1280
+
+
+Соотношение 16:29:
+
+1024x1856
+
+
+Соотношение 5:9:
+
+640x1152, 960x1728
+
+
+Соотношение 14:25:
+
+896x1600
+
+
+Соотношение 9:16:
+
+576x1024, 1152x2048
+
+
+Соотношение 13:23:
+
+832x1472
+
+
+Соотношение 17:30:
+
+1088x1920
+
+
+Соотношение 4:7:
+
+512x896, 768x1344, 1024x1792
+
+
+Соотношение 15:26:
+
+960x1664
+
+
+Соотношение 11:19:
+
+704x1216
+
+
+Соотношение 18:31:
+
+1152x1984
+
+
+Соотношение 7:12:
+
+896x1536
+
+
+Соотношение 17:29:
+
+1088x1856
+
+
+Соотношение 10:17:
+
+640x1088
+
+
+Соотношение 13:22:
+
+832x1408
+
+
+Соотношение 16:27:
+
+1024x1728
+
+
+Соотношение 19:32:
+
+1216x2048
+
+
+Соотношение 3:5:
+
+576x960, 768x1280, 960x1600, 1152x1920
+
+
+Соотношение 17:28:
+
+1088x1792
+
+
+Соотношение 14:23:
+
+896x1472
+
+
+Соотношение 11:18:
+
+704x1152
+
+
+Соотношение 19:31:
+
+1216x1984
+
+
+Соотношение 8:13:
+
+512x832, 1024x1664
+
+
+Соотношение 13:21:
+
+832x1344
+
+
+Соотношение 18:29:
+
+1152x1856
+
+
+Соотношение 5:8:
+
+640x1024, 960x1536, 1280x2048
+
+
+Соотношение 17:27:
+
+1088x1728
+
+
+Соотношение 12:19:
+
+768x1216
+
+
+Соотношение 19:30:
+
+1216x1920
+
+
+Соотношение 7:11:
+
+896x1408
+
+
+Соотношение 16:25:
+
+1024x1600
+
+
+Соотношение 9:14:
+
+576x896, 1152x1792
+
+
+Соотношение 20:31:
+
+1280x1984
+
+
+Соотношение 11:17:
+
+704x1088
+
+
+Соотношение 13:20:
+
+832x1280
+
+
+Соотношение 15:23:
+
+960x1472
+
+
+Соотношение 17:26:
+
+1088x1664
+
+
+Соотношение 19:29:
+
+1216x1856
+
+
+Соотношение 21:32:
+
+1344x2048
+
+
+Соотношение 2:3:
+
+512x768, 640x960, 768x1152, 896x1344, 1024x1536, 1152x1728, 1280x1920
+
+
+Соотношение 21:31:
+
+1344x1984
+
+
+Соотношение 19:28:
+
+1216x1792
+
+
+Соотношение 17:25:
+
+1088x1600
+
+
+Соотношение 15:22:
+
+960x1408
+
+
+Соотношение 13:19:
+
+832x1216
+
+
+Соотношение 11:16:
+
+704x1024, 1408x2048
+
+
+Соотношение 20:29:
+
+1280x1856
+
+
+Соотношение 9:13:
+
+576x832, 1152x1664
+
+
+Соотношение 16:23:
+
+1024x1472
+
+
+Соотношение 7:10:
+
+896x1280, 1344x1920
+
+
+Соотношение 19:27:
+
+1216x1728
+
+
+Соотношение 12:17:
+
+768x1088
+
+
+Соотношение 17:24:
+
+1088x1536
+
+
+Соотношение 22:31:
+
+1408x1984
+
+
+Соотношение 5:7:
+
+640x896, 960x1344, 1280x1792
+
+
+Соотношение 23:32:
+
+1472x2048
+
+
+Соотношение 18:25:
+
+1152x1600
+
+
+Соотношение 13:18:
+
+832x1152
+
+
+Соотношение 21:29:
+
+1344x1856
+
+
+Соотношение 8:11:
+
+512x704, 1024x1408
+
+
+Соотношение 19:26:
+
+1216x1664
+
+
+Соотношение 11:15:
+
+704x960, 1408x1920
+
+
+Соотношение 14:19:
+
+896x1216
+
+
+Соотношение 17:23:
+
+1088x1472
+
+
+Соотношение 20:27:
+
+1280x1728
+
+
+Соотношение 23:31:
+
+1472x1984
+
+
+Соотношение 3:4:
+
+576x768, 768x1024, 960x1280, 1152x1536, 1344x1792, 1536x2048
+
+
+Соотношение 22:29:
+
+1408x1856
+
+
+Соотношение 19:25:
+
+1216x1600
+
+
+Соотношение 16:21:
+
+1024x1344
+
+
+Соотношение 13:17:
+
+832x1088
+
+
+Соотношение 23:30:
+
+1472x1920
+
+
+Соотношение 10:13:
+
+640x832, 1280x1664
+
+
+Соотношение 17:22:
+
+1088x1408
+
+
+Соотношение 24:31:
+
+1536x1984
+
+
+Соотношение 7:9:
+
+896x1152, 1344x1728
+
+
+Соотношение 25:32:
+
+1600x2048
+
+
+Соотношение 18:23:
+
+1152x1472
+
+
+Соотношение 11:14:
+
+704x896, 1408x1792
+
+
+Соотношение 15:19:
+
+960x1216
+
+
+Соотношение 19:24:
+
+1216x1536
+
+
+Соотношение 23:29:
+
+1472x1856
+
+
+Соотношение 4:5:
+
+512x640, 768x960, 1024x1280, 1280x1600, 1536x1920
+
+
+Соотношение 25:31:
+
+1600x1984
+
+
+Соотношение 21:26:
+
+1344x1664
+
+
+Соотношение 17:21:
+
+1088x1344
+
+
+Соотношение 13:16:
+
+832x1024, 1664x2048
+
+
+Соотношение 22:27:
+
+1408x1728
+
+
+Соотношение 9:11:
+
+576x704, 1152x1408
+
+
+Соотношение 23:28:
+
+1472x1792
+
+
+Соотношение 14:17:
+
+896x1088
+
+
+Соотношение 19:23:
+
+1216x1472
+
+
+Соотношение 24:29:
+
+1536x1856
+
+
+Соотношение 5:6:
+
+640x768, 960x1152, 1280x1536, 1600x1920
+
+
+Соотношение 26:31:
+
+1664x1984
+
+
+Соотношение 21:25:
+
+1344x1600
+
+
+Соотношение 16:19:
+
+1024x1216
+
+
+Соотношение 27:32:
+
+1728x2048
+
+
+Соотношение 11:13:
+
+704x832, 1408x1664
+
+
+Соотношение 17:20:
+
+1088x1280
+
+
+Соотношение 23:27:
+
+1472x1728
+
+
+Соотношение 6:7:
+
+768x896, 1152x1344, 1536x1792
+
+
+Соотношение 25:29:
+
+1600x1856
+
+
+Соотношение 19:22:
+
+1216x1408
+
+
+Соотношение 13:15:
+
+832x960, 1664x1920
+
+
+Соотношение 20:23:
+
+1280x1472
+
+
+Соотношение 27:31:
+
+1728x1984
+
+
+Соотношение 7:8:
+
+896x1024, 1344x1536, 1792x2048
+
+
+Соотношение 22:25:
+
+1408x1600
+
+
+Соотношение 15:17:
+
+960x1088
+
+
+Соотношение 23:26:
+
+1472x1664
+
+
+Соотношение 8:9:
+
+512x576, 1024x1152, 1536x1728
+
+
+Соотношение 25:28:
+
+1600x1792
+
+
+Соотношение 17:19:
+
+1088x1216
+
+
+Соотношение 26:29:
+
+1664x1856
+
+
+Соотношение 9:10:
+
+576x640, 1152x1280, 1728x1920
+
+
+Соотношение 28:31:
+
+1792x1984
+
+
+Соотношение 19:21:
+
+1216x1344
+
+
+Соотношение 29:32:
+
+1856x2048
+
+
+Соотношение 10:11:
+
+640x704, 1280x1408
+
+
+Соотношение 21:23:
+
+1344x1472
+
+
+Соотношение 11:12:
+
+704x768, 1408x1536
+
+
+Соотношение 23:25:
+
+1472x1600
+
+
+Соотношение 12:13:
+
+768x832, 1536x1664
+
+
+Соотношение 25:27:
+
+1600x1728
+
+
+Соотношение 13:14:
+
+832x896, 1664x1792
+
+
+Соотношение 27:29:
+
+1728x1856
+
+
+Соотношение 14:15:
+
+896x960, 1792x1920
+
+
+Соотношение 29:31:
+
+1856x1984
+
+
+Соотношение 15:16:
+
+960x1024, 1920x2048
+
+
+Соотношение 16:17:
+
+1024x1088
+
+
+Соотношение 17:18:
+
+1088x1152
+
+
+Соотношение 18:19:
+
+1152x1216
+
+
+Соотношение 19:20:
+
+1216x1280
+
+
+Соотношение 20:21:
+
+1280x1344
+
+
+Соотношение 21:22:
+
+1344x1408
+
+
+Соотношение 22:23:
+
+1408x1472
+
+
+Соотношение 23:24:
+
+1472x1536
+
+
+Соотношение 24:25:
+
+1536x1600
+
+
+Соотношение 25:26:
+
+1600x1664
+
+
+Соотношение 26:27:
+
+1664x1728
+
+
+Соотношение 27:28:
+
+1728x1792
+
+
+Соотношение 28:29:
+
+1792x1856
+
+
+Соотношение 29:30:
+
+1856x1920
+
+
+Соотношение 30:31:
+
+1920x1984
+
+
+Соотношение 31:32:
+
+1984x2048