245 lines
11 KiB
Python
245 lines
11 KiB
Python
import math
|
|
import numpy as np
|
|
from PIL import Image, ImageDraw, ImageFilter
|
|
|
|
HI_SIZE = 4096
|
|
OUT_SIZE = 1024
|
|
CENTER = HI_SIZE / 2.0
|
|
|
|
# 1. ГЛУБОКИЙ КИНЕМАТОГРАФИЧЕСКИЙ КОСМОС
|
|
bg = Image.new('RGBA', (HI_SIZE, HI_SIZE), (2, 3, 10, 255))
|
|
|
|
# Плавная галактическая спираль и звездная пыль
|
|
dust = Image.new('RGBA', (HI_SIZE, HI_SIZE), (0, 0, 0, 0))
|
|
ddraw = ImageDraw.Draw(dust)
|
|
|
|
for i in range(24):
|
|
a = -0.6 + (i / 24.0) * 1.2
|
|
r_dist = (i - 12) * 140
|
|
cx = CENTER + r_dist * math.cos(a + math.pi/2)
|
|
cy = CENTER + r_dist * math.sin(a + math.pi/2)
|
|
rw = 2300 - abs(i - 12) * 120
|
|
rh = 850 - abs(i - 12) * 45
|
|
col = (45, 20, 75, 40) if i % 2 == 0 else (15, 55, 95, 45)
|
|
ddraw.ellipse([cx - rw, cy - rh, cx + rw, cy + rh], fill=col)
|
|
|
|
dust = dust.filter(ImageFilter.GaussianBlur(340))
|
|
bg = Image.alpha_composite(bg, dust)
|
|
|
|
# Золотой аккреционный вихрь вокруг сингулярности
|
|
vortex = Image.new('RGBA', (HI_SIZE, HI_SIZE), (0, 0, 0, 0))
|
|
vdraw = ImageDraw.Draw(vortex)
|
|
vdraw.ellipse([CENTER - 1650, CENTER - 1050, CENTER + 1650, CENTER + 1050], fill=(220, 115, 20, 35))
|
|
vdraw.ellipse([CENTER - 1200, CENTER - 1200, CENTER + 1200, CENTER + 1200], fill=(255, 160, 35, 45))
|
|
vdraw.ellipse([CENTER - 800, CENTER - 800, CENTER + 800, CENTER + 800], fill=(255, 210, 80, 50))
|
|
vortex = vortex.filter(ImageFilter.GaussianBlur(220))
|
|
bg = Image.alpha_composite(bg, vortex)
|
|
|
|
# Россыпь мягких звезд
|
|
np.random.seed(137)
|
|
star_layer = Image.new('RGBA', (HI_SIZE, HI_SIZE), (0, 0, 0, 0))
|
|
sdraw = ImageDraw.Draw(star_layer)
|
|
for _ in range(500):
|
|
sx = np.random.uniform(40, HI_SIZE - 40)
|
|
sy = np.random.uniform(40, HI_SIZE - 40)
|
|
rad = np.random.uniform(2, 8)
|
|
alpha = np.random.randint(80, 240)
|
|
tints = [(255, 255, 255), (255, 230, 175), (195, 230, 255)]
|
|
tint = tints[np.random.randint(len(tints))]
|
|
sdraw.ellipse([sx - rad, sy - rad, sx + rad, sy + rad], fill=(*tint, alpha))
|
|
|
|
star_layer = star_layer.filter(ImageFilter.GaussianBlur(3))
|
|
bg = Image.alpha_composite(bg, star_layer)
|
|
|
|
# 2. РОВНО 13 ЛУЧЕЙ КАК ПЛАВНЫЕ ЭНЕРГЕТИЧЕСКИЕ ЛЕПЕСТКИ СВЕТА (ОРГАНИЧЕСКАЯ САМИКА, НЕ ЧЕРТЕЖ!)
|
|
petals_glow = Image.new('RGBA', (HI_SIZE, HI_SIZE), (0, 0, 0, 0))
|
|
pg_draw = ImageDraw.Draw(petals_glow)
|
|
|
|
petals_body = Image.new('RGBA', (HI_SIZE, HI_SIZE), (0, 0, 0, 0))
|
|
pb_draw = ImageDraw.Draw(petals_body)
|
|
|
|
petals_core = Image.new('RGBA', (HI_SIZE, HI_SIZE), (0, 0, 0, 0))
|
|
pc_draw = ImageDraw.Draw(petals_core)
|
|
|
|
N_POINTS = 13
|
|
R_TIP = HI_SIZE * 0.440 # Вершина 13 лучей
|
|
R_WAIST = HI_SIZE * 0.290 # Талия лепестка
|
|
R_BASE = HI_SIZE * 0.175 # Основание
|
|
|
|
# Вершина строго вертикально вверх
|
|
angles = [(-math.pi / 2.0) + (2.0 * math.pi * i / N_POINTS) for i in range(N_POINTS)]
|
|
|
|
# Строим каждый из 13 лучей как грациозный изогнутый плазменный лепесток
|
|
for i in range(N_POINTS):
|
|
a = angles[i]
|
|
tip = (CENTER + R_TIP * math.cos(a), CENTER + R_TIP * math.sin(a))
|
|
|
|
# Боковые крылья лепестка (плавные кривые Безье)
|
|
half_w_ang = (math.pi / N_POINTS) * 0.65
|
|
ctrl_left = (CENTER + R_WAIST * math.cos(a - half_w_ang), CENTER + R_WAIST * math.sin(a - half_w_ang))
|
|
ctrl_right = (CENTER + R_WAIST * math.cos(a + half_w_ang), CENTER + R_WAIST * math.sin(a + half_w_ang))
|
|
|
|
base_left = (CENTER + R_BASE * math.cos(a - half_w_ang * 0.7), CENTER + R_BASE * math.sin(a - half_w_ang * 0.7))
|
|
base_right = (CENTER + R_BASE * math.cos(a + half_w_ang * 0.7), CENTER + R_BASE * math.sin(a + half_w_ang * 0.7))
|
|
|
|
# Генерация точек по Безье
|
|
left_side = []
|
|
right_side = []
|
|
for step in range(35):
|
|
t = step / 34.0
|
|
# Кривая от основания через талию к острию
|
|
lx = (1-t)**2 * base_left[0] + 2*(1-t)*t * ctrl_left[0] + t**2 * tip[0]
|
|
ly = (1-t)**2 * base_left[1] + 2*(1-t)*t * ctrl_left[1] + t**2 * tip[1]
|
|
left_side.append((lx, ly))
|
|
|
|
rx = (1-t)**2 * base_right[0] + 2*(1-t)*t * ctrl_right[0] + t**2 * tip[0]
|
|
ry = (1-t)**2 * base_right[1] + 2*(1-t)*t * ctrl_right[1] + t**2 * tip[1]
|
|
right_side.append((rx, ry))
|
|
|
|
petal_poly = left_side + right_side[::-1]
|
|
|
|
# Полупрозрачное золотистое тело лепестка
|
|
pg_draw.polygon(petal_poly, fill=(255, 175, 40, 50))
|
|
pb_draw.polygon(petal_poly, fill=(255, 215, 80, 75))
|
|
|
|
# Внутренний сияющий криволинейный контур
|
|
for p in range(len(left_side) - 1):
|
|
pb_draw.line([left_side[p], left_side[p+1]], fill=(255, 235, 130, 200), width=10)
|
|
pc_draw.line([left_side[p], left_side[p+1]], fill=(255, 255, 255, 240), width=4)
|
|
for p in range(len(right_side) - 1):
|
|
pb_draw.line([right_side[p], right_side[p+1]], fill=(255, 235, 130, 200), width=10)
|
|
pc_draw.line([right_side[p], right_side[p+1]], fill=(255, 255, 255, 240), width=4)
|
|
|
|
# Центральный луч-нерв каждого лепестка
|
|
p_in = (CENTER + R_BASE * 0.95 * math.cos(a), CENTER + R_BASE * 0.95 * math.sin(a))
|
|
pg_draw.line([p_in, tip], fill=(255, 190, 45, 160), width=36)
|
|
pb_draw.line([p_in, tip], fill=(255, 235, 110, 220), width=14)
|
|
pc_draw.line([p_in, tip], fill=(255, 255, 255, 255), width=6)
|
|
|
|
# Плавные переплетающиеся дуги между 13 лучами (вместо жестких хорд-чертежей)
|
|
arcs_layer = Image.new('RGBA', (HI_SIZE, HI_SIZE), (0, 0, 0, 0))
|
|
adraw_arc = ImageDraw.Draw(arcs_layer)
|
|
for i in range(N_POINTS):
|
|
p1 = (CENTER + R_TIP * math.cos(angles[i]), CENTER + R_TIP * math.sin(angles[i]))
|
|
p2 = (CENTER + R_TIP * math.cos(angles[(i + 4) % N_POINTS]), CENTER + R_TIP * math.sin(angles[(i + 4) % N_POINTS]))
|
|
# Дуга, изогнутая к центру
|
|
mid_a = (angles[i] + angles[(i + 4) % N_POINTS]) / 2.0
|
|
if abs(angles[(i + 4) % N_POINTS] - angles[i]) > math.pi:
|
|
mid_a += math.pi
|
|
ctrl = (CENTER + R_WAIST * 0.95 * math.cos(mid_a), CENTER + R_WAIST * 0.95 * math.sin(mid_a))
|
|
|
|
arc_pts = []
|
|
for step in range(30):
|
|
t = step / 29.0
|
|
ax = (1-t)**2 * p1[0] + 2*(1-t)*t * ctrl[0] + t**2 * p2[0]
|
|
ay = (1-t)**2 * p1[1] + 2*(1-t)*t * ctrl[1] + t**2 * p2[1]
|
|
arc_pts.append((ax, ay))
|
|
for p in range(len(arc_pts) - 1):
|
|
adraw_arc.line([arc_pts[p], arc_pts[p+1]], fill=(140, 220, 255, 120), width=8)
|
|
pc_draw.line([arc_pts[p], arc_pts[p+1]], fill=(255, 255, 255, 180), width=3)
|
|
|
|
# 3. ЦЕНТРАЛЬНЫЙ ТРИСКЕЛИОН ХРОМ-999: ЖИДКИЙ ШЕЛК И ПЛАВНЫЕ СПИРАЛИ
|
|
trisk_glow = Image.new('RGBA', (HI_SIZE, HI_SIZE), (0, 0, 0, 0))
|
|
tgdraw = ImageDraw.Draw(trisk_glow)
|
|
|
|
trisk_body = Image.new('RGBA', (HI_SIZE, HI_SIZE), (0, 0, 0, 0))
|
|
tbdraw = ImageDraw.Draw(trisk_body)
|
|
|
|
# Единое центральное кольцо
|
|
R_RING = HI_SIZE * 0.088
|
|
tgdraw.ellipse([CENTER - R_RING, CENTER - R_RING, CENTER + R_RING, CENTER + R_RING], outline=(255, 185, 35, 220), width=44)
|
|
tbdraw.ellipse([CENTER - R_RING, CENTER - R_RING, CENTER + R_RING, CENTER + R_RING], outline=(255, 235, 120, 255), width=22)
|
|
pc_draw.ellipse([CENTER - R_RING, CENTER - R_RING, CENTER + R_RING, CENTER + R_RING], outline=(255, 255, 255, 255), width=8)
|
|
|
|
# 3 плавных хвоста девяток
|
|
for k in range(3):
|
|
rot = -math.pi / 2.0 + k * (2.0 * math.pi / 3.0)
|
|
spine = []
|
|
widths = []
|
|
|
|
# Плавное раскручивание от кольца
|
|
for step in range(50):
|
|
t = step / 49.0
|
|
ang = rot + t * 1.52
|
|
rad = R_RING + t * (HI_SIZE * 0.165)
|
|
px = CENTER + rad * math.cos(ang)
|
|
py = CENTER + rad * math.sin(ang)
|
|
spine.append((px, py))
|
|
w = 34.0 * (1.0 - t * 0.65)
|
|
widths.append(w)
|
|
|
|
# Изящная логарифмическая завитушка девяточки
|
|
tip_pt = spine[-1]
|
|
tip_ang = rot + 1.52
|
|
for f in range(40):
|
|
ft = f / 39.0
|
|
f_r = 78.0 * (1.0 - ft * 0.82)
|
|
f_a = tip_ang + ft * math.pi * 1.82
|
|
fx = tip_pt[0] + f_r * math.cos(f_a) - 78.0 * math.cos(tip_ang)
|
|
fy = tip_pt[1] + f_r * math.sin(f_a) - 78.0 * math.sin(tip_ang)
|
|
spine.append((fx, fy))
|
|
widths.append(max(4.0, 12.0 * (1.0 - ft * 0.72)))
|
|
|
|
# Каллиграфическая лента переменной толщины
|
|
left_edge = []
|
|
right_edge = []
|
|
for i in range(len(spine)):
|
|
p = spine[i]
|
|
w = widths[i] / 2.0
|
|
if i == 0:
|
|
dx = spine[1][0] - p[0]
|
|
dy = spine[1][1] - p[1]
|
|
elif i == len(spine) - 1:
|
|
dx = p[0] - spine[i-1][0]
|
|
dy = p[1] - spine[i-1][1]
|
|
else:
|
|
dx = spine[i+1][0] - spine[i-1][0]
|
|
dy = spine[i+1][1] - spine[i-1][1]
|
|
length = math.hypot(dx, dy) + 1e-6
|
|
nx = -dy / length
|
|
ny = dx / length
|
|
left_edge.append((p[0] + nx * w, p[1] + ny * w))
|
|
right_edge.append((p[0] - nx * w, p[1] - ny * w))
|
|
|
|
poly = left_edge + right_edge[::-1]
|
|
tgdraw.polygon(poly, fill=(255, 175, 30, 200))
|
|
tbdraw.polygon(poly, fill=(255, 240, 130, 255))
|
|
|
|
# Сверхгладкая центральная световая нить
|
|
for p in range(len(spine) - 1):
|
|
pc_draw.line([spine[p], spine[p+1]], fill=(255, 255, 255, 255), width=7)
|
|
|
|
# Центральное фотонное оптическое ядро (чистый мягкий сферический свет)
|
|
core = Image.new('RGBA', (HI_SIZE, HI_SIZE), (0, 0, 0, 0))
|
|
cdraw = ImageDraw.Draw(core)
|
|
for r_c in range(130, 0, -4):
|
|
alpha = int(255 * (1.0 - r_c / 130.0)**1.3)
|
|
cdraw.ellipse([CENTER - r_c, CENTER - r_c, CENTER + r_c, CENTER + r_c], fill=(255, 253, 240, alpha))
|
|
|
|
# Нежная горизонтальная световая линия аккреции
|
|
for dx in range(-650, 650, 2):
|
|
fade = 1.0 - (abs(dx) / 650.0)**2
|
|
alpha = int(180 * fade)
|
|
h_w = int(14 * (1.0 - abs(dx) / 650.0) + 2)
|
|
cdraw.ellipse([CENTER + dx - 2, CENTER - h_w, CENTER + dx + 2, CENTER + h_w], fill=(185, 242, 255, alpha))
|
|
|
|
# 4. СБОРКА И МНОГОУРОВНЕВЫЙ BLUR
|
|
comp = Image.alpha_composite(bg, petals_glow.filter(ImageFilter.GaussianBlur(50)))
|
|
comp = Image.alpha_composite(comp, trisk_glow.filter(ImageFilter.GaussianBlur(35)))
|
|
comp = Image.alpha_composite(comp, arcs_layer.filter(ImageFilter.GaussianBlur(15)))
|
|
comp = Image.alpha_composite(comp, petals_body)
|
|
comp = Image.alpha_composite(comp, trisk_body)
|
|
comp = Image.alpha_composite(comp, pc_draw._image if hasattr(pc_draw, '_image') else petals_core)
|
|
comp = Image.alpha_composite(comp, core)
|
|
|
|
# Финальный оптический bloom
|
|
bloom = comp.filter(ImageFilter.GaussianBlur(28))
|
|
comp = Image.blend(comp, bloom, 0.22)
|
|
|
|
# 5. СВЕРХКАЧЕСТВЕННЫЙ ДАУНСЕЙМПЛИНГ С 4096 ДО 1024 ЧЕРЕЗ LANCZOS
|
|
final_1024 = comp.resize((OUT_SIZE, OUT_SIZE), Image.Resampling.LANCZOS)
|
|
|
|
out_file = '/home/alexives/.gemini/antigravity-ide/brain/4ff924d9-3d7f-4202-9066-3ac5c3088b8e/star_13_celestial_plasma_flow.png'
|
|
final_1024.save(out_file, 'PNG')
|
|
print("Saved celestial plasma flow:", out_file)
|