oledgifstudio 0.1.0__py3-none-any.whl

oledgif/__init__.py

@@ -0,0 +1,3 @@
+"""oledgif — générateur de GIFs animés pour écrans OLED (SteelSeries, SSD1306, ...)."""
+
+__version__ = "0.1.0"

oledgif/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

oledgif/cli.py

@@ -0,0 +1,176 @@
+"""CLI : python -m oledgif "TEXTE" [options]"""
+
+import argparse
+import os
+import random
+import string
+import sys
+
+from . import __version__
+from .describe import parse as parse_description
+from .effects import ALNUM, DESCRIPTIONS, EFFECTS, Ctx
+from .fonts import load_font
+from .patterns import PATTERNS
+from .presets import DEFAULT_PRESET, PRESETS, resolve_size
+from .render import convert_animation, load_source, save_gif
+
+from PIL import Image
+
+CHARSETS = {
+    "alnum": ALNUM,
+    "digits": string.digits,
+    "upper": string.digits + string.ascii_uppercase,
+    "letters": string.ascii_letters,
+    "ascii": "".join(c for c in string.printable if c.isprintable() and c != " "),
+}
+
+
+def build_parser():
+    p = argparse.ArgumentParser(
+        prog="oledgif",
+        description="Génère des GIFs animés 1 bit pour écrans OLED (SteelSeries, SSD1306...).",
+    )
+    p.add_argument("text", nargs="?", help="texte à animer (optionnel avec --image ou un motif)")
+    p.add_argument("-d", "--describe", metavar="PHRASE",
+                   help="décrire l'animation en langage naturel, ex: 'GG qui clignote vite'")
+    p.add_argument("-i", "--image", metavar="FICHIER",
+                   help="image source (PNG/JPG/GIF...) : convertie en 1 bit avec tramage ; "
+                        "un GIF animé est converti tel quel si --effect vaut auto/convert")
+    p.add_argument("--style", default="photo", choices=["photo", "solid", "comic", "edges"],
+                   help="rendu de --image : photo = contraste+netteté+tramage (défaut), "
+                        "solid = seuillage net (logos), comic = solid + contours blancs "
+                        "des formes perdues dans le noir (illustrations), "
+                        "edges = contours blancs sur noir")
+    p.add_argument("--fit", default="contain", choices=["contain", "cover"],
+                   help="contain = image entière (défaut), cover = remplit l'écran en "
+                        "recadrant — recommandé pour les photos paysage")
+    p.add_argument("--no-dither", action="store_true",
+                   help="alias de --style solid")
+    p.add_argument("--no-denoise", action="store_true",
+                   help="garde le bruit : désactive le filtre médian et la suppression "
+                        "des pixels isolés (reflets, sources de lumière ponctuelles)")
+    p.add_argument("-o", "--out", default=None, help="fichier de sortie (.gif)")
+    p.add_argument("-p", "--preset", default=None,
+                   help=f"écran cible (défaut: {DEFAULT_PRESET}) — voir --list-presets")
+    p.add_argument("--size", default=None, metavar="WxH", help="taille custom, ex: 128x40")
+    p.add_argument("-e", "--effect", default="auto",
+                   help="effet (défaut: auto) — voir --list-effects")
+    p.add_argument("--fps", type=int, default=15)
+    p.add_argument("--seconds", type=float, default=4.0, help="durée cible (certains effets la déduisent)")
+    p.add_argument("--speed", type=float, default=None, help="vitesse de défilement en px/s (scroll)")
+    p.add_argument("--font", default=None, help="chemin d'une police .ttf")
+    p.add_argument("--font-size", type=int, default=None)
+    p.add_argument("--charset", default="alnum",
+                   help="alnum|digits|upper|letters|ascii ou chaîne littérale (matrix/slot)")
+    p.add_argument("--invert", action="store_true", help="noir sur blanc")
+    p.add_argument("--scale", type=int, default=1, help="agrandit le GIF xN (aperçu)")
+    p.add_argument("--seed", type=int, default=None, help="graine aléatoire (rendu reproductible)")
+    p.add_argument("--demo", action="store_true", help="génère un exemple de chaque effet dans ./samples")
+    p.add_argument("--list-effects", action="store_true")
+    p.add_argument("--list-presets", action="store_true")
+    p.add_argument("--version", action="version", version=f"oledgif {__version__}")
+    return p
+
+
+def make_gif(text, out, *, preset=None, size=None, effect="auto", fps=15, seconds=4.0,
+             speed=None, font_path=None, font_size=None, charset=ALNUM,
+             invert=False, scale=1, seed=None, image=None, style="photo", fit="contain",
+             denoise=True):
+    W, H = resolve_size(preset, size)
+    font = load_font(font_path, font_size, screen_h=H)
+
+    src = None
+    if image:
+        im = Image.open(image)
+        if getattr(im, "is_animated", False) and effect in ("auto", "convert"):
+            # GIF animé -> conversion frame par frame, durées d'origine conservées
+            frames, durations = convert_animation(image, W, H, style, fit, denoise)
+            n, duration = save_gif(frames, out, fps=fps, invert=invert,
+                                   scale=scale, durations=durations)
+            return out, "convert", W, H, n, duration
+        im.close()
+        src = load_source(image, W, H, style, fit, denoise)
+        if effect in ("auto", "convert"):
+            effect = "vhs"
+
+    if effect == "auto":
+        try:
+            wide = font.getlength(text) > W - 4
+        except AttributeError:
+            wide = len(text) * 7 > W - 4
+        effect = "scroll" if wide else "wave"
+    if effect not in EFFECTS:
+        raise SystemExit(f"Effet inconnu: {effect!r}. Effets: {', '.join(EFFECTS)}")
+
+    ctx = Ctx(text=text or "", W=W, H=H, fps=fps, seconds=seconds, font=font,
+              font_path=font_path, font_size=font_size, charset=charset,
+              speed=speed, src=src, rng=random.Random(seed))
+    frames = EFFECTS[effect](ctx)
+    n, duration = save_gif(frames, out, fps=fps, invert=invert, scale=scale)
+    return out, effect, W, H, n, duration
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+
+    if args.list_effects:
+        for name, desc in DESCRIPTIONS.items():
+            print(f"  {name:<11} {desc}")
+        return 0
+    if args.list_presets:
+        for name, (w, h, desc) in PRESETS.items():
+            print(f"  {name:<12} {w}x{h:<4} {desc}")
+        return 0
+
+    charset = CHARSETS.get(args.charset, args.charset)
+
+    if args.demo:
+        outdir = "samples"
+        os.makedirs(outdir, exist_ok=True)
+        text = args.text or "GG WP 42"
+        for name in EFFECTS:
+            out = os.path.join(outdir, f"{name}.gif")
+            make_gif(text, out, preset=args.preset, size=args.size, effect=name,
+                     fps=args.fps, seconds=args.seconds, speed=args.speed,
+                     font_path=args.font, font_size=args.font_size, charset=charset,
+                     invert=args.invert, scale=args.scale, seed=args.seed or 42)
+            print(f"  {out}")
+        return 0
+
+    text, effect, fps, seconds = args.text, args.effect, args.fps, args.seconds
+    if args.describe:
+        parsed = parse_description(args.describe)
+        text = parsed.get("text", text)
+        if effect == "auto":
+            effect = parsed.get("effect", "auto")
+        fps = parsed.get("fps", fps)
+        seconds = parsed.get("seconds", seconds)
+
+    textless_ok = args.image or effect in PATTERNS or effect == "matrix"
+    if not text and not textless_ok:
+        print("Erreur: aucun texte. Passe-le en argument, entre guillemets dans --describe, "
+              "ou utilise --image / un motif (starfield, plasma, life, eq, scope, radar).",
+              file=sys.stderr)
+        return 2
+
+    if args.out:
+        out = args.out
+    elif text:
+        out = "".join(c if c.isalnum() else "_" for c in text)[:24] + ".gif"
+    elif args.image:
+        out = os.path.splitext(os.path.basename(args.image))[0] + "_oled.gif"
+    else:
+        out = f"{effect}.gif"
+    out, effect, W, H, n, duration = make_gif(
+        text, out, preset=args.preset, size=args.size, effect=effect, fps=fps,
+        seconds=seconds, speed=args.speed, font_path=args.font,
+        font_size=args.font_size, charset=charset, invert=args.invert,
+        scale=args.scale, seed=args.seed, image=args.image,
+        style="solid" if args.no_dither else args.style, fit=args.fit,
+        denoise=not args.no_denoise)
+    print(f"{out}  —  {W}x{H}, effet {effect}, {n} frames @ {duration} ms")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

