Spaces:
Runtime error
Runtime error
| """The drawing behind a slide's text: stars, glows, planets, orbit rings and constellations. Each layout variant puts | |
| its drawing where its text is not, and the deck's seed moves it a little, so two decks never look alike while one deck | |
| always looks the same. The same list is drawn as SVG for the page and as a picture for the PowerPoint.""" | |
| import hashlib | |
| import math | |
| import random | |
| from dataclasses import dataclass, field | |
| from app.slides.themes import H, W | |
| class Shape: | |
| kind: str # glow | planet | ring | band | const | stars | |
| cx: float = 0 | |
| cy: float = 0 | |
| r: float = 0 | |
| rx: float = 0 | |
| ry: float = 0 | |
| rot: float = 0 | |
| color: str = "accent" # palette key | |
| opacity: float = 1.0 | |
| width: float = 2.0 | |
| points: list[tuple[float, float, float, float]] = field(default_factory=list) # stars: x, y, r, opacity | |
| edges: list[tuple[int, int]] = field(default_factory=list) | |
| # ring, band: only this part of the path, in degrees round it (0 to 180 is the half nearer the viewer, below the | |
| # centre before the tilt). None: all of it. | |
| arc: tuple[float, float] | None = None | |
| inner: float = 0 # band: the inner edge, as a share of rx and ry (the band fills from there out to the ring) | |
| class Decor: | |
| hot: tuple[float, float] # where the sky is brightest | |
| shapes: list[Shape] | |
| # Where a variant has room for a drawing: (x0, y0, x1, y1). None: only stars and a soft glow. | |
| FREE = { | |
| "dark-space": { | |
| ("points", "a"): (1520, 140, 1900, 940), ("points", "c"): None, ("points", "b"): None, ("points", "d"): None, | |
| ("agenda", "a"): (120, 660, 820, 1000), ("agenda", "b"): None, | |
| ("two_column", "a"): None, ("two_column", "b"): None, | |
| ("stat", "a"): None, ("stat", "b"): None, ("quote", "a"): None, ("quote", "b"): (140, 60, 760, 140), | |
| ("section", "b"): (1500, 60, 1900, 560), ("closing", "b"): None, ("closing", "c"): (140, 860, 960, 1060), | |
| }, | |
| "light-space": { | |
| ("points", "a"): None, ("points", "b"): None, ("points", "c"): None, ("points", "d"): None, | |
| ("agenda", "a"): None, ("agenda", "b"): (120, 760, 820, 1000), | |
| ("two_column", "a"): None, ("two_column", "b"): None, | |
| ("stat", "a"): None, ("stat", "b"): None, ("quote", "a"): None, ("quote", "b"): (100, 360, 400, 760), | |
| ("closing", "a"): None, ("closing", "b"): None, ("closing", "c"): None, | |
| }, | |
| } | |
| def _stars(rnd: random.Random, dark: bool) -> Shape: | |
| n = 120 if dark else 70 | |
| pts = [] | |
| for _ in range(n): | |
| if dark: | |
| r, op = rnd.choice((0.8, 1.0, 1.2, 1.2, 1.6, 2.2)), round(rnd.uniform(0.18, 0.85), 2) | |
| else: | |
| r, op = rnd.choice((0.9, 1.2, 1.5, 2.0)), round(rnd.uniform(0.08, 0.26), 2) | |
| pts.append((rnd.uniform(0, W), rnd.uniform(0, H), r, op)) | |
| return Shape("stars", points=pts, color="star") | |
| def _constellation(rnd: random.Random, box: tuple[float, float, float, float], n: int = 7) -> Shape: | |
| x0, y0, x1, y1 = box | |
| pts = [(rnd.uniform(x0, x1), rnd.uniform(y0, y1), rnd.choice((4.0, 5.0, 6.0, 8.0)), 1.0) for _ in range(n)] | |
| pts.sort(key=lambda p: p[0]) | |
| edges = [(i, i + 1) for i in range(n - 1)] | |
| if n > 4: | |
| edges.append((rnd.randrange(0, n - 3), rnd.randrange(n - 2, n))) | |
| return Shape("const", points=pts, edges=edges, color="accent", opacity=0.85) | |
| def on_ring(ring: Shape, degrees: float) -> tuple[float, float]: | |
| """The point at `degrees` round a ring's path, after its tilt: where a planet sits so it is on the drawn line. | |
| Same maths as the renderers (SVG rotate(rot cx cy), the PowerPoint's polyline).""" | |
| a, rot = math.radians(degrees), math.radians(ring.rot) | |
| x, y = ring.rx * math.cos(a), ring.ry * math.sin(a) | |
| return ring.cx + x * math.cos(rot) - y * math.sin(rot), ring.cy + x * math.sin(rot) + y * math.cos(rot) | |
| def ring_path(s: Shape, scale: float = 1.0, steps: int = 180) -> list[tuple[float, float]]: | |
| """Points along a ring's (scaled) path, over its arc, for the renderers to draw.""" | |
| a0, a1 = s.arc or (0, 360) | |
| scaled = Shape("ring", s.cx, s.cy, rx=s.rx * scale, ry=s.ry * scale, rot=s.rot) | |
| return [on_ring(scaled, a0 + (a1 - a0) * k / steps) for k in range(steps + 1)] | |
| # A ringed planet's band, from the inside out: (inner, outer, opacity) as shares of the ring. A brighter inner ring | |
| # and a fainter outer one with a dark gap between, as Saturn's are. | |
| BANDS = ((0.72, 0.86, 0.34), (0.89, 1.0, 0.22)) | |
| NEAR, FAR = (0, 180), (180, 360) | |
| def ringed_planet(cx: float, cy: float, r: float, rx: float, ry: float, rot: float, opacity: float = 1.0) -> list[Shape]: | |
| """A planet inside its rings: the far half of the rings goes behind the planet and the near half in front, so the | |
| rings wrap round it instead of lying flat over its face. The far half is a little dimmer, being further away.""" | |
| def half(arc: tuple[float, float], op: float) -> list[Shape]: | |
| out = [Shape("band", cx, cy, rx=rx * hi, ry=ry * hi, rot=rot, color="accent", opacity=o * op, arc=arc, inner=lo / hi) | |
| for lo, hi, o in BANDS] | |
| out.append(Shape("ring", cx, cy, rx=rx, ry=ry, rot=rot, color="accent", opacity=0.8 * op, width=2, arc=arc)) | |
| return out | |
| return [*half(FAR, 0.6 * opacity), Shape("planet", cx, cy, r), *half(NEAR, opacity)] | |
| def build(theme: str, layout: str, variant: str, seed: int, index: int) -> Decor: | |
| """The drawing for one slide.""" | |
| dark = theme == "dark-space" | |
| rnd = random.Random(int(hashlib.sha1(f"{seed}:{index}:{layout}:{variant}".encode()).hexdigest()[:12], 16)) | |
| j = lambda span: rnd.uniform(-span, span) # noqa: E731 (a small, seeded nudge) | |
| shapes = [_stars(rnd, dark)] | |
| hot = (W * rnd.uniform(0.25, 0.75), H * rnd.uniform(0.15, 0.5)) | |
| key = (layout, variant) | |
| if dark: | |
| if key == ("title", "a"): | |
| hot = (960, 760) | |
| shapes += [Shape("glow", 960, 900, 900, color="accent2", opacity=0.55), | |
| Shape("planet", 960 + j(60), 1080 + 560 + j(40), 820), | |
| Shape("ring", 960, 860 + j(20), rx=1150, ry=150, rot=-4 + j(3), color="accent", opacity=0.45, width=2.5)] | |
| elif key == ("title", "b"): | |
| cx, cy = 1520 + j(60), 300 + j(50) | |
| hot = (cx, cy) | |
| shapes += [Shape("glow", cx, cy, 520, color="accent2", opacity=0.5), | |
| *ringed_planet(cx, cy, 230 + j(25), rx=395, ry=82, rot=-18 + j(6))] | |
| elif key == ("title", "c"): | |
| hot = (1450, 540) | |
| shapes += [Shape("glow", 1450, 540, 620, color="accent2", opacity=0.35), | |
| _constellation(rnd, (1120, 170, 1800, 910), 8)] | |
| elif layout == "section" and variant == "a": | |
| hot = (960, 540) | |
| shapes += [Shape("glow", 960, 540, 760, color="accent2", opacity=0.35), | |
| Shape("ring", 960, 540 + j(20), rx=980, ry=260, rot=-8 + j(5), color="accent", opacity=0.3, width=2)] | |
| elif layout == "closing" and variant == "a": | |
| hot = (960, 980) | |
| shapes += [Shape("glow", 960, 1120, 760, color="accent2", opacity=0.5), | |
| Shape("ring", 960, 1210, rx=1080, ry=880, rot=0, color="accent", opacity=0.35, width=2.5)] | |
| else: | |
| corner = rnd.choice(((0, 0), (W, 0), (0, H), (W, H))) | |
| shapes.append(Shape("glow", corner[0], corner[1], 700, color="accent2", opacity=0.32)) | |
| hot = (corner[0] * 0.8 + W * 0.1, corner[1] * 0.8 + H * 0.1) | |
| free = FREE["dark-space"].get(key) | |
| if free: | |
| x0, y0, x1, y1 = free | |
| r = min(x1 - x0, y1 - y0) * rnd.uniform(0.26, 0.34) | |
| cx, cy = rnd.uniform(x0 + r, x1 - r), rnd.uniform(y0 + r, y1 - r) | |
| shapes += [Shape("glow", cx, cy, r * 2.2, color="accent2", opacity=0.35), | |
| *ringed_planet(cx, cy, r, rx=r * 1.8, ry=r * 0.38, rot=-16 + j(10), opacity=0.9)] | |
| else: | |
| ring = lambda cx, cy, r, op=0.3: Shape("ring", cx, cy, rx=r, ry=r, color="accent2", opacity=op, width=2) # noqa: E731 | |
| if key == ("title", "a"): | |
| cx, cy = 2010 + j(40), 540 + j(60) | |
| hot = (1500, 540) | |
| orbit = ring(cx, cy, 540, 0.24) | |
| shapes += [ring(cx, cy, 360), orbit, ring(cx, cy, 740, 0.18), Shape("planet", *on_ring(orbit, 200 + j(20)), 34)] | |
| elif key == ("title", "b"): | |
| hot = (1500, 820) | |
| shapes += [Shape("glow", 1560, 840, 520, color="accent", opacity=0.12), | |
| _constellation(rnd, (1360, 660, 1800, 980), 7)] | |
| elif key == ("title", "c"): | |
| hot = (960, 540) | |
| rot = -10 + j(4) # one tilt for both, so the rings stay concentric | |
| orbit = Shape("ring", 960, 520, rx=900, ry=330, rot=rot, color="accent2", opacity=0.28, width=2.5) | |
| shapes += [orbit, Shape("ring", 960, 520, rx=1040, ry=400, rot=rot, color="accent2", opacity=0.14, width=2), | |
| Shape("planet", *on_ring(orbit, rnd.choice((20, 160, 200, 340)) + j(10)), 30)] | |
| elif key in (("section", "a"), ("section", "b")): | |
| cx, toward = (1960, 180) if variant == "a" else (-40, 0) # the planet sits on the side facing the text | |
| orbit = ring(cx, 560, 460, 0.22) | |
| shapes += [ring(cx, 560, 300), orbit, ring(cx, 560, 640, 0.15), Shape("planet", *on_ring(orbit, toward + j(10)), 26)] | |
| elif key == ("closing", "c"): | |
| hot = (960, 860) | |
| shapes += [Shape("ring", 960, 540, rx=1000, ry=470, rot=6 + j(4), color="accent2", opacity=0.2, width=2.5)] | |
| else: | |
| corner = rnd.choice(((W + 60, -60), (W + 60, H + 60), (-60, H + 60))) | |
| shapes += [ring(corner[0], corner[1], 260, 0.22), ring(corner[0], corner[1], 400, 0.15)] | |
| free = FREE["light-space"].get(key) | |
| if free: | |
| shapes.append(_constellation(rnd, free, 5)) | |
| return Decor(hot, shapes) | |