slack-gif-creator

Créateur de GIFs pour Slack

Un ensemble d'outils et de connaissances pour créer des GIFs animés optimisés pour Slack.

Exigences Slack

Dimensions :

• GIFs émojis : 128x128 (recommandé)
• GIFs messages : 480x480

Paramètres :

• FPS : 10-30 (plus bas = taille de fichier plus petite)
• Couleurs : 48-128 (moins = taille de fichier plus petite)
• Durée : rester sous 3 secondes pour les GIFs émojis

Flux de travail principal

from core.gif_builder import GIFBuilder
from PIL import Image, ImageDraw

# 1. Créer le constructeur
builder = GIFBuilder(width=128, height=128, fps=10)

# 2. Générer les images
for i in range(12):
    frame = Image.new('RGB', (128, 128), (240, 248, 255))
    draw = ImageDraw.Draw(frame)

    # Dessiner votre animation à l'aide des primitives PIL
    # (cercles, polygones, lignes, etc.)

    builder.add_frame(frame)

# 3. Enregistrer avec optimisation
builder.save('output.gif', num_colors=48, optimize_for_emoji=True)

Dessiner des graphismes

Travailler avec des images téléchargées par l'utilisateur

Si un utilisateur télécharge une image, déterminez s'il souhaite :

• L'utiliser directement (ex. "anime ceci", "découpe ceci en images")
• L'utiliser comme inspiration (ex. "fais quelque chose comme ça")

Chargez et travaillez avec les images à l'aide de PIL :

from PIL import Image

uploaded = Image.open('file.png')
# Utiliser directement, ou juste comme référence pour les couleurs / le style

Dessiner à partir de zéro

Lorsque vous dessinez des graphismes à partir de zéro, utilisez les primitives PIL ImageDraw :

from PIL import ImageDraw

draw = ImageDraw.Draw(frame)

# Cercles / ovales
draw.ellipse([x1, y1, x2, y2], fill=(r, g, b), outline=(r, g, b), width=3)

# Étoiles, triangles, tout polygone
points = [(x1, y1), (x2, y2), (x3, y3), ...]
draw.polygon(points, fill=(r, g, b), outline=(r, g, b), width=3)

# Lignes
draw.line([(x1, y1), (x2, y2)], fill=(r, g, b), width=5)

# Rectangles
draw.rectangle([x1, y1, x2, y2], fill=(r, g, b), outline=(r, g, b), width=3)

N'utilisez pas : les polices d'émojis (peu fiables selon la plateforme) ou ne supposez pas que des graphismes pré-intégrés existent dans ce skill.

Rendre les graphismes beaux

Les graphismes doivent sembler soignés et créatifs, pas basiques. Voici comment :

Utilisez des traits plus épais – Mettez toujours width=2 ou plus pour les contours et les lignes. Les traits fins (width=1) donnent un aspect haché et amateur.

Ajoutez de la profondeur visuelle :