oledgif/describe.py

@@ -0,0 +1,60 @@
+"""Mode langage naturel (FR/EN) : une phrase -> effet + paramètres.
+
+Pas de modèle IA : simple correspondance de mots-clés, instantané et gratuit.
+"""
+
+import re
+import unicodedata
+
+KEYWORDS = {
+    "scroll":     ["defile", "defilant", "scroll", "marquee", "bandeau", "glisse a gauche"],
+    "typewriter": ["machine a ecrire", "typewriter", "tape", "frappe", "ecrit lettre"],
+    "wave":       ["vague", "wave", "ondule", "ondulation", "flotte"],
+    "blink":      ["clignote", "clignotant", "blink", "flash", "flashe"],
+    "bounce":     ["rebond", "rebondit", "bounce", "dvd"],
+    "matrix":     ["matrix", "pluie", "rain", "code qui tombe", "hacker"],
+    "slot":       ["slot", "machine a sous", "roulette", "casino", "tirage", "jackpot"],
+    "glitch":     ["glitch", "bug", "corrompu", "casse", "parasite"],
+    "pulse":      ["pulse", "bat", "battement", "coeur", "respire", "zoom"],
+    "slide":      ["slide", "monte", "remonte", "entre par le bas", "générique", "credits"],
+    "vhs":        ["vhs", "vintage", "retro", "cassette", "tracking", "analogique", "crt"],
+    # motifs sans texte
+    "starfield":  ["etoile", "star", "warp", "espace", "hyperespace", "galaxie"],
+    "plasma":     ["plasma", "lave", "psychedelique"],
+    "life":       ["jeu de la vie", "conway", "cellule", "automate"],
+    "eq":         ["egaliseur", "equalizer", "musique", "spectre", "barres audio", "visualiseur"],
+    "scope":      ["oscilloscope", "oscillo", "onde", "signal", "sinusoide"],
+    "radar":      ["radar", "sonar", "balayage", "echo"],
+}
+
+
+def _fold(s: str) -> str:
+    s = unicodedata.normalize("NFD", s.lower())
+    return "".join(c for c in s if unicodedata.category(c) != "Mn")
+
+
+def parse(description: str) -> dict:
+    """Retourne {effect, text?, fps?, seconds?} déduits de la phrase."""
+    folded = _fold(description)
+    out: dict = {}
+
+    # texte entre guillemets : "..." '...' «...» “...”
+    m = re.search(r'["\'«“](.+?)["\'»”]', description)
+    if m:
+        out["text"] = m.group(1)
+
+    for effect, words in KEYWORDS.items():
+        if any(w in folded for w in words):
+            out["effect"] = effect
+            break
+
+    if any(w in folded for w in ("rapide", "vite", "fast", "quick")):
+        out["fps"] = 25
+    elif any(w in folded for w in ("lent", "lentement", "slow", "doucement")):
+        out["fps"] = 10
+
+    m = re.search(r"(\d+(?:[.,]\d+)?)\s*s(?:ec|econdes?)?\b", folded)
+    if m:
+        out["seconds"] = float(m.group(1).replace(",", "."))
+
+    return out

oledgif/effects.py

