CommunityImagegithub.com

Génération de figures de recherche

Génère des figures de qualité publication pour articles académiques : pipelines méthodologiques en LaTeX TikZ et rendus 3D Blender.

Qu'est-ce que Génération de figures de recherche ?

Cette compétence permet de générer des figures de qualité publication pour des articles académiques via un flux de travail conversationnel structuré. Elle prend en charge deux pipelines principaux : TikZ pour les diagrammes 2D (pipelines méthodologiques, organigrammes, diagrammes d'architecture) et Blender pour les rendus 3D (maillages SMPL/FBX, squelettes, teasers multi-personnages). Une option hybride combine les deux lorsqu'un diagramme TikZ nécessite des illustrations 3D rendues. L'utilisateur décrit son besoin, la compétence extrait la structure, confirme avec l'utilisateur, génère le code correspondant (LaTeX TikZ ou script Python Blender), compile ou rend une prévisualisation rapide, puis affine jusqu'à satisfaction. La conception suit des principes de qualité académique : mise en page par cartes, couleurs pastel, polices sans empattement, et mise en évidence des contributions originales. Le rendu final utilise Eevee pour les prévisualisations rapides et Cycles pour les rendus de qualité publication. La compétence est destinée aux chercheurs et aux développeurs qui ont besoin de figures professionnelles pour leurs articles, présentations ou thèses.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/retrocognition023/my-agent-skills/tree/HEAD/skills/research-figure

Installed? Explore more Image skills: steipete/songsee, affaan-m/frontend-design, mattpocock/improve-codebase-architecture · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Figure de Recherche : Générateur de Pipeline TikZ et de Rendu 3D Blender

Générez des figures de qualité publication grâce à une conversation structurée : comprenez le besoin de visualisation, confirmez la structure, générez le code (TikZ ou Blender Python), effectuez le rendu et itérez.

Prérequis

  • Chemin TikZ : pdflatex avec les paquets TikZ (installez via brew install --cask mactex-no-gui sur macOS)
  • Chemin Blender : Blender 3.x+ (définissez la variable d'environnement BLENDER_PATH, ou installez dans /Applications/ sur macOS, ou ajoutez au PATH)

Phase 0 : Orientation

Décidez s'il s'agit d'une figure TikZ ou Blender en fonction de la demande de l'utilisateur.

Choisissez TikZ lorsque l'utilisateur souhaite :

  • Pipeline méthodologique / organigramme / diagramme d'architecture
  • Figures 2D avec boîtes et flèches
  • Toute figure composée principalement de texte, boîtes et flèches

Choisissez Blender lorsque l'utilisateur souhaite :

  • Maillage 3D rendu (SMPL, FBX, OBJ)
  • Figure d'accroche avec plusieurs personnages 3D
  • Comparaison de méthodes côte à côte avec maillages 3D
  • Visualisation de squelette (points clés 3D + membres)
  • Visualisation de boîte englobante autour d'objets 3D
  • Toute figure nécessitant un rendu 3D

Choisissez Hybride (TikZ + Blender) lorsque :

  • Un diagramme de pipeline contient des modules qui nécessitent des illustrations rendues en 3D
  • Par exemple, un module « Estimation de pose 3D » doit contenir une image de maillage rendu

En cas d'ambiguïté, demandez à l'utilisateur.


Chemin TikZ

Principes de conception

Ces principes sont issus des meilleures pratiques en matière de conception de figures académiques :

  1. Disposition par cartes : Chaque module est enfermé dans un rectangle arrondi (carte). Les cartes sont reliées par des flèches. Cela rend la structure du pipeline immédiatement claire.
  2. Couleurs faiblement saturées : Utilisez des couleurs pastel et douces. N'utilisez jamais de couleurs vives/saturées. La figure doit être professionnelle, pas comme un PowerPoint.
  3. Disposition compacte : Minimisez les espaces blancs. Alignez les éléments horizontalement et verticalement. La figure doit être serrée et dense, pas dispersée.
  4. Polices sans empattement : Utilisez \sffamily partout pour un aspect moderne et épuré.
  5. Mettez en évidence les contributions : Les modules de contribution novatrice de l'utilisateur doivent être visuellement distincts (bordure plus épaisse, couleur de fond différente) des modules standard.
  6. Éléments de visualisation 2D : Remplacez le texte brut par des éléments visuels stylisés lorsque c'est possible (cartes de caractéristiques sous forme de rectangles empilés, blocs de réseau sous forme de boîtes étiquetées, etc.). Gardez ces éléments simples et en 2D — aucun rendu 3D n'est nécessaire.

Phase TikZ 1 : Comprendre la méthode

Lorsque l'utilisateur fournit une description (résumé, résumé de la méthode, ou même une idée vague) :

  1. Lisez attentivement la description et extrayez la structure du pipeline sous forme de chaîne : Entrée → Module1 → Intermédiaire1 → Module2 → ... → Sortie
  2. Pour chaque module, identifiez :
    • Nom : un nom court et descriptif
    • Type : traitement de données, réseau neuronal, optimisation, inférence, perte, etc.
    • Est-ce nouveau ? : si cela fait partie de la contribution de l'utilisateur
    • Éléments internes : ce qui se passe à l'intérieur (convolution, attention, MLP, etc.)
  3. Identifiez le modèle de flux global :
    • Linéaire (le plus courant)
    • Boucle/itératif
    • Multi-branches (traitement parallèle)
    • Deux étapes (entraînement + inférence, ou deux sous-problèmes)

Phase TikZ 2 : Confirmer avec l'utilisateur (1-2 tours)

Présentez la structure extraite à l'utilisateur dans un format clair et structuré en utilisant AskUserQuestion ou une conversation directe. Restez bref — l'objectif est de confirmer, pas de concevoir à partir de zéro.

Tour 1 (obligatoire) : Affichez la structure du pipeline et demandez :

  • La décomposition en modules est-elle correcte ?
  • Quels sont les modules clés des contributions ?
  • Préférence de disposition : horizontale (par défaut), verticale, boucle, deux étapes ou multi-branches ?
  • Préférence de jeu de couleurs ? (Si non spécifié, par défaut Bleu-Gris)

Formatez le pipeline clairement, par exemple :

Pipeline extrait :
  Entrée image → Encodeur de caractéristiques → [VOTRE MÉTHODE : Module de fusion adaptatif] → Décodeur → Maillage de sortie

Disposition : Linéaire horizontale (de gauche à droite)
Mise en évidence : « Module de fusion adaptatif » (contribution novatrice)
Jeu de couleurs : Bleu-Gris (par défaut)

Tour 2 (uniquement si nécessaire) : Si le pipeline est complexe ou si l'utilisateur a des demandes spéciales concernant les détails internes du module, demandez :

  • Éléments de visualisation spécifiques à l'intérieur des modules
  • Annotations ou étiquettes spéciales
  • Fonctions de perte ou signaux d'entraînement à afficher

Si la méthode est simple, sautez le tour 2 et passez directement à la génération.

Phase TikZ 3 : Générer le code TikZ

Lisez les fichiers de référence pour assembler la figure :

  1. Lisez references/layout_templates.md — choisissez le modèle correspondant au type de disposition (horizontale linéaire, verticale, boucle, deux modules, multi-branches). Utilisez le modèle comme squelette structurel.

  2. Lisez references/color_schemes.md — choisissez le jeu de couleurs choisi par l'utilisateur (ou Bleu-Gris par défaut). Copiez le bloc \definecolor dans le préambule.

  3. Lisez references/tikz_elements.md — sélectionnez les styles d'éléments nécessaires :

    • Styles de boîte de module (standard, nouveau, optionnel, io, groupe, perte)
    • Styles de flèche (standard, étiquetée, orthogonale, pointillée, bidirectionnelle)
    • Éléments 2D (cartes de caractéristiques, blocs de réseau, grilles, espaces réservés d'image)
    • Annotations (accolades, légendes, étiquettes de dimension)
  4. Composez le fichier .tex final en suivant ces règles :

    • Utilisez \documentclass[border=5pt]{standalone} pour une sortie recadrée
    • Incluez tous les paquets et bibliothèques TikZ nécessaires
    • Définissez toutes les couleurs dans le préambule
    • Définissez tous les styles avec \tikzset dans le préambule
    • Placez les nœuds à l'aide de la bibliothèque positioning (par exemple, right=1.0cm of nodeA)
    • Maintenez un espacement cohérent : généralement 0,8 à 1,2 cm entre les nœuds
    • Assurez-vous que tout le texte tient dans sa boîte (utilisez \\ pour les sauts de ligne si nécessaire)
    • Utilisez \textbf pour les titres de module, \footnotesize\color{textLight} pour les sous-titres
    • Ajoutez des étiquettes de flèche pour les flux de données importants (caractéristiques, codes latents, etc.)
    • Utilisez le mode mathématique pour les symboles : $\mathbf{z}$, $\mathcal{L}$, etc.
  5. Écrivez le fichier .tex dans le répertoire de travail (par exemple, figure.tex ou un nom spécifié par l'utilisateur).

Phase TikZ 4 : Compiler et auto-vérification

  1. Compilez à l'aide du script fourni :

    bash .claude/skills/research-figure/scripts/compile_tikz.sh <chemin-vers-fichier-tex>
    
  2. Si la compilation échoue : lisez la sortie d'erreur, corrigez le code LaTeX et réessayez. Problèmes courants :

    • Paquets manquants → ajoutez \usepackage{...}
    • Couleur non définie → vérifiez les définitions \definecolor
    • Erreurs de positionnement de nœud → vérifiez les noms de nœud et les références of
    • Erreurs de mode mathématique → vérifiez la correspondance $...$
  3. Visualisez le résultat : Utilisez l'outil Read pour voir l'image PNG générée.

  4. Auto-vérifiez la figure à l'aide de cette liste de contrôle :

    • Tout le texte est lisible (pas de chevauchement)
    • Les flèches pointent dans la bonne direction
    • L'alignement horizontal et vertical est propre
    • La disposition est compacte (pas de grandes zones vides)
    • Le jeu de couleurs est cohérent et harmonieux
    • Les modules de contribution novatrice sont visuellement mis en évidence
    • Les noms de module correspondent à ce qui a été convenu avec l'utilisateur
    • La police est sans empattement partout
  5. Si des problèmes sont trouvés : corrigez le code TikZ et recompilez. Ne montrez PAS une figure cassée à l'utilisateur.

Phase TikZ 5 : Présenter et itérer

  1. Montrez la figure compilée à l'utilisateur (l'image PNG).
  2. Expliquez brièvement la structure.
  3. Demandez si des modifications sont nécessaires.
  4. En fonction des commentaires, modifiez le code TikZ, recompilez et montrez à nouveau.
  5. Répétez jusqu'à ce que l'utilisateur soit satisfait.
  6. Fournissez le chemin du fichier .tex final afin que l'utilisateur puisse :
    • L'inclure directement dans son article avec \input{}
    • Ou le compiler indépendamment et l'inclure via \includegraphics{}

Chemin Blender

Phase Blender 1 : Comprendre la visualisation

Identifiez le cas d'utilisation :

Cas d'utilisationDescriptionModèle
AccrocheN personnages le long de l'axe X, matériaux dégradés, sol + brouillard + trajectoiretemplates/blender/template_teaser.py
Module de pipelineMaillage unique avec fond transparent, pour inclusion dans TikZtemplates/blender/template_single_render.py
Comparaison2+ personnages, couleurs différentes (bleu = nôtre, rouge = référence)templates/blender/template_comparison.py
SqueletteSphères de points clés 3D + cylindres de membresRecette D dans references/blender_recipes.md
Boîte englobante + MaillageBoîte englobante en fil de fer autour d'un maillageRecette E dans references/blender_recipes.md

Extrayez de la demande de l'utilisateur :

  • Chemins des fichiers de données (FBX, OBJ, NPZ)
  • Indices d'image (images d'animation à afficher)
  • Nombre de personnages / instances
  • Préférences de style (couleurs, angle de caméra, avec/sans sol)

Phase Blender 2 : Confirmer avec l'utilisateur

Présentez un résumé structuré :

Type de figure : Accroche multi-personnages
Données : motion.fbx, images [1, 30, 60, 90, 120, 150]
Disposition : 6 personnages le long de l'axe X, espacement 1,5 m
Caméra : Plan large, focale 85 mm
Éclairage : Studio trois points
Matériau : Argile dégradée bleue
Sol : Damier avec reflets
Brouillard : Oui (bleu-gris)
Trajectoire : Oui (courbe dégradée avec flèche)
Sortie : 2048x1024 JPEG

Un tour est généralement suffisant. Passez à la génération.

Phase Blender 3 : Générer le script Blender

  1. Lisez references/blender_api.md pour les signatures de fonctions.
  2. Lisez references/blender_recipes.md pour le modèle de recette correspondant.
  3. Générez un script Python complet qui importe depuis blender_utils.* (PAS depuis myblender.*).
  4. Le script DOIT prendre en charge un indicateur --preview qui bascule entre le mode de prévisualisation rapide et le mode de rendu final (voir ci-dessous).
  5. Écrivez le script dans le répertoire de travail (par exemple, render_teaser.py).

Le script doit être autonome et exécutable via :

bash .claude/skills/research-figure/scripts/render_blender.sh <script.py> -- [args]

Conception de rendu en deux passes

Chaque script Blender généré DOIT prendre en charge deux modes de rendu contrôlés par un indicateur CLI --preview :

import argparse

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("--preview", action="store_true",
                        help="Prévisualisation rapide Eevee basse résolution")
    # ... autres arguments ...
    if '--' in sys.argv:
        args = parser.parse_args(sys.argv[sys.argv.index('--') + 1:])
    else:
        args = parser.parse_args([])
    return args

Dans la section de rendu, créez une branche sur args.preview :

scene = bpy.context.scene
if args.preview:
    # Prévisualisation rapide : Eevee, basse résolution, PNG
    set_eevee_renderer(scene, camera)
    preview_path = output_path.rsplit('.', 1)[0] + '_preview.png'
    set_output_properties(scene, output_file_path=preview_path,
                          res_x=800, res_y=400, format='PNG')
else:
    # Rendu final : Cycles, pleine résolution
    set_cycles_renderer(scene, camera, num_samples=256,
                        use_transparent_bg=False)
    set_output_properties(scene, output_file_path=output_path,
                          res_x=2048, res_y=1024, format='JPEG')
render_with_progress()

Paramètres du mode prévisualisation :

  • Moteur : Eevee (set_eevee_renderer) — des ordres de grandeur plus rapide que Cycles
  • Résolution : 1/2 à 1/4 de la finale (par exemple, 800x400 pour une accroche 2048x1024)
  • Format : PNG (pour un visionnage rapide)
  • Chemin de sortie : ajoutez le suffixe _preview avant l'extension

Paramètres du mode final :

  • Moteur : Cycles (set_cycles_renderer) — lancer de rayons, qualité publication
  • Résolution : résolution cible complète
  • Échantillons : 256+ pour une qualité finale

Phase Blender 4 : Rendu de prévisualisation et auto-vérification

Effectuez toujours d'abord un rendu de prévisualisation rapide. N'allez PAS directement à un rendu Cycles.

  1. Exécutez le rendu de prévisualisation :

    bash .claude/skills/research-figure/scripts/render_blender.sh <script.py> -- --preview
    
  2. Si le rendu échoue : lisez la sortie d'erreur, corrigez le script Python et réessayez. Problèmes courants :

    • ModuleNotFoundError → problème PYTHONPATH (render_blender.sh le gère automatiquement)
    • KeyError sur les entrées de nœud → compatibilité de version Blender (utilisez try/except)
    • Rendu noir/vide → caméra non définie, ou objets non visibles
    • Erreurs GPU → définissez prefer_gpu=False dans set_cycles_renderer
  3. Visualisez l'image de prévisualisation : Utilisez l'outil Read pour voir le fichier *_preview.png généré.

  4. Auto-vérifiez la prévisualisation :

    • Les objets sont visibles et correctement positionnés
    • L'angle de la caméra montre le sujet clairement
    • L'éclairage est raisonnable (l'éclairage Eevee diffère légèrement de Cycles mais la composition doit être correcte)
    • Les matériaux sont appliqués (pas de gris par défaut)
    • L'arrière-plan est propre
    • L'espacement et la disposition des personnages semblent corrects
  5. Si des problèmes sont trouvés : corrigez le script et réexécutez la prévisualisation. Ne montrez PAS une figure cassée à l'utilisateur.

Phase Blender 5 : Présenter la prévisualisation et obtenir l'approbation

  1. Montrez l'image de prévisualisation à l'utilisateur.
  2. Expliquez qu'il s'agit d'une prévisualisation rapide Eevee pour vérifier la disposition/composition — le rendu final Cycles aura un meilleur éclairage, de meilleurs matériaux et un meilleur anti-aliasing.
  3. Demandez à l'utilisateur de confirmer que la prévisualisation semble correcte avant de procéder au rendu complet. Utilisez AskUserQuestion avec des options telles que :
    • « Semble bon, faites le rendu final » — passez à la phase 6
    • « Ajustez la caméra / l'éclairage / l'espacement » — itérez sur le script et refaites le rendu de prévisualisation
    • « Changez les images / personnages » — modifiez et refaites le rendu de prévisualisation
  4. Si l'utilisateur demande des modifications, modifiez le script, refaites le rendu de prévisualisation (pas le rendu complet), et montrez à nouveau.
  5. Répétez jusqu'à ce que l'utilisateur approuve la prévisualisation.

Phase Blender 6 : Rendu final

Ne procédez ici qu'après que l'utilisateur a approuvé la prévisualisation.

  1. Exécutez le rendu final Cycles (sans --preview) :

    bash .claude/skills/research-figure/scripts/render_blender.sh <script.py>
    

    Remarque : cela prendra beaucoup plus de temps que la prévisualisation. C'est normal.

  2. Visualisez le résultat : Utilisez l'outil Read pour voir l'image rendue finale.

  3. Montrez l'image finale à l'utilisateur.

  4. Si l'utilisateur souhaite d'autres ajustements, revenez à la phase 5 (itération de prévisualisation) plutôt que de relancer le rendu Cycles lent pour chaque ajustement.


Hybride : Appel récursif TikZ + Blender

Lorsqu'un diagramme de pipeline TikZ nécessite des illustrations de module rendues en 3D...

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Skills associés