• Utilisez des dégradés pour les arrière-plans (create_gradient_background)
• Superposez plusieurs formes pour plus de complexité (ex. une étoile avec une plus petite étoile à l'intérieur)

Rendez les formes plus intéressantes :

• Ne dessinez pas un simple cercle – ajoutez des reflets, des anneaux ou des motifs
• Les étoiles peuvent avoir une lueur (dessinez des versions plus grandes et semi-transparentes derrière)
• Combinez plusieurs formes (étoiles + étincelles, cercles + anneaux)

Faites attention aux couleurs :

• Utilisez des couleurs vives et complémentaires
• Ajoutez du contraste (contours foncés sur formes claires, contours clairs sur formes foncées)
• Considérez la composition globale

Pour les formes complexes (cœurs, flocons de neige, etc.) :

• Utilisez des combinaisons de polygones et d'ellipses
• Calculez les points avec soin pour la symétrie
• Ajoutez des détails (un cœur peut avoir une courbe de reflet, les flocons ont des branches complexes)

Soyez créatif et détaillé ! Un bon GIF Slack doit sembler soigné, pas comme un graphisme provisoire.

Utilitaires disponibles

GIFBuilder (core.gif_builder)

Assemble les images et optimise pour Slack :

builder = GIFBuilder(width=128, height=128, fps=10)
builder.add_frame(frame)  # Ajouter une image PIL
builder.add_frames(frames)  # Ajouter une liste d'images
builder.save('out.gif', num_colors=48, optimize_for_emoji=True, remove_duplicates=True)

Validateurs (core.validators)

Vérifiez si le GIF respecte les exigences Slack :

from core.validators import validate_gif, is_slack_ready

# Validation détaillée
passes, info = validate_gif('my.gif', is_emoji=True, verbose=True)

# Vérification rapide
if is_slack_ready('my.gif'):
    print("Prêt !")

Fonctions d'interpolation (core.easing)

Mouvement fluide au lieu de linéaire :

from core.easing import interpolate

# Progression de 0.0 à 1.0
t = i / (num_frames - 1)

# Appliquer l'interpolation
y = interpolate(start=0, end=400, t=t, easing='ease_out')

# Disponibles : linear, ease_in, ease_out, ease_in_out,
#           bounce_out, elastic_out, back_out

Aides à la composition (core.frame_composer)

Fonctions pratiques pour les besoins courants :

from core.frame_composer import (
    create_blank_frame,         # Fond uni
    create_gradient_background,  # Dégradé vertical
    draw_circle,                # Aide pour les cercles
    draw_text,                  # Rendu de texte simple
    draw_star                   # Étoile à 5 branches
)

Concepts d'animation

Secousse / Vibration

Décaler la position de l'objet avec oscillation :

• Utiliser math.sin() ou math.cos() avec l'indice de l'image
• Ajouter de petites variations aléatoires pour un aspect naturel
• Appliquer à la position x et/ou y

Pulsation / Battement de cœur

Redimensionner l'objet de manière rythmique :

• Utiliser math.sin(t * frequency * 2 * math.pi) pour une pulsation douce
• Pour un battement : deux pulsations rapides puis pause (ajuster l'onde sinusoïdale)
• Mettre à l'échelle entre 0.8 et 1.2 de la taille de base

Rebond

L'objet tombe et rebondit :

• Utiliser interpolate() avec easing='bounce_out' pour l'atterrissage
• Utiliser easing='ease_in' pour la chute (accélération)
• Appliquer la gravité en augmentant la vitesse y à chaque image

Rotation

Faire tourner l'objet autour du centre :

• PIL : image.rotate(angle, resample=Image.BICUBIC)
• Pour un balancement : utiliser une onde sinusoïdale pour l'angle au lieu de linéaire

Apparition / Disparition progressive

Apparaître ou disparaître graduellement :

• Créer une image RGBA, ajuster le canal alpha
• Ou utiliser Image.blend(image1, image2, alpha)
• Apparition : alpha de 0 à 1
• Disparition : alpha de 1 à 0

Glissement

Déplacer l'objet depuis l'extérieur du cadre jusqu'à sa position :

• Position de départ : en dehors des limites de l'image
• Position d'arrivée : emplacement cible
• Utiliser interpolate() avec easing='ease_out' pour un arrêt fluide
• Pour un dépassement : utiliser easing='back_out'

Zoom

Mettre à l'échelle et positionner pour un effet de zoom :

• Zoom avant : mise à l'échelle de 0.1 à 2.0, recadrer au centre
• Zoom arrière : mise à l'échelle de 2.0 à 1.0
• Peut ajouter un flou de mouvement pour le drame (filtre PIL)

Explosion / Bouffée de particules

Créer des particules rayonnant vers l'extérieur :

• Générer des particules avec des angles et des vitesses aléatoires
• Mettre à jour chaque particule : x += vx, y += vy
• Ajouter de la gravité : vy += gravity_constant
• Estomper les particules avec le temps (réduire l'alpha)

Stratégies d'optimisation

Uniquement lorsqu'on vous demande de réduire la taille du fichier, implémentez quelques-unes des méthodes suivantes :

1. Moins d'images - Réduire les FPS (10 au lieu de 20) ou la durée
2. Moins de couleurs - num_colors=48 au lieu de 128
3. Dimensions plus petites - 128x128 au lieu de 480x480
4. Supprimer les doublons - remove_duplicates=True dans save()
5. Mode émoji - optimize_for_emoji=True optimise automatiquement

# Optimisation maximale pour émoji
builder.save(
    'emoji.gif',
    num_colors=48,
    optimize_for_emoji=True,
    remove_duplicates=True
)

Philosophie

Ce skill fournit :

• Connaissances : les exigences de Slack et les concepts d'animation
• Utilitaires : GIFBuilder, validateurs, fonctions d'interpolation
• Flexibilité : créez la logique d'animation en utilisant les primitives PIL

Il ne fournit PAS :

• Des modèles d'animation rigides ou des fonctions pré-fabriquées
• Le rendu de polices d'émojis (peu fiable selon la plateforme)
• Une bibliothèque de graphismes pré-intégrés dans le skill

Note sur les téléchargements utilisateur : Ce skill n'inclut pas de graphismes pré-construits, mais si un utilisateur télécharge une image, utilisez PIL pour la charger et travailler avec - interprétez sa demande pour savoir s'il souhaite l'utiliser directement ou simplement comme inspiration.

Soyez créatif ! Combinez les concepts (rebondissant + tournant, pulsant + glissant, etc.) et utilisez toutes les capacités de PIL.

Dépendances

pip install pillow imageio numpy