@@ -0,0 +1,321 @@
+"""Effets d'animation. Chaque effet reçoit un Ctx et retourne une liste de frames "L"."""
+
+import math
+import random
+import string
+from dataclasses import dataclass, field
+
+from PIL import Image, ImageDraw
+
+from .fonts import fit_font, load_font
+from .render import canvas, char_images, text_image
+
+ALNUM = string.digits + string.ascii_uppercase + string.ascii_lowercase
+
+EFFECTS: dict[str, callable] = {}
+DESCRIPTIONS: dict[str, str] = {}
+
+
+def effect(name: str, desc: str):
+    def deco(fn):
+        EFFECTS[name] = fn
+        DESCRIPTIONS[name] = desc
+        return fn
+    return deco
+
+
+@dataclass
+class Ctx:
+    text: str
+    W: int
+    H: int
+    fps: int = 15
+    seconds: float = 4.0
+    font: object = None
+    font_path: str | None = None
+    font_size: int | None = None
+    charset: str = ALNUM
+    speed: float | None = None  # px/s pour scroll
+    src: object = None  # image source (--image) ; sinon le texte est rendu
+    rng: random.Random = field(default_factory=random.Random)
+
+    @property
+    def nframes(self) -> int:
+        return max(2, int(round(self.fps * self.seconds)))
+
+    def center(self, img) -> tuple[int, int]:
+        return (self.W - img.width) // 2, (self.H - img.height) // 2
+
+    def sprite(self):
+        """Ce que l'effet anime : l'image fournie, sinon le texte rendu."""
+        return self.src if self.src is not None else text_image(self.text, self.font)
+
+
+# ---------------------------------------------------------------- scroll
+
+@effect("scroll", "le texte/l'image défile de droite à gauche (boucle parfaite)")
+def scroll(ctx: Ctx):
+    timg = ctx.sprite()
+    speed = ctx.speed or max(20.0, ctx.W / 3)  # px/s
+    travel = ctx.W + timg.width
+    n = max(2, int(round(travel / speed * ctx.fps)))
+    y = (ctx.H - timg.height) // 2
+    frames = []
+    for i in range(n):
+        f = canvas(ctx.W, ctx.H)
+        x = ctx.W - int(round(travel * i / n))
+        f.paste(timg, (x, y))
+        frames.append(f)
+    return frames
+
+
+# ---------------------------------------------------------------- typewriter
+
+@effect("typewriter", "machine à écrire : les lettres apparaissent une à une, curseur clignotant")
+def typewriter(ctx: Ctx):
+    cps = 8  # caractères/seconde
+    fpc = max(1, round(ctx.fps / cps))
+    blink = max(1, ctx.fps // 2)
+    hold = int(ctx.fps * 1.5)
+    frames = []
+    total = len(ctx.text) * fpc + hold
+    for t in range(total):
+        k = min(len(ctx.text), t // fpc + 1) if t < len(ctx.text) * fpc else len(ctx.text)
+        part = ctx.text[:k]
+        timg = text_image(part, ctx.font) if part.strip() else None
+        f = canvas(ctx.W, ctx.H)
+        w = timg.width if timg else int(ctx.font.getlength(part)) if part else 0
+        x = min(2, ctx.W - 6 - w)  # reste lisible si le texte déborde
+        y = (ctx.H - (timg.height if timg else ctx.H // 2)) // 2
+        if timg:
+            f.paste(timg, (x, y))
+        if (t // blink) % 2 == 0:  # curseur bloc
+            ch = timg.height if timg else max(8, ctx.H // 2)
+            cx = x + w + 2
+            ImageDraw.Draw(f).rectangle([cx, y, cx + max(3, ch // 2), y + ch], fill=255)
+        frames.append(f)
+    return frames
+
+
+# ---------------------------------------------------------------- wave
+
+@effect("wave", "les lettres ondulent verticalement en vague")
+def wave(ctx: Ctx):
+    chars = char_images(ctx.text, ctx.font)
+    total_w = sum(adv for _, adv in chars)
+    x0 = (ctx.W - total_w) // 2
+    max_h = max((im.height for im, _ in chars if im), default=ctx.H // 2)
+    mid = (ctx.H - max_h) // 2
+    amp = max(1, min(mid, int(ctx.H * 0.18)))
+    frames = []
+    for t in range(ctx.nframes):
+        f = canvas(ctx.W, ctx.H)
+        phase = 2 * math.pi * t / ctx.nframes * max(1, round(ctx.seconds))
+        x = x0
+        for i, (im, adv) in enumerate(chars):
+            if im:
+                y = mid + int(round(amp * math.sin(phase + i * 0.7)))
+                f.paste(im, (x, y))
+            x += adv
+        frames.append(f)
+    return frames
+
+
+# ---------------------------------------------------------------- blink
+
+@effect("blink", "le texte/l'image clignote")
+def blink(ctx: Ctx):
+    timg = ctx.sprite()
+    pos = ctx.center(timg)
+    period = max(2, ctx.fps // 2)
+    frames = []
+    for t in range(ctx.nframes):
+        f = canvas(ctx.W, ctx.H)
+        if (t // period) % 2 == 0:
+            f.paste(timg, pos)
+        frames.append(f)
+    return frames
+
+
+# ---------------------------------------------------------------- bounce
+
+@effect("bounce", "le texte/l'image rebondit sur les bords (façon logo DVD)")
+def bounce(ctx: Ctx):
+    timg = ctx.sprite()
+    free_x, free_y = max(0, ctx.W - timg.width), max(0, ctx.H - timg.height)
+    vx = free_x / (ctx.fps * 1.6) if free_x else 0.0
+    vy = free_y / (ctx.fps * 0.9) if free_y else 0.0
+    vx, vy = max(vx, 0.4) if free_x else 0, max(vy, 0.4) if free_y else 0
+    x, y = free_x * 0.3, free_y * 0.7
+    frames = []
+    for _ in range(ctx.nframes):
+        f = canvas(ctx.W, ctx.H)
+        f.paste(timg, (int(round(x)), int(round(y))))
+        frames.append(f)
+        x += vx
+        y += vy
+        if free_x and (x < 0 or x > free_x):
+            vx = -vx
+            x = max(0.0, min(x, float(free_x)))
+        if free_y and (y < 0 or y > free_y):
+            vy = -vy
+            y = max(0.0, min(y, float(free_y)))
+    return frames
+
+
+# ---------------------------------------------------------------- matrix
+
+@effect("matrix", "pluie de caractères alphanumériques ; le texte se révèle au centre (texte optionnel)")
+def matrix(ctx: Ctx):
+    fm = load_font(ctx.font_path, size=max(8, ctx.H // 4), screen_h=ctx.H)
+    cell_w = max(4, int(round(fm.getlength("0")))) if hasattr(fm, "getlength") else 6
+    cell_h = max(6, text_image("0", fm).height + 1)
+    ncols, nrows = max(1, ctx.W // cell_w), max(1, ctx.H // cell_h) + 1
+    rng = ctx.rng
+    grid = [[rng.choice(ctx.charset) for _ in range(nrows)] for _ in range(ncols)]
+    heads = [rng.uniform(0, nrows) for _ in range(ncols)]
+    speeds = [rng.uniform(0.15, 0.55) for _ in range(ncols)]
+    trails = [rng.randint(2, max(3, nrows)) for _ in range(ncols)]
+    reveal_at = int(ctx.nframes * 0.55)
+    timg = ctx.sprite() if (ctx.text.strip() or ctx.src is not None) else None
+    frames = []
+    for t in range(ctx.nframes):
+        f = canvas(ctx.W, ctx.H)
+        d = ImageDraw.Draw(f)
+        for c in range(ncols):
+            heads[c] = (heads[c] + speeds[c]) % (nrows + trails[c])
+            if rng.random() < 0.15:
+                grid[c][rng.randrange(nrows)] = rng.choice(ctx.charset)
+            for k in range(trails[c]):
+                r = int(heads[c]) - k
+                if 0 <= r < nrows:
+                    d.text((c * cell_w, r * cell_h), grid[c][r], font=fm, fill=255)
+        if timg and t >= reveal_at:
+            x, y = ctx.center(timg)
+            d.rectangle([x - 3, y - 2, x + timg.width + 2, y + timg.height + 1], fill=0)
+            f.paste(timg, (x, y))
+        frames.append(f)
+    return frames
+
+
+# ---------------------------------------------------------------- slot
+
+@effect("slot", "machine à sous : chaque position cycle sur tout l'alphabet puis se fige")
+def slot(ctx: Ctx):
+    cells = len(ctx.text)
+    size = ctx.font_size or max(8, int(ctx.H * 0.62))
+    font = fit_font("0" * max(1, cells), ctx.W - 4, ctx.font_path, size, ctx.H)
+    cell_w = int(round(font.getlength("0"))) + 1 if hasattr(font, "getlength") else 7
+    x0 = (ctx.W - cell_w * cells) // 2
+    lock = [int(ctx.nframes * 0.7 * (i + 1) / (cells + 1)) for i in range(cells)]
+    rng = ctx.rng
+    frames = []
+    for t in range(ctx.nframes):
+        f = canvas(ctx.W, ctx.H)
+        d = ImageDraw.Draw(f)
+        for i, target in enumerate(ctx.text):
+            ch = target if (t >= lock[i] or target == " ") else rng.choice(ctx.charset)
+            im = text_image(ch, font) if ch != " " else None
+            if im:
+                f.paste(im, (x0 + i * cell_w + (cell_w - im.width) // 2,
+                             (ctx.H - im.height) // 2))
+        frames.append(f)
+    return frames
+
+
+# ---------------------------------------------------------------- glitch
+
+@effect("glitch", "texte/image corrompu : bandes décalées et bruit aléatoire")
+def glitch(ctx: Ctx):
+    base = canvas(ctx.W, ctx.H)
+    timg = ctx.sprite()
+    base.paste(timg, ctx.center(timg))
+    rng = ctx.rng
+    frames = []
+    for t in range(ctx.nframes):
+        f = base.copy()
+        if t % 7 != 0:  # frame propre régulière, ça respire
+            for _ in range(rng.randint(1, 3)):
+                y0 = rng.randrange(0, ctx.H - 2)
+                h = rng.randint(2, max(3, ctx.H // 5))
+                dx = rng.randint(-ctx.W // 8, ctx.W // 8)
+                band = f.crop((0, y0, ctx.W, min(ctx.H, y0 + h)))
+                ImageDraw.Draw(f).rectangle([0, y0, ctx.W, y0 + h], fill=0)
+                f.paste(band, (dx, y0))
+            px = f.load()
+            for _ in range(int(ctx.W * ctx.H * 0.006)):
+                px[rng.randrange(ctx.W), rng.randrange(ctx.H)] = 255
+        frames.append(f)
+    return frames
+
+
+# ---------------------------------------------------------------- pulse
+
+@effect("pulse", "le texte/l'image bat comme un cœur (zoom avant/arrière)")
+def pulse(ctx: Ctx):
+    timg = ctx.sprite()
+    frames = []
+    for t in range(ctx.nframes):
+        s = 0.55 + 0.45 * (0.5 + 0.5 * math.sin(2 * math.pi * t / ctx.fps))
+        im = timg.resize((max(1, int(timg.width * s)), max(1, int(timg.height * s))),
+                         Image.NEAREST)
+        f = canvas(ctx.W, ctx.H)
+        f.paste(im, ctx.center(im))
+        frames.append(f)
+    return frames
+
+
+# ---------------------------------------------------------------- vhs
+
+@effect("vhs", "tremblement horizontal façon cassette vidéo (défaut pour les images)")
+def vhs(ctx: Ctx):
+    base = canvas(ctx.W, ctx.H)
+    timg = ctx.sprite()
+    base.paste(timg, ctx.center(timg))
+    rng = ctx.rng
+    n = ctx.nframes
+    tau = 2 * math.pi
+    cycles = max(1, round(ctx.seconds / 2))  # ondulations complètes par boucle
+    frames = []
+    for t in range(n):
+        ph = tau * t / n
+        f = canvas(ctx.W, ctx.H)
+        band_y = int(ctx.H * t / n)  # bande de tracking, 1 passage par boucle
+        jerk = rng.choice((-2, 2)) if rng.random() < 0.12 else 0  # à-coup
+        for y in range(ctx.H):
+            off = round(1.6 * math.sin(ph * cycles + y / 6.5)
+                        + 0.9 * math.sin(ph * 2 * cycles + y / 2.8)) + jerk
+            if abs(y - band_y) < 2:
+                off += 4 + rng.randint(0, 3)
+            row = base.crop((0, y, ctx.W, y + 1))
+            f.paste(row, (off % ctx.W, y))
+            f.paste(row, (off % ctx.W - ctx.W, y))  # bouclage horizontal
+        d = ImageDraw.Draw(f)
+        for _ in range(rng.randint(2, 6)):  # poussière sur la bande
+            x = rng.randrange(ctx.W)
+            d.line([x, band_y, min(ctx.W - 1, x + rng.randint(1, 4)), band_y], fill=255)
+        frames.append(f)
+    return frames
+
+
+# ---------------------------------------------------------------- slide
+
+@effect("slide", "le texte/l'image entre par le bas, pause, sort par le haut")
+def slide(ctx: Ctx):
+    timg = ctx.sprite()
+    x, yc = ctx.center(timg)
+    n = ctx.nframes
+    n_in, n_out = int(n * 0.25), int(n * 0.25)
+    frames = []
+    for t in range(n):
+        f = canvas(ctx.W, ctx.H)
+        if t < n_in:
+            y = ctx.H - int((ctx.H - yc) * (t + 1) / n_in)
+        elif t >= n - n_out:
+            k = t - (n - n_out)
+            y = yc - int((yc + timg.height) * (k + 1) / n_out)
+        else:
+            y = yc
+        f.paste(timg, (x, y))
+        frames.append(f)
+    return frames

oledgif/fonts.py

@@ -0,0 +1,34 @@
+"""Chargement de police. Priorité aux monospaces (rendu stable sur petit écran)."""
+
+from PIL import ImageFont
+
+# ImageFont.truetype cherche automatiquement dans C:\Windows\Fonts sous Windows.
+CANDIDATES = ["consola.ttf", "lucon.ttf", "cour.ttf", "DejaVuSansMono.ttf", "arial.ttf"]
+
+
+def load_font(path: str | None = None, size: int | None = None, screen_h: int = 40):
+    if size is None:
+        size = max(8, int(screen_h * 0.62))
+    if path:
+        return ImageFont.truetype(path, size)
+    for name in CANDIDATES:
+        try:
+            return ImageFont.truetype(name, size)
+        except OSError:
+            continue
+    return ImageFont.load_default()
+
+
+def fit_font(text: str, max_w: int, path: str | None, size: int, screen_h: int):
+    """Réduit la taille jusqu'à ce que `text` tienne dans max_w pixels."""
+    font = load_font(path, size, screen_h)
+    while size > 7:
+        try:
+            width = font.getlength(text)
+        except AttributeError:  # bitmap fallback sans getlength
+            break
+        if width <= max_w:
+            break
+        size -= 1
+        font = load_font(path, size, screen_h)
+    return font

oledgif/patterns.py

@@ -0,0 +1,165 @@
+"""Motifs animés sans texte : écrans de veille pour OLED.
+
+Importé pour ses effets de bord (enregistrement dans EFFECTS).
+"""
+
+import math
+
+from PIL import ImageDraw
+
+from .effects import Ctx, effect
+from .render import canvas
+
+# Effets utilisables sans texte ni image
+PATTERNS = {"starfield", "plasma", "life", "eq", "scope", "radar"}
+
+_BAYER4 = [[0, 8, 2, 10], [12, 4, 14, 6], [3, 11, 1, 9], [15, 7, 13, 5]]
+
+
+@effect("starfield", "champ d'étoiles en hyperespace (sans texte)")
+def starfield(ctx: Ctx):
+    rng = ctx.rng
+    n = max(24, ctx.W * ctx.H // 140)
+    stars = [[rng.uniform(-1, 1), rng.uniform(-1, 1), rng.uniform(0.08, 1.0)]
+             for _ in range(n)]
+    cx, cy = ctx.W / 2, ctx.H / 2
+    frames = []
+    for _ in range(ctx.nframes):
+        f = canvas(ctx.W, ctx.H)
+        px = f.load()
+        for s in stars:
+            s[2] -= 0.022
+            if s[2] <= 0.06:
+                s[0], s[1], s[2] = rng.uniform(-1, 1), rng.uniform(-1, 1), 1.0
+            x, y = cx + s[0] / s[2] * cx, cy + s[1] / s[2] * cy
+            if 0 <= x < ctx.W and 0 <= y < ctx.H:
+                px[int(x), int(y)] = 255
+                if s[2] < 0.3:  # étoiles proches plus grosses
+                    if x + 1 < ctx.W:
+                        px[int(x) + 1, int(y)] = 255
+                    if y + 1 < ctx.H:
+                        px[int(x), int(y) + 1] = 255
+        frames.append(f)
+    return frames
+
+
+@effect("plasma", "plasma rétro tramé Bayer, boucle parfaite (sans texte)")
+def plasma(ctx: Ctx):
+    W, H = ctx.W, ctx.H
+    frames = []
+    for t in range(ctx.nframes):
+        ph = 2 * math.pi * t / ctx.nframes
+        f = canvas(W, H)
+        px = f.load()
+        for y in range(H):
+            for x in range(W):
+                v = (math.sin(x / 9 + 2 * ph)
+                     + math.sin(y / 5 - 2 * ph)
+                     + math.sin((x + y) / 11 + 4 * ph)
+                     + math.sin(math.hypot(x - W / 2, y - H / 2) / 6 - 2 * ph)) / 4
+                if (v + 1) * 8 > _BAYER4[y % 4][x % 4]:
+                    px[x, y] = 255
+        frames.append(f)
+    return frames
+
+
+@effect("life", "jeu de la vie de Conway, soupe aléatoire (sans texte)")
+def life(ctx: Ctx):
+    cell = 2
+    gw, gh = max(4, ctx.W // cell), max(4, ctx.H // cell)
+    rng = ctx.rng
+    grid = [[1 if rng.random() < 0.35 else 0 for _ in range(gw)] for _ in range(gh)]
+    frames = []
+    for _ in range(ctx.nframes):
+        f = canvas(ctx.W, ctx.H)
+        d = ImageDraw.Draw(f)
+        for r in range(gh):
+            for c in range(gw):
+                if grid[r][c]:
+                    d.rectangle([c * cell, r * cell, c * cell + cell - 1,
+                                 r * cell + cell - 1], fill=255)
+        frames.append(f)
+        nxt = [[0] * gw for _ in range(gh)]
+        alive = 0
+        for r in range(gh):
+            for c in range(gw):
+                nb = sum(grid[(r + dr) % gh][(c + dc) % gw]
+                         for dr in (-1, 0, 1) for dc in (-1, 0, 1)
+                         if (dr, dc) != (0, 0))
+                nxt[r][c] = 1 if (nb == 3 or (grid[r][c] and nb == 2)) else 0
+                alive += nxt[r][c]
+        grid = nxt
+        if alive < gw * gh * 0.03:  # la soupe est morte : on ressème
+            grid = [[1 if rng.random() < 0.35 else 0 for _ in range(gw)]
+                    for _ in range(gh)]
+    return frames
+
+
+@effect("eq", "égaliseur audio : barres et pics qui retombent (sans texte)")
+def eq(ctx: Ctx):
+    bar_w, gap = 4, 2
+    nb = max(3, (ctx.W + gap) // (bar_w + gap))
+    rng = ctx.rng
+    freqs = [(rng.randint(1, 3), rng.randint(2, 5), rng.uniform(0, math.tau))
+             for _ in range(nb)]
+    peaks = [0.0] * nb
+    frames = []
+    for t in range(ctx.nframes):
+        ph = 2 * math.pi * t / ctx.nframes
+        f = canvas(ctx.W, ctx.H)
+        d = ImageDraw.Draw(f)
+        for i, (f1, f2, p0) in enumerate(freqs):
+            v = abs(0.65 * math.sin(f1 * ph + p0) + 0.35 * math.sin(f2 * ph + 2 * p0))
+            h = max(1, int(v * (ctx.H - 3)))
+            peaks[i] = max(peaks[i] - ctx.H / (ctx.fps * 1.2), h + 2)
+            x = i * (bar_w + gap)
+            d.rectangle([x, ctx.H - h, x + bar_w - 1, ctx.H - 1], fill=255)
+            py = ctx.H - 1 - int(min(peaks[i], ctx.H - 1))
+            d.line([x, py, x + bar_w - 1, py], fill=255)
+        frames.append(f)
+    return frames
+
+
+@effect("scope", "oscilloscope : onde sinusoïdale modulée (sans texte)")
+def scope(ctx: Ctx):
+    cy = ctx.H / 2
+    amp = ctx.H * 0.42
+    frames = []
+    for t in range(ctx.nframes):
+        ph = 2 * math.pi * t / ctx.nframes
+        f = canvas(ctx.W, ctx.H)
+        d = ImageDraw.Draw(f)
+        for gx in range(0, ctx.W, 8):  # graduations discrètes
+            f.putpixel((gx, int(cy)), 255)
+        pts = []
+        for x in range(ctx.W):
+            env = 0.5 + 0.5 * math.sin(2 * math.pi * x / ctx.W - 2 * ph)
+            y = cy + amp * env * math.sin(2 * math.pi * 3 * x / ctx.W + 4 * ph)
+            pts.append((x, y))
+        d.line(pts, fill=255)
+        frames.append(f)
+    return frames
+
+
+@effect("radar", "balayage radar avec échos qui s'effacent (sans texte)")
+def radar(ctx: Ctx):
+    cx, cy = ctx.W // 2, ctx.H // 2
+    R = min(cx, cy) - 1
+    rng = ctx.rng
+    blips = [(rng.uniform(0, math.tau), rng.uniform(0.3, 0.95)) for _ in range(6)]
+    rotations = max(1, round(ctx.seconds / 2))
+    frames = []
+    for t in range(ctx.nframes):
+        sweep = (2 * math.pi * rotations * t / ctx.nframes) % math.tau
+        f = canvas(ctx.W, ctx.H)
+        d = ImageDraw.Draw(f)
+        d.ellipse([cx - R, cy - R, cx + R, cy + R], outline=255)
+        d.line([cx, cy,
+                cx + R * math.cos(sweep), cy + R * math.sin(sweep)], fill=255)
+        for ang, dist in blips:
+            age = (sweep - ang) % math.tau
+            if age < 1.4:  # l'écho reste visible ~1/4 de tour
+                bx, by = cx + R * dist * math.cos(ang), cy + R * dist * math.sin(ang)
+                d.rectangle([bx - 1, by - 1, bx + 1, by + 1], fill=255)
+        frames.append(f)
+    return frames

oledgif/presets.py

@@ -0,0 +1,29 @@
+"""Presets d'écrans OLED répandus sur le marché."""
+
+PRESETS = {
+    # SteelSeries (GameSense / SteelSeries GG)
+    "apex":         (128, 40, "SteelSeries Apex 5 / 7 / Pro — OLED clavier"),
+    "rival":        (128, 36, "SteelSeries Rival 700 / 710 — OLED souris"),
+    # Modules OLED I2C/SPI courants (Arduino, Raspberry Pi, macropads QMK...)
+    "oled-128x64":  (128, 64, "SSD1306 / SH1106 / SSD1309 128x64"),
+    "oled-128x32":  (128, 32, "SSD1306 128x32"),
+    "oled-96x16":   (96, 16, "SSD1306 96x16"),
+    "oled-256x64":  (256, 64, "SSD1322 256x64"),
+}
+
+DEFAULT_PRESET = "apex"
+
+
+def resolve_size(preset: str | None, size: str | None) -> tuple[int, int]:
+    """--size WxH prime sur --preset ; sinon preset (défaut: apex)."""
+    if size:
+        try:
+            w, h = size.lower().split("x")
+            return int(w), int(h)
+        except ValueError:
+            raise SystemExit(f"--size invalide: {size!r} (attendu: LARGEURxHAUTEUR, ex. 128x40)")
+    name = preset or DEFAULT_PRESET
+    if name not in PRESETS:
+        raise SystemExit(f"Preset inconnu: {name!r}. Presets: {', '.join(PRESETS)}")
+    w, h, _ = PRESETS[name]
+    return w, h

oledgif/render.py

@@ -0,0 +1,209 @@
+"""Rendu bas niveau : texte/image -> bitmap, binarisation 1 bit, écriture GIF."""
+
+from PIL import Image, ImageChops, ImageDraw, ImageFilter, ImageOps, ImageSequence
+
+THRESHOLD = 128
+
+
+def canvas(w: int, h: int) -> Image.Image:
+    return Image.new("L", (w, h), 0)
+
+
+def text_image(text: str, font) -> Image.Image:
+    """Rend `text` (blanc sur noir) dans une image ajustée au plus près."""
+    probe = ImageDraw.Draw(Image.new("L", (1, 1)))
+    bbox = probe.textbbox((0, 0), text, font=font)
+    w = max(1, bbox[2] - bbox[0])
+    h = max(1, bbox[3] - bbox[1])
+    img = Image.new("L", (w, h), 0)
+    ImageDraw.Draw(img).text((-bbox[0], -bbox[1]), text, font=font, fill=255)
+    return img
+
+
+def char_images(text: str, font):
+    """Liste (image, avance_x) par caractère — pour les effets par lettre."""
+    out = []
+    for ch in text:
+        try:
+            adv = font.getlength(ch)
+        except AttributeError:
+            adv = text_image(ch, font).width + 1
+        out.append((None if ch == " " else text_image(ch, font), int(round(adv))))
+    return out
+
+
+def _fit(im: Image.Image, max_w: int, max_h: int, fit: str) -> Image.Image:
+    if fit == "cover":
+        return ImageOps.fit(im, (max_w, max_h), Image.LANCZOS)
+    scale = min(max_w / im.width, max_h / im.height)
+    return im.resize((max(1, round(im.width * scale)), max(1, round(im.height * scale))),
+                     Image.LANCZOS)
+
+
+def _despeckle(im: Image.Image) -> Image.Image:
+    """Éteint tout pixel 0/255 dont aucun des 8 voisins n'a sa couleur.
+
+    Élimine le « poivre et sel » (reflets, sources de lumière ponctuelles)
+    sans toucher à la trame Floyd-Steinberg, dont les pixels ont toujours
+    des voisins diagonaux de même couleur.
+    """
+    w, h = im.size
+    px = im.load()
+    out = im.copy()
+    po = out.load()
+    for y in range(h):
+        for x in range(w):
+            v = px[x, y]
+            alone = True
+            for dy in (-1, 0, 1):
+                for dx in (-1, 0, 1):
+                    if dx == 0 and dy == 0:
+                        continue
+                    nx, ny = x + dx, y + dy
+                    if 0 <= nx < w and 0 <= ny < h and px[nx, ny] == v:
+                        alone = False
+                        break
+                if not alone:
+                    break
+            if alone:
+                po[x, y] = 255 - v
+    return out
+
+
+def _otsu(hist) -> int | None:
+    """Seuil d'Otsu (variance inter-classes maximale) sur un histogramme 256 bins."""
+    total = sum(hist)
+    if total == 0:
+        return None
+    s_all = sum(i * h for i, h in enumerate(hist))
+    w0 = s0 = 0
+    best, thr = 0.0, None
+    for t in range(256):
+        w0 += hist[t]
+        if w0 == 0:
+            continue
+        w1 = total - w0
+        if w1 == 0:
+            break
+        s0 += t * hist[t]
+        m0, m1 = s0 / w0, (s_all - s0) / w1
+        var = w0 * w1 * (m0 - m1) ** 2
+        if var > best:
+            best, thr = var, t
+    return thr
+
+
+def _prepare(im: Image.Image, max_w: int, max_h: int,
+             style: str = "photo", fit: str = "contain",
+             denoise: bool = True) -> Image.Image:
+    """Niveaux de gris + redimensionnement, puis conversion 1 bit selon `style`.
+
+    photo  : auto-contraste + netteté + trame Floyd-Steinberg (photos)
+    solid  : seuillage net à l'écriture (logos, dessins au trait)
+    comic  : solid + les formes noyées dans le noir retracées en contour blanc
+    edges  : détection de contours -> traits blancs sur noir (photos très petites)
+    denoise: filtre médian avant conversion + suppression des pixels isolés après
+    """
+    im = ImageOps.exif_transpose(im).convert("L")
+    if style == "edges":
+        # contours calculés en 2x puis épaissis, sinon ils disparaissent à la réduction
+        big = _fit(im, max_w * 2, max_h * 2, fit)
+        big = ImageOps.autocontrast(big, cutoff=1)
+        if denoise:
+            big = big.filter(ImageFilter.MedianFilter(3))
+        big = big.filter(ImageFilter.GaussianBlur(1)).filter(ImageFilter.FIND_EDGES)
+        ImageDraw.Draw(big).rectangle([0, 0, big.width - 1, big.height - 1],
+                                      outline=0, width=2)  # cadre = artefact du bord
+        big = ImageOps.autocontrast(big).filter(ImageFilter.MaxFilter(3))
+        small = big.resize((max(1, big.width // 2), max(1, big.height // 2)), Image.LANCZOS)
+        # seuil adaptatif : on garde ~10 % des pixels (les contours les plus forts)
+        hist, acc, thr = small.histogram(), 0, 255
+        budget = small.width * small.height * 0.10
+        for lvl in range(255, -1, -1):
+            acc += hist[lvl]
+            if acc >= budget:
+                thr = lvl
+                break
+        thr = max(24, thr)
+        small = small.point(lambda p: 255 if p >= thr else 0)
+        return _despeckle(small) if denoise else small
+    im = _fit(im, max_w, max_h, fit)
+    im = ImageOps.autocontrast(im, cutoff=1)
+    if style == "comic":
+        if denoise:
+            im = im.filter(ImageFilter.MedianFilter(3))
+        solid = im.point(lambda p: 255 if p >= THRESHOLD else 0)
+        dark = ImageChops.invert(solid)  # blanc = zones noires du seuillage
+        hist = im.histogram(dark.convert("1"))
+        thr = _otsu(hist)
+        total = sum(hist)
+        if thr is None or total == 0:
+            return solid
+        lo = sum(hist[:thr + 1])
+        if min(lo, total - lo) / total < 0.05:  # zone noire quasi unie : rien à tracer
+            return solid
+        # frontière entre les deux populations sombres (ex. ciel / silhouette),
+        # tenue à 1 px des zones blanches pour ne pas doubler leurs bords
+        mid = ImageChops.multiply(im.point(lambda p, t=thr: 255 if p > t else 0), dark)
+        contour = ImageChops.difference(mid, mid.filter(ImageFilter.MinFilter(3)))
+        contour = ImageChops.multiply(contour, dark.filter(ImageFilter.MinFilter(3)))
+        out = ImageChops.lighter(solid, contour)
+        return _despeckle(out) if denoise else out
+    if style == "photo":
+        if denoise:  # pas en solid : le médian arrondirait les logos nets
+            im = im.filter(ImageFilter.MedianFilter(3))
+        im = im.filter(ImageFilter.UnsharpMask(radius=1.2, percent=160, threshold=2))
+        im = im.convert("1", dither=Image.FLOYDSTEINBERG).convert("L")
+        if denoise:
+            im = _despeckle(im)
+    return im
+
+
+def load_source(path: str, max_w: int, max_h: int, style: str = "photo",
+                fit: str = "contain", denoise: bool = True) -> Image.Image:
+    """Charge une image et la prépare comme 'sprite' 1 bit pour les effets."""
+    return _prepare(Image.open(path), max_w, max_h, style, fit, denoise)
+
+
+def convert_animation(path: str, w: int, h: int, style: str = "photo",
+                      fit: str = "contain", denoise: bool = True):
+    """Convertit un GIF animé existant : frames centrées + durées d'origine."""
+    im = Image.open(path)
+    frames, durations = [], []
+    for raw in ImageSequence.Iterator(im):
+        sprite = _prepare(raw.convert("L"), w, h, style, fit, denoise)
+        f = canvas(w, h)
+        f.paste(sprite, ((w - sprite.width) // 2, (h - sprite.height) // 2))
+        frames.append(f)
+        durations.append(max(20, int(raw.info.get("duration", 100))))
+    return frames, durations
+
+
+def binarize(frame: Image.Image, invert: bool = False) -> Image.Image:
+    if invert:
+        return frame.point(lambda p: 0 if p >= THRESHOLD else 255).convert("1")
+    return frame.point(lambda p: 255 if p >= THRESHOLD else 0).convert("1")
+
+
+def save_gif(frames, path: str, fps: int, invert: bool = False, scale: int = 1,
+             loop: int = 0, durations=None):
+    """Binarise, agrandit (nearest) si demandé, et écrit le GIF bouclé.
+
+    `durations` (liste de ms par frame) prime sur `fps` — utile en conversion.
+    """
+    out = []
+    for f in frames:
+        b = binarize(f, invert)
+        if scale > 1:
+            b = b.resize((b.width * scale, b.height * scale), Image.NEAREST)
+        out.append(b.convert("P"))
+    duration = durations if durations else max(20, int(round(1000 / fps)))
+    out[0].save(
+        path,
+        save_all=True,
+        append_images=out[1:],
+        duration=duration,
+        loop=loop,
+        optimize=True,
+    )
+    return len(out), (duration if isinstance(duration, int) else duration[0])

oledgifstudio-0.1.0.dist-info/METADATA

@@ -0,0 +1,245 @@
+Metadata-Version: 2.4
+Name: oledgifstudio
+Version: 0.1.0
+Summary: Générateur de GIFs animés 1 bit pour écrans OLED (SteelSeries, SSD1306, ...)
+Author-email: MaticeMrll <marill.matice@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 MaticeMrll
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/MaticeMrll/oled-gif-studio
+Project-URL: Repository, https://github.com/MaticeMrll/oled-gif-studio
+Project-URL: Issues, https://github.com/MaticeMrll/oled-gif-studio/issues
+Keywords: oled,gif,steelseries,ssd1306,keyboard,pillow
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Environment :: Console
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=9.0
+Dynamic: license-file
+
+# oled-gif-studio
+
+<p align="center">
+  <img src="docs/hero.gif" width="384" alt="OLED GIF STUDIO qui défile sur un écran 128x40">
+</p>
+
+Générateur de GIFs animés **1 bit** pour les petits écrans OLED : claviers/souris
+SteelSeries, modules SSD1306/SH1106 (Arduino, Raspberry Pi, macropads QMK)...
+
+Pas de modèle IA, pas d'API payante : tout est **procédural** (Python + Pillow),
+donc instantané, gratuit et pixel-perfect. Un mode « description en langage
+naturel » (français ou anglais) choisit l'effet et les paramètres pour toi.
+
+> Tous les aperçus de ce README sont agrandis ×3 — la taille réelle des GIFs
+> est celle de l'écran cible (128×40 par défaut).
+
+## Installation
+
+Aucune, si Python (≥ 3.10) + Pillow sont déjà installés. Sinon :
+
+```
+pip install Pillow
+```
+
+Optionnel, pour avoir la commande `oledgif` partout :
+
+```
+pip install -e .
+```
+
+## Usage rapide
+
+```powershell
+# Depuis le dossier du projet :
+python -m oledgif "HELLO WORLD"                          # effet auto → hello.gif
+python -m oledgif "GG" -e slot -o gg.gif                 # machine à sous
+python -m oledgif "PWNED" -e glitch -p rival             # pour l'OLED d'une souris
+python -m oledgif "42" -e matrix --size 128x64 --fps 20  # taille custom
+
+# En langage naturel :
+python -m oledgif -d "le texte 'BONJOUR' défile lentement"
+python -m oledgif -d "'GAME OVER' qui clignote vite pendant 3s"
+python -m oledgif -d "un radar qui balaie l'écran"
+
+# À partir d'une image :
+python -m oledgif -i photo.jpg --fit cover               # photo plein écran, effet vhs
+python -m oledgif -i comic.jpg --fit cover --style comic # illustration/BD
+python -m oledgif -i logo.png -e bounce                  # le logo rebondit
+python -m oledgif -i meme.gif                            # GIF animé converti tel quel
+
+# Motifs sans texte (écrans de veille) :
+python -m oledgif -e starfield
+python -m oledgif -e plasma --seconds 6
+
+# Un exemple de chaque effet dans ./samples :
+python -m oledgif --demo
+```
+
+## Effets texte / image (`--list-effects`)
+
+<table>
+<tr>
+<td align="center"><img src="docs/scroll.gif" alt="scroll"><br><code>scroll</code> — défilement en boucle parfaite</td>
+<td align="center"><img src="docs/typewriter.gif" alt="typewriter"><br><code>typewriter</code> — machine à écrire avec curseur</td>
+</tr>
+<tr>
+<td align="center"><img src="docs/wave.gif" alt="wave"><br><code>wave</code> — lettres en vague</td>
+<td align="center"><img src="docs/blink.gif" alt="blink"><br><code>blink</code> — clignotement</td>
+</tr>
+<tr>
+<td align="center"><img src="docs/bounce.gif" alt="bounce"><br><code>bounce</code> — rebond façon logo DVD</td>
+<td align="center"><img src="docs/matrix.gif" alt="matrix"><br><code>matrix</code> — pluie de caractères qui révèle le texte</td>
+</tr>
+<tr>
+<td align="center"><img src="docs/slot.gif" alt="slot"><br><code>slot</code> — chaque lettre cycle puis se fige</td>
+<td align="center"><img src="docs/glitch.gif" alt="glitch"><br><code>glitch</code> — bandes décalées + bruit</td>
+</tr>
+<tr>
+<td align="center"><img src="docs/pulse.gif" alt="pulse"><br><code>pulse</code> — battement de cœur</td>
+<td align="center"><img src="docs/vhs.gif" alt="vhs"><br><code>vhs</code> — tracking façon cassette vidéo</td>
+</tr>
+<tr>
+<td align="center"><img src="docs/slide.gif" alt="slide"><br><code>slide</code> — générique bas → haut</td>
+<td></td>
+</tr>
+</table>
+
+`typewriter`, `wave`, `matrix` et `slot` sont réservés au texte ; les autres
+acceptent aussi une image (`--image`).
+
+`--effect auto` (défaut) : `scroll` si le texte est trop large pour l'écran,
+sinon `wave` ; `vhs` pour une image ; conversion directe pour un GIF animé.
+
+## Motifs sans texte (écrans de veille)
+
+<table>
+<tr>
+<td align="center"><img src="docs/starfield.gif" alt="starfield"><br><code>starfield</code> — hyperespace</td>
+<td align="center"><img src="docs/plasma.gif" alt="plasma"><br><code>plasma</code> — plasma rétro tramé</td>
+</tr>
+<tr>
+<td align="center"><img src="docs/life.gif" alt="life"><br><code>life</code> — jeu de la vie de Conway</td>
+<td align="center"><img src="docs/eq.gif" alt="eq"><br><code>eq</code> — égaliseur audio</td>
+</tr>
+<tr>
+<td align="center"><img src="docs/scope.gif" alt="scope"><br><code>scope</code> — oscilloscope</td>
+<td align="center"><img src="docs/radar.gif" alt="radar"><br><code>radar</code> — balayage avec échos</td>
+</tr>
+</table>
+
+## Images : les 4 styles de rendu
+
+Convertir une image couleur en 1 bit sur 5120 pixels est un exercice de
+sacrifice — le bon `--style` dépend de la source. Démonstration sur la même
+scène (lune, silhouettes sur ciel en dégradé, lumières de ville) :
+
+| Rendu | Style |
+|---|---|
+| <img src="docs/style_source.png" alt="source" width="288"> | **Source** (niveaux de gris) |
+| <img src="docs/style_photo.png" alt="photo" width="288"> | `--style photo` (défaut) — auto-contraste + netteté + trame Floyd-Steinberg. Le bon choix pour les **photos réelles** : la trame simule les niveaux de gris. Sur une illustration, elle devient du bruit. |
+| <img src="docs/style_solid.png" alt="solid" width="288"> | `--style solid` — seuillage net (alias `--no-dither`). Parfait pour les **logos** et dessins au trait… mais tout ce qui est sombre-sur-sombre disparaît dans le noir. |
+| <img src="docs/style_comic.png" alt="comic" width="288"> | `--style comic` — comme `solid`, mais un 2ᵉ seuil automatique (Otsu) sépare les tons sombres et retrace en **contour blanc** les formes noyées dans le noir. Idéal pour les **illustrations/BD**. |
+| <img src="docs/style_edges.png" alt="edges" width="288"> | `--style edges` — détection de contours, traits blancs sur fond noir. Look néon/filaire, souvent le plus lisible pour un **paysage ou un visage**. |
+
+Autres options d'image :
+
+- `--fit cover` — l'image remplit tout l'écran (recadrée) au lieu d'être
+  réduite à un timbre-poste au milieu. Recommandé pour les photos paysage.
+- **Dé-bruitage** (actif par défaut) : un filtre médian + une suppression des
+  pixels isolés éliminent le « poivre et sel » (reflets, lampadaires, étoiles).
+  `--no-denoise` le désactive si tu veux justement garder ces points.
+- Un **GIF animé** en entrée est converti frame par frame en conservant les
+  durées d'origine (avec `--effect auto`).
+
+## Langage naturel (`--describe`)
+
+```powershell
+python -m oledgif -d "le texte 'BRB' qui rebondit pendant 5 secondes"
+python -m oledgif -d "'REC' en mode vhs vintage"
+python -m oledgif -d "a fast blinking 'GO' for 3 seconds"
+```
+
+Le parseur (FR/EN, insensible aux accents) reconnaît l'effet par mots-clés
+(« défile », « clignote », « tape », « radar », « vintage »…), le texte entre
+guillemets, la durée (« pendant 3s ») et la vitesse (« lentement », « vite »).
+
+## Écrans préconfigurés (`--list-presets`)
+
+| Preset        | Taille  | Matériel |
+|---------------|---------|----------|
+| `apex` (défaut) | 128×40 | SteelSeries Apex 5 / 7 / Pro (OLED clavier) |
+| `rival`       | 128×36  | SteelSeries Rival 700 / 710 (OLED souris) |
+| `oled-128x64` | 128×64  | SSD1306 / SH1106 / SSD1309 |
+| `oled-128x32` | 128×32  | SSD1306 |
+| `oled-96x16`  | 96×16   | SSD1306 |
+| `oled-256x64` | 256×64  | SSD1322 |
+
+N'importe quelle autre taille : `--size LARGEURxHAUTEUR`.
+
+## Options utiles
+
+- `--charset alnum|digits|upper|letters|ascii` ou une chaîne littérale — le
+  jeu de caractères utilisé par `matrix` et `slot` (défaut : les 62
+  alphanumériques `0-9A-Za-z`).
+- `--font chemin.ttf --font-size N` — police custom (défaut : Consolas,
+  taille ajustée à l'écran).
+- `--invert` — noir sur blanc.
+- `--scale 4` — GIF agrandi ×4 (pour prévisualiser confortablement).
+- `--seed 42` — rendu reproductible pour les effets aléatoires.
+- `--fps`, `--seconds`, `--speed` (px/s pour scroll).
+
+## Envoyer le GIF sur l'écran SteelSeries
+
+Deux options :
+
+1. **SteelSeries GG** : dans les réglages de ton clavier (section OLED),
+   tu peux importer une image/GIF 128×40 — les GIFs générés ici sont au bon
+   format (1 bit, taille exacte).
+2. **GameSense API** (programmatique) : comme le fait
+   [SteelseriesAnimGif](https://github.com/bolner/SteelseriesAnimGif), on peut
+   streamer les frames vers l'écran via l'API locale de SteelSeries GG.
+   Les GIFs produits ici sont directement exploitables frame par frame.
+
+## Structure du projet
+
+```
+oledgif/
+  cli.py        # ligne de commande + make_gif()
+  effects.py    # les 11 effets texte/image (registre @effect)
+  patterns.py   # les 6 motifs sans texte
+  render.py     # préparation d'images, binarisation, écriture GIF
+  describe.py   # parseur langage naturel FR/EN
+  presets.py    # tailles d'écrans du marché
+  fonts.py      # chargement de police
+samples/        # un GIF d'exemple par effet (taille réelle, --demo)
+docs/           # illustrations du README (agrandies ×3)
+```
+--- 
+## Mon choix
+
+<img src="docs/keyboard.jpg" alt="source" width="288">
+
+Ninja Turtles !

oledgifstudio-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+oledgif/__init__.py,sha256=CfdGypEDKbwS5Gajw3xULiynQ5pKZSM1JzOtMF1jRNE,117
+oledgif/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+oledgif/cli.py,sha256=m6Td-wPLArm7Kheph-oil0fEwiSOmheV4RsxZP4XKYA,8178
+oledgif/describe.py,sha256=xwxe5l2OYCb5t-BlhHJC598i4y1AQ-4AyntJE9_hYTI,2521
+oledgif/effects.py,sha256=r-x7ZtU6hJZth3H_eWCxWaT6Azhzv6G_3HzWPEiz1GY,11688
+oledgif/fonts.py,sha256=Bnc5Y9IPYF2mZOp4UATuCeLr2kujuWwMj6nokoQ1mnU,1153
+oledgif/patterns.py,sha256=T5T8jF_TU4jvZQdiR-dSFFUtZ1Y9w4shgVOWJdT8458,6072
+oledgif/presets.py,sha256=YuVCfLX1kbJO7wG2viomByPkKHKUPlG2zX-XG3QbhwA,1161
+oledgif/render.py,sha256=XLgZWQAabtJLIbrJu3XJT6JczhuenLIoCbVUcdAtvUE,8366
+oledgifstudio-0.1.0.dist-info/licenses/LICENSE,sha256=uWzjux6kyECC8L0SRzSZPFIprrqBS5jHM7An9oyNQiw,1067
+oledgifstudio-0.1.0.dist-info/METADATA,sha256=sMZBjxqQpTG-WH7mqp0uKOYsdOPZkhVJk_VB9fq2bFo,11104
+oledgifstudio-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+oledgifstudio-0.1.0.dist-info/entry_points.txt,sha256=XKSU_9joU04QuaLpsI-St3pbiIWIYA6s8lWOEErxN80,45
+oledgifstudio-0.1.0.dist-info/top_level.txt,sha256=17bnjJbfg_S4lecEKvGv3669PfigTYQxQntr4FXQcAQ,8
+oledgifstudio-0.1.0.dist-info/RECORD,,

oledgifstudio-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

oledgifstudio-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+oledgif = oledgif.cli:main

oledgifstudio-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MaticeMrll
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

oledgifstudio-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+oledgif