284 lines
12 KiB
Python
284 lines
12 KiB
Python
import io
|
|
import math
|
|
import random
|
|
from collections import defaultdict
|
|
from typing import BinaryIO, Union
|
|
|
|
from PIL import Image
|
|
|
|
|
|
def encode_to_base36(num: int) -> str:
|
|
"""Кодирует неотрицательное число в компактный строковый идентификатор."""
|
|
if num < 0:
|
|
raise ValueError("Число должно быть неотрицательным")
|
|
|
|
charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
|
if num < len(charset):
|
|
return charset[num]
|
|
|
|
result = []
|
|
while num > 0:
|
|
result.append(charset[num % len(charset)])
|
|
num //= len(charset)
|
|
return "".join(reversed(result))
|
|
|
|
|
|
def generate_shape_def(shape: str, radius: int, shape_id: str) -> str:
|
|
"""Генерирует SVG-элемент для тега <defs> в зависимости от типа фигуры."""
|
|
r = radius
|
|
match shape:
|
|
case "ring":
|
|
stroke_width = max(1.0, r * 0.35)
|
|
inner_r = max(0.5, r - stroke_width / 2.0)
|
|
return f'<circle id="{shape_id}" r="{inner_r:.1f}" fill="none" stroke="currentColor" stroke-width="{stroke_width:.1f}"/>'
|
|
|
|
case "square":
|
|
size = r * 2
|
|
rx = max(0.5, r * 0.1)
|
|
return f'<rect id="{shape_id}" class="shape" x="{-r}" y="{-r}" width="{size}" height="{size}" rx="{rx:.1f}"/>'
|
|
|
|
case "diamond":
|
|
return f'<polygon id="{shape_id}" class="shape" points="0,{-r} {-r},0 0,{r} {r},0"/>'
|
|
|
|
case "triangle":
|
|
return f'<polygon id="{shape_id}" class="shape" points="0,{-r} {-r},{r} {r},{r}"/>'
|
|
|
|
case "hexagon":
|
|
w = round(r * 0.866)
|
|
h_half = round(r * 0.5)
|
|
return f'<polygon id="{shape_id}" class="shape" points="0,{-r} {w},{-h_half} {w},{h_half} 0,{r} {-w},{h_half} {-w},{-h_half}"/>'
|
|
|
|
case "star":
|
|
points = []
|
|
inner_r = r * 0.45
|
|
for i in range(10):
|
|
angle = i * math.pi / 5 - math.pi / 2
|
|
curr_r = r if i % 2 == 0 else inner_r
|
|
px = round(curr_r * math.cos(angle), 1)
|
|
py = round(curr_r * math.sin(angle), 1)
|
|
points.append(f"{px},{py}")
|
|
pts_str = " ".join(points)
|
|
return f'<polygon id="{shape_id}" class="shape" points="{pts_str}"/>'
|
|
|
|
case "cross":
|
|
arm = max(1, round(r * 0.35))
|
|
return f'<path id="{shape_id}" class="shape" d="M{-arm},{-r} H{arm} V{-arm} H{r} V{arm} H{arm} V{r} H{-arm} V{arm} H{-r} V{-arm} H{-arm} Z"/>'
|
|
|
|
case "line":
|
|
th = max(1, round(r * 0.25))
|
|
return f'<rect id="{shape_id}" class="shape" x="{-r}" y="{-th}" width="{2*r}" height="{2*th}" rx="1"/>'
|
|
|
|
case "wave":
|
|
th = max(1.0, r * 0.3)
|
|
return f'<path id="{shape_id}" class="shape" d="M{-r},0 Q{-r/2:.1f},{-r} 0,0 T{r},0" fill="none" stroke="currentColor" stroke-width="{th:.1f}"/>'
|
|
|
|
case "heart":
|
|
scale_f = r / 12.0
|
|
return (
|
|
f'<path id="{shape_id}" class="shape" transform="scale({scale_f:.3f}) translate(-12, -12)" '
|
|
f'd="M12 21.35l-1.45-1.32C5.4 15.36 2 12.28 2 8.5 2 5.42 4.42 3 7.5 3c1.74 0 3.41.81 4.5 2.09C13.09 3.81 14.76 3 16.5 3 19.58 3 22 5.42 22 8.5c0 3.78-3.4 6.86-8.55 11.54L12 21.35z"/>'
|
|
)
|
|
|
|
case "circle" | _:
|
|
return f'<circle id="{shape_id}" class="shape" r="{r}"/>'
|
|
|
|
|
|
def generate_halftone_svg(
|
|
image: Union[Image.Image, BinaryIO, bytes, str],
|
|
*,
|
|
cols: int = 35,
|
|
max_radius: int = 8,
|
|
shape: str = "circle",
|
|
color: str = "#a855ff",
|
|
opacity: float = 0.9,
|
|
blink: int = 6,
|
|
rotation: int = 0,
|
|
scale: int = 980,
|
|
angle: int = 0,
|
|
animation_variants: int = 12,
|
|
seed: int = 42,
|
|
) -> str:
|
|
"""
|
|
Генерирует чистый оптимизированный SVG-халфтон из растрового изображения.
|
|
|
|
Параметры:
|
|
- image: PIL Image, файловый объект (BytesIO), байты или путь к файлу
|
|
- cols: число точек по наибольшей стороне сетки (10-200)
|
|
- max_radius: максимальный радиус/размер точки (3-20)
|
|
- shape: тип фигуры ('circle', 'ring', 'square', 'diamond', 'triangle', 'hexagon', 'star', 'cross', 'line', 'wave', 'heart')
|
|
- color: основной HEX цвет (например '#a855ff')
|
|
- opacity: коэффициент непрозрачности (0.0 - 1.0)
|
|
- blink: интенсивность мерцания (0 - выключено/статичный, 1-10 - скорость)
|
|
- rotation: угол покачивания в градусах (-15 .. +15)
|
|
- scale: масштаб пульсации (800 .. 1040, где 980 = 0.98)
|
|
- angle: наклон растровой сетки (-44 .. +45)
|
|
- animation_variants: число вариантов CSS-задержек
|
|
- seed: сид для детерминированного распределения анимаций
|
|
"""
|
|
rng = random.Random(seed)
|
|
|
|
# 1. Загрузка и подготовка изображения в градациях серого
|
|
if isinstance(image, (bytes, bytearray)):
|
|
pil_img = Image.open(io.BytesIO(image))
|
|
elif hasattr(image, "read"):
|
|
if hasattr(image, "seek"):
|
|
image.seek(0)
|
|
pil_img = Image.open(image)
|
|
elif isinstance(image, str):
|
|
pil_img = Image.open(image)
|
|
elif isinstance(image, Image.Image):
|
|
pil_img = image
|
|
else:
|
|
raise ValueError("Неподдерживаемый тип входного изображения")
|
|
|
|
# Конвертируем в Grayscale
|
|
img = pil_img.convert("L")
|
|
|
|
# Обработка наклона сетки (angle): поворачиваем изображение при необходимости
|
|
if angle != 0:
|
|
# Поворачиваем с сохранением пропорций и белым фоном (255 = прозрачно/пусто)
|
|
img = img.rotate(-angle, resample=Image.Resampling.BICUBIC, expand=True, fillcolor=255)
|
|
|
|
# Вычисляем размеры сетки: значение `cols` задает число точек по наибольшей стороне (ширине или высоте)
|
|
if img.width >= img.height:
|
|
grid_width = max(1, cols)
|
|
grid_height = max(1, round(cols * (img.height / img.width)))
|
|
else:
|
|
grid_height = max(1, cols)
|
|
grid_width = max(1, round(cols * (img.width / img.height)))
|
|
|
|
img_resized = img.resize((grid_width, grid_height), Image.Resampling.LANCZOS)
|
|
|
|
step = max_radius * 2 + 2
|
|
width = grid_width * step
|
|
height = grid_height * step
|
|
|
|
# 2. Формирование классов анимации
|
|
animation_classes = []
|
|
is_animated = blink > 0
|
|
|
|
# Длительность цикла анимации: при blink=10 -> 0.6s, при blink=1 -> 2.4s
|
|
duration = max(0.4, 2.5 - (blink * 0.19)) if is_animated else 1.0
|
|
|
|
for i in range(animation_variants):
|
|
delay = (i / animation_variants) * duration * 1.5
|
|
encoded_i = encode_to_base36(i)
|
|
delay_str = f"{int(delay)}" if delay == int(delay) else f"{delay:.2f}".rstrip("0").rstrip(".")
|
|
animation_classes.append(f".a{encoded_i}{{--d:{delay_str}s}}")
|
|
|
|
# 3. Обход пикселей и группировка
|
|
elements_by_class = defaultdict(list)
|
|
unique_radii = set()
|
|
|
|
for y in range(grid_height):
|
|
for x in range(grid_width):
|
|
brightness = img_resized.getpixel((x, y))
|
|
factor = (255 - brightness) / 255.0
|
|
|
|
# Отсекаем слишком светлые участки (шум фона)
|
|
if factor < 0.12:
|
|
continue
|
|
|
|
radius = int(factor * max_radius)
|
|
if radius == 0:
|
|
continue
|
|
|
|
cx = x * step + step // 2
|
|
cy = y * step + step // 2
|
|
|
|
anim_class = rng.randint(0, animation_variants - 1)
|
|
encoded_class = encode_to_base36(anim_class)
|
|
|
|
elements_by_class[encoded_class].append((radius, cx, cy))
|
|
unique_radii.add(radius)
|
|
|
|
# 4. Формирование <defs>
|
|
defs_list = ["<defs>"]
|
|
for radius in sorted(unique_radii):
|
|
shape_id = f"s{encode_to_base36(radius)}"
|
|
defs_list.append(generate_shape_def(shape, radius, shape_id))
|
|
defs_list.append("</defs>")
|
|
defs_html = "".join(defs_list)
|
|
|
|
# 5. Формирование групп <g class="a...">
|
|
groups = []
|
|
for anim_class in sorted(elements_by_class.keys()):
|
|
group_elements = elements_by_class[anim_class]
|
|
uses = "".join(
|
|
f'<use href="#s{encode_to_base36(radius)}" x="{cx}" y="{cy}"/>'
|
|
for radius, cx, cy in group_elements
|
|
)
|
|
if uses:
|
|
groups.append(f'<g class="a{anim_class}">{uses}</g>')
|
|
|
|
animation_css = "".join(animation_classes)
|
|
groups_html = "".join(groups)
|
|
|
|
# 6. Стилизация и Keyframes
|
|
scale_val = max(0.5, min(1.5, scale / 1000.0))
|
|
scale_str = f"{scale_val:.3f}".rstrip("0").rstrip(".")
|
|
rot_str = f"{rotation}deg"
|
|
|
|
# Корректный цвет с прозрачностью
|
|
clean_color = color.strip() if color else "#a855ff"
|
|
if not clean_color.startswith("#"):
|
|
clean_color = f"#{clean_color}"
|
|
|
|
# Добавляем альфа-канал в hex при необходимости или используем CSS opacity
|
|
fill_style = f"fill:{clean_color};stroke:{clean_color};opacity:{opacity:.2f};"
|
|
|
|
if is_animated:
|
|
anim_rule = f"animation:noise {duration:.2f}s ease-in-out infinite alternate;animation-delay:var(--d);"
|
|
keyframes_rule = (
|
|
f"@keyframes noise{{"
|
|
f"0%{{opacity:{max(0.2, opacity * 0.7):.2f};transform:scale(1) rotate(0deg)}}"
|
|
f"50%{{opacity:{opacity:.2f}}}"
|
|
f"100%{{opacity:{max(0.1, opacity * 0.5):.2f};transform:scale({scale_str}) rotate({rot_str})}}"
|
|
f"}}"
|
|
)
|
|
else:
|
|
anim_rule = "animation:none;"
|
|
keyframes_rule = ""
|
|
|
|
svg_css = (
|
|
f"<style>"
|
|
f"svg{{background:transparent}}"
|
|
f".shape,circle,rect,polygon,path{{{fill_style}transform-origin:center;{anim_rule}transition:all .5s ease-out}}"
|
|
f"{keyframes_rule}"
|
|
f".frozen .shape,.frozen circle,.frozen rect,.frozen polygon,.frozen path{{animation:none!important;opacity:{opacity:.2f}!important;transform:none!important}}"
|
|
f"{animation_css}"
|
|
f"</style>"
|
|
)
|
|
|
|
svg_template = (
|
|
f'<!-- Generated by Hypn0 Generator (https://hypn0.ru) -->\n'
|
|
f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {width} {height}" width="100%" height="100%">'
|
|
f'{svg_css}'
|
|
f'{defs_html}'
|
|
f'<g id="hypn0-canvas">{groups_html}</g>'
|
|
f'</svg>'
|
|
)
|
|
|
|
return svg_template
|
|
|
|
|
|
def prepare_gallery_svg(svg_content: str) -> str:
|
|
"""
|
|
Модифицирует SVG для долговременного хранения в галерее:
|
|
добавляет CSS-правила, чтобы в изолированном контексте (<img>) анимация
|
|
находилась на паузе по умолчанию и запускалась только при наведении (:hover),
|
|
предотвращая перегрузку CPU/GPU браузера при выводе сетки карточек.
|
|
"""
|
|
if not svg_content:
|
|
return svg_content
|
|
|
|
hover_css = (
|
|
"svg:not(:hover) .shape,svg:not(:hover) circle,svg:not(:hover) rect,"
|
|
"svg:not(:hover) polygon,svg:not(:hover) path{animation-play-state:paused!important}"
|
|
)
|
|
|
|
if "</style>" in svg_content:
|
|
return svg_content.replace("</style>", f"{hover_css}</style>", 1)
|
|
|
|
return svg_content
|