Visualisation scientifique

Vue d'ensemble

La visualisation scientifique transforme les données en figures claires et précises pour publication. Créez des graphiques prêts pour revues avec mises en page multi-panneaux, barres d'erreur, marqueurs de significativité et palettes accessibles aux daltoniens. Exportez en PDF/EPS/TIFF en utilisant matplotlib, seaborn et plotly pour vos manuscrits.

Quand utiliser cette compétence

Cette compétence doit être utilisée quand :

• Vous créez des graphiques ou des visualisations pour des manuscrits scientifiques
• Vous préparez des figures pour soumettre à une revue (Nature, Science, Cell, PLOS, etc.)
• Vous garantissez que les figures sont accessibles aux daltoniens
• Vous réalisez des figures multi-panneaux avec un style cohérent
• Vous exportez des figures à la bonne résolution et au bon format
• Vous respectez des directives de publication spécifiques
• Vous améliorez des figures existantes pour respecter les normes de publication
• Vous créez des figures qui doivent fonctionner en couleur et en niveaux de gris

Guide de démarrage rapide

Figure de qualité publication basique

import matplotlib.pyplot as plt
import numpy as np

# Appliquer le style publication (depuis scripts/style_presets.py)
from style_presets import apply_publication_style
apply_publication_style('default')

# Créer une figure avec la taille appropriée (une colonne = 3,5 pouces)
fig, ax = plt.subplots(figsize=(3.5, 2.5))

# Tracer les données
x = np.linspace(0, 10, 100)
ax.plot(x, np.sin(x), label='sin(x)')
ax.plot(x, np.cos(x), label='cos(x)')

# Étiquetage correct avec unités
ax.set_xlabel('Time (seconds)')
ax.set_ylabel('Amplitude (mV)')
ax.legend(frameon=False)

# Supprimer les spines inutiles
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)

# Enregistrer dans les formats de publication (depuis scripts/figure_export.py)
from figure_export import save_publication_figure
save_publication_figure(fig, 'figure1', formats=['pdf', 'png'], dpi=300)

Utiliser des styles préconfigurés

Appliquez les styles spécifiques aux revues en utilisant les fichiers de style matplotlib dans assets/ :

import matplotlib.pyplot as plt

# Option 1 : Utiliser directement le fichier de style
plt.style.use('assets/nature.mplstyle')

# Option 2 : Utiliser l'assistant style_presets.py
from style_presets import configure_for_journal
configure_for_journal('nature', figure_width='single')

# Créez maintenant vos figures - elles respecteront automatiquement les spécifications de Nature
fig, ax = plt.subplots()
# ... votre code de tracé ...

Démarrage rapide avec Seaborn

Pour les graphiques statistiques, utilisez seaborn avec un style de publication :

import seaborn as sns
import matplotlib.pyplot as plt
from style_presets import apply_publication_style

# Appliquer le style publication
apply_publication_style('default')
sns.set_theme(style='ticks', context='paper', font_scale=1.1)
sns.set_palette('colorblind')

# Créer une figure de comparaison statistique
fig, ax = plt.subplots(figsize=(3.5, 3))
sns.boxplot(data=df, x='treatment', y='response', 
            order=['Control', 'Low', 'High'], palette='Set2', ax=ax)
sns.stripplot(data=df, x='treatment', y='response',
              order=['Control', 'Low', 'High'], 
              color='black', alpha=0.3, size=3, ax=ax)
ax.set_ylabel('Response (μM)')
sns.despine()

# Enregistrer la figure
from figure_export import save_publication_figure
save_publication_figure(fig, 'treatment_comparison', formats=['pdf', 'png'], dpi=300)

Principes fondamentaux et bonnes pratiques

1. Résolution et format de fichier

Exigences critiques (détaillées dans references/publication_guidelines.md) :

• Images raster (photos, microscopie) : 300-600 DPI
• Traits linéaires (graphiques, tracés) : 600-1200 DPI ou format vectoriel
• Formats vectoriels (préférés) : PDF, EPS, SVG
• Formats raster : TIFF, PNG (jamais JPEG pour des données scientifiques)

Implémentation :

# Utiliser le script figure_export.py pour les bons paramètres
from figure_export import save_publication_figure

# Enregistre dans plusieurs formats avec les bons DPI
save_publication_figure(fig, 'myfigure', formats=['pdf', 'png'], dpi=300)

# Ou enregistrer selon les exigences spécifiques de la revue
from figure_export import save_for_journal
save_for_journal(fig, 'figure1', journal='nature', figure_type='combination')

2. Sélection des couleurs - Accessibilité daltonienne

Utilisez toujours des palettes accessibles aux daltoniens (détaillées dans references/color_palettes.md) :

Recommandé : Palette Okabe-Ito (distinguable par tous les types de daltonisme) :

# Option 1 : Utiliser assets/color_palettes.py
from color_palettes import OKABE_ITO_LIST, apply_palette
apply_palette('okabe_ito')

# Option 2 : Spécification manuelle
okabe_ito = ['#E69F00', '#56B4E9', '#009E73', '#F0E442',
             '#0072B2', '#D55E00', '#CC79A7', '#000000']
plt.rcParams['axes.prop_cycle'] = plt.cycler(color=okabe_ito)

Pour les cartes de chaleur/données continues :

• Utilisez des colormaps perceptuellement uniformes : viridis, plasma, cividis
• Évitez les cartes de divergence rouge-vert (utilisez plutôt PuOr, RdBu, BrBG)
• Ne jamais utiliser les colormaps jet ou rainbow

Toujours tester les figures en niveaux de gris pour assurer l'interprétabilité.

3. Typographie et texte

Directives de police (détaillées dans references/publication_guidelines.md) :

• Polices sans-serif : Arial, Helvetica, Calibri
• Tailles minimales à la taille d'impression finale :
  • Étiquettes des axes : 7-9 pt
  • Étiquettes des graduations : 6-8 pt
  • Étiquettes des panneaux : 8-12 pt (gras)
• Casse titre pour les étiquettes : "Time (hours)" et non "TIME (HOURS)"
• Toujours inclure les unités entre parenthèses

Implémentation :

# Définir les polices globalement
import matplotlib as mpl
mpl.rcParams['font.family'] = 'sans-serif'
mpl.rcParams['font.sans-serif'] = ['Arial', 'Helvetica']
mpl.rcParams['font.size'] = 8
mpl.rcParams['axes.labelsize'] = 9
mpl.rcParams['xtick.labelsize'] = 7
mpl.rcParams['ytick.labelsize'] = 7

4. Dimensions des figures

Largeurs spécifiques aux revues (détaillées dans references/journal_requirements.md) :

• Nature : Simple 89 mm, Double 183 mm
• Science : Simple 55 mm, Double 175 mm
• Cell : Simple 85 mm, Double 178 mm

Vérifier la conformité de la taille de la figure :

from figure_export import check_figure_size

fig = plt.figure(figsize=(3.5, 3))  # 89 mm pour Nature
check_figure_size(fig, journal='nature')

5. Figures multi-panneaux

Bonnes pratiques :

• Étiqueter les panneaux avec des lettres en gras : A, B, C (majuscules pour la plupart des revues, minuscules pour Nature)
• Maintenir un style cohérent sur tous les panneaux
• Aligner les panneaux le long des arêtes si possible
• Utiliser un espace blanc adéquat entre les panneaux

Exemple d'implémentation (voir references/matplotlib_examples.md pour le code complet) :

from string import ascii_uppercase

fig = plt.figure(figsize=(7, 4))
gs = fig.add_gridspec(2, 2, hspace=0.4, wspace=0.4)

ax1 = fig.add_subplot(gs[0, 0])
ax2 = fig.add_subplot(gs[0, 1])
# ... créer les autres panneaux ...

# Ajouter les étiquettes des panneaux
for i, ax in enumerate([ax1, ax2, ...]):
    ax.text(-0.15, 1.05, ascii_uppercase[i], transform=ax.transAxes,
            fontsize=10, fontweight='bold', va='top')

Tâches courantes

Tâche 1 : Créer un graphique linéaire prêt pour la publication

Voir references/matplotlib_examples.md Exemple 1 pour le code complet.

Étapes clés :

1. Appliquer le style de publication
2. Définir la taille de figure appropriée pour la revue cible
3. Utiliser des couleurs accessibles aux daltoniens
4. Ajouter des barres d'erreur avec la bonne représentation (SEM, SD, ou IC)
5. Étiqueter les axes avec les unités
6. Supprimer les spines inutiles
7. Enregistrer dans un format vectoriel

Utiliser seaborn pour les intervalles de confiance automatiques :

import seaborn as sns
fig, ax = plt.subplots(figsize=(5, 3))
sns.lineplot(data=timeseries, x='time', y='measurement',
             hue='treatment', errorbar=('ci', 95), 
             markers=True, ax=ax)
ax.set_xlabel('Time (hours)')
ax.set_ylabel('Measurement (AU)')
sns.despine()

Tâche 2 : Créer une figure multi-panneaux

Voir references/matplotlib_examples.md Exemple 2 pour le code complet.

Étapes clés :

1. Utiliser GridSpec pour une mise en page flexible
2. Assurer un style cohérent sur tous les panneaux
3. Ajouter des étiquettes de panneaux en gras (A, B, C, etc.)
4. Aligner les panneaux connexes
5. Vérifier que tout le texte est lisible à la taille finale

Tâche 3 : Créer une carte de chaleur avec un colormap approprié

Voir references/matplotlib_examples.md Exemple 4 pour le code complet.

Étapes clés :

1. Utiliser un colormap perceptuellement uniforme (viridis, plasma, cividis)
2. Inclure une barre de couleur étiquetée
3. Pour les données divergentes, utiliser une carte de divergence accessible aux daltoniens (RdBu_r, PuOr)
4. Définir la valeur de centre appropriée pour les cartes divergentes
5. Tester l'apparence en niveaux de gris

Utiliser seaborn pour les matrices de corrélation :

import seaborn as sns
fig, ax = plt.subplots(figsize=(5, 4))
corr = df.corr()
mask = np.triu(np.ones_like(corr, dtype=bool))
sns.heatmap(corr, mask=mask, annot=True, fmt='.2f',
            cmap='RdBu_r', center=0, square=True,
            linewidths=1, cbar_kws={'shrink': 0.8}, ax=ax)

Tâche 4 : Préparer une figure pour une revue spécifique

Flux de travail :

1. Vérifier les exigences de la revue : references/journal_requirements.md
2. Configurer matplotlib pour la revue :

   from style_presets import configure_for_journal
   configure_for_journal('nature', figure_width='single')

3. Créer la figure (elle se dimensionnera automatiquement correctement)
4. Exporter avec les spécifications de la revue :

   from figure_export import save_for_journal
   save_for_journal(fig, 'figure1', journal='nature', figure_type='line_art')

Tâche 5 : Corriger une figure existante pour respecter les normes de publication

Approche par checklist (liste complète dans references/publication_guidelines.md) :

1. Vérifier la résolution : Confirmer que les DPI respectent les exigences de la revue
2. Vérifier le format de fichier : Utiliser du vectoriel pour les graphiques, TIFF/PNG pour les images
3. Vérifier les couleurs : S'assurer que c'est accessible aux daltoniens
4. Vérifier les polices : Minimum 6-7 pt à la taille finale, sans-serif
5. Vérifier les étiquettes : Tous les axes étiquetés avec les unités
6. Vérifier la taille : Correspond à la largeur de colonne de la revue
7. Tester en niveaux de gris : La figure est interprétable sans couleur
8. Supprimer le chart junk : Pas de grilles inutiles, effets 3D, ombres

Tâche 6 : Créer des visualisations accessibles aux daltoniens

Stratégie :

1. Utiliser les palettes approuvées depuis assets/color_palettes.py
2. Ajouter un codage redondant (styles de ligne, marqueurs, motifs)
3. Tester avec un simulateur de daltonisme
4. Assurer la compatibilité en niveaux de gris

Exemple :

from color_palettes import apply_palette
import matplotlib.pyplot as plt

apply_palette('okabe_ito')

# Ajouter un codage redondant au-delà de la couleur
line_styles = ['-', '--', '-.', ':']
markers = ['o', 's', '^', 'v']

for i, (data, label) in enumerate(datasets):
    plt.plot(x, data, linestyle=line_styles[i % 4],
             marker=markers[i % 4], label=label)

Rigueur statistique

Toujours inclure :

• Des barres d'erreur (SD, SEM, ou IC - spécifier laquelle dans la légende)
• La taille de l'échantillon (n) dans la figure ou la légende
• Les marqueurs de significativité statistique (, , )
• Les points de données individuels quand c'est possible (pas seulement les statistiques résumées)

Exemple avec statistiques :

# Afficher les points individuels avec les statistiques résumées
ax.scatter(x_jittered, individual_points, alpha=0.4, s=8)
ax.errorbar(x, means, yerr=sems, fmt='o', capsize=3)

# Marquer la significativité
ax.text(1.5, max_y * 1.1, '***', ha='center', fontsize=8)

Travailler avec différentes bibliothèques de tracé

Matplotlib

• Contrôle maximal sur les détails de publication
• Optimal pour les figures multi-panneaux complexes
• Utiliser les fichiers de style fournis pour une mise en forme cohérente
• Voir references/matplotlib_examples.md pour des exemples complets

Seaborn

Seaborn propose une interface de haut niveau, orientée dataset, pour les graphiques statistiques, construite sur matplotlib. Elle excelle dans la création de visualisations statistiques de qualité publication avec un code minimal tout en maintenant une compatibilité complète avec la personnalisation matplotlib.

Avantages clés pour la visualisation scientifique :

• Estimation statistique automatique et intervalles de confiance
• Support intégré pour les figures multi-panneaux (faceting)
• Palettes accessibles aux daltoniens par défaut
• API orientée dataset utilisant les DataFrames pandas
• Cartographie sémantique des variables aux propriétés visuelles

Démarrage rapide avec style publication

Appliquez toujours d'abord les styles de publication matplotlib, puis configurez seaborn :

import seaborn as sns
import matplotlib.pyplot as plt
from style_presets import apply_publication_style

# Appliquer le style publication
apply_publication_style('default')

# Configurer seaborn pour la publication
sns.set_theme(style='ticks', context='paper', font_scale=1.1)
sns.set_palette('colorblind')  # Utiliser une palette accessible aux daltoniens

# Créer une figure
fig, ax = plt.subplots(figsize=(3.5, 2.5))
sns.scatterplot(data=df, x='time', y='response', 
                hue='treatment', style='condition', ax=ax)
sns.despine()  # Supprimer les spines supérieur et droit

Types de graphiques courants pour les publications

Comparaisons statistiques :

# Diagramme en boîte avec points individuels pour la transparence
fig, ax = plt.subplots(figsize=(3.5, 3))
sns.boxplot(data=df, x='treatment', y='response', 
            order=['Control', 'Low', 'High'], palette='Set2', ax=ax)
sns.stripplot(data=df, x='treatment', y='response',
              order=['Control', 'Low', 'High'], 
              color='black', alpha=0.3, size=3, ax=ax)
ax.set_ylabel('Response (μM)')
sns.despine()

Analyse de distribution :

# Diagramme en violon avec comparaison divisée
fig, ax = plt.subplots(figsize=(4, 3))
sns.violinplot(data=df, x='timepoint', y='expression',
               hue='treatment', split=True, inner='quartile', ax=ax)
ax.set_ylabel('Gene Expression (AU)')
sns.despine()

Matrices de corrélation :

# Carte de chaleur avec colormap et annotations appropriées
fig, ax = plt.subplots(figsize=(5, 4))
corr = df.corr()
mask = np.triu(np.ones_like(corr, dtype=bool))  # Afficher seulement le triangle inférieur
sns.heatmap(corr, mask=mask, annot=True, fmt='.2f',
            cmap='RdBu_r', center=0, square=True,
            linewidths=1, cbar_kws={'shrink': 0.8}, ax=ax)
plt.tight_layout()

Séries temporelles avec bandes de confiance :

# Graphique linéaire avec calcul automatique d'IC
fig, ax = plt.subplots(figsize=(5, 3))
sns.lineplot(data=timeseries, x='time', y='measurement',
             hue='treatment', style='replicate',
             errorbar=('ci', 95), markers=True, dashes=False, ax=ax)
ax.set_xlabel('Time (hours)')
ax.set_ylabel('Measurement (AU)')
sns.despine()

Figures multi-panneaux avec Seaborn

Utiliser FacetGrid pour le faceting automatique :

# Créer un graphique en facettes
g = sns.relplot(data=df, x='dose', y='response',
                hue='treatment', col='cell_line', row='timepoint',
                kind='line', height=2.5, aspect=1.2,
                errorbar=('ci', 95), markers=True)
g.set_axis_labels('Dose (μM)', 'Response (AU)')
g.set_titles('{row_name} | {col_name}')
sns.despine()

# Enregistrer avec les bons DPI
from figure_export import save_publication_figure
save_publication_figure(g.figure, 'figure_facets', 
                       formats=['pdf', 'png'], dpi=300)

Combiner seaborn avec les sous-graphiques matplotlib :

# Créer une mise en page multi-panneaux personnalisée
fig, axes = plt.subplots(2, 2, figsize=(7, 6))

# Panneau A : Scatter avec régression
sns.regplot(data=df, x='predictor', y='response', ax=axes[0, 0])
axes[0, 0].text(-0.15, 1.05, 'A', transform=axes[0, 0].transAxes,
                fontsize=10, fontweight='bold')

# Panneau B : Comparaison de distribution
sns.violinplot(data=df, x='group', y='value', ax=axes[0, 1])
axes[0, 1].text(-0.15, 1.05, 'B', transform=axes[0, 1].transAxes,
                fontsize=10, fontweight='bold')

# Panneau C : Carte de chaleur
sns.heatmap(correlation_data, cmap='viridis', ax=axes[1, 0])
axes[1, 0].text(-0.15, 1.05, 'C', transform=axes[1, 0].transAxes,
                fontsize=10, fontweight='bold')

# Panneau D : Série temporelle
sns.lineplot(data=timeseries, x='time', y='signal', 
             hue='condition', ax=axes[1, 1])
axes[1, 1].text(-0.15, 1.05, 'D', transform=axes[1, 1].transAxes,
                fontsize=10, fontweight='bold')

plt.tight_layout()
sns.despine()

Palettes de couleurs pour les publications

Seaborn inclut plusieurs palettes accessibles aux daltoniens :

# Utiliser la palette intégrée pour daltoniens (recommandée)
sns.set_palette('colorblind')

# Ou spécifier des couleurs personnalisées accessibles aux daltoniens (Okabe-Ito)
okabe_ito = ['#E69F00', '#56B4E9', '#009E73', '#F0E442',
             '#0072B2', '#D55E00', '#CC79A7', '#000000']
sns.set_palette(okabe_ito)

# Pour les cartes de chaleur et données continues
sns.heatmap(data, cmap='viridis')  # Perceptuellement uniforme
sns.heatmap(corr, cmap='RdBu_r', center=0)  # Divergente, centrée

Choisir entre les fonctions au niveau des axes et au niveau des figures

Fonctions au niveau des axes (par ex. scatterplot, boxplot, heatmap) :

• Utiliser lors de la construction de mises en page multi-panneaux personnalisées
• Accepter le paramètre ax= pour un placement précis
• Meilleure intégration avec les sous-graphiques matplotlib
• Plus de contrôle sur la composition des figures

fig, ax = plt.subplots(figsize=(3.5, 2.5))
sns.scatterplot(data=df, x='x', y='y', hue='group', ax=ax)

Fonctions au niveau des figures (par ex. relplot, catplot, displot) :

• Utiliser pour le faceting automatique par variables catégoriques
• Créer des figures complètes avec un style cohérent
• Excellent pour l'analyse exploratoire
• Utiliser height et aspect pour le dimensionnement

g = sns.relplot(data=df, x='x', y='y', col='category', kind='scatter')

Rigueur statistique avec Seaborn

Seaborn calcule et affiche automatiquement l'incertitude :

# Graphique linéaire : affiche la moyenne ± IC 95% par défaut
sns.lineplot(data=df, x='time', y='value', hue='treatment',
             errorbar=('ci', 95))  # Peut changer en 'sd', 'se', etc.

# Diagramme en barres : affiche la moyenne avec IC bootstrappé
sns.barplot(data=df, x='treatment', y='response',
            errorbar=('ci', 95), capsize=0.1)

# Toujours spécifier le type d'erreur dans la légende de la figure :
# « Les barres d'erreur représentent les intervalles de confiance à 95 % »

Bonnes pratiques pour les figures Seaborn prêtes pour la publication

1. Toujours définir d'abord le thème de publication :

   sns.set_theme(style='ticks', context='paper', font_scale=1.1)

2. Utiliser des palettes accessibles aux daltoniens :

   sns.set_palette('colorblind')

3. Supprimer les éléments inutiles :

   sns.despine()  # Supprimer les spines supérieur et droit

4. Contrôler la taille de la figure de manière appropriée :

   # Au niveau des axes : utiliser figsize matplotlib
   fig, ax = plt.subplots(figsize=(3.5, 2.5))
   
   # Au niveau des figures : utiliser height et aspect
   g = sns.relplot(..., height=3, aspect=1.2)

5. Afficher les points de données individuels quand c'est possible :

   sns.boxplot(...)  # Statistiques résumées
   sns.stripplot(..., alpha=0.3)  # Points individuels

6. Inclure des étiquettes appropriées avec des unités :

   ax.set_xlabel('Time (hours)')
   ax.set_ylabel('Expression (AU)')

7. Exporter à la bonne résolution :

   from figure_export import save_publication_figure
   save_publication_figure(fig, 'figure_name', 
                          formats=['pdf', 'png'], dpi=300)

Techniques avancées avec Seaborn

Relations pairwise pour l'analyse exploratoire :

# Aperçu rapide de toutes les relations
g = sns.pairplot(data=df, hue='condition', 
                 vars=['gene1', 'gene2', 'gene3'],
                 corner=True, diag_kind='kde', height=2)

Carte de chaleur avec clustering hiérarchique :

# Regrouper les échantillons et les caractéristiques
g = sns.clustermap(expression_data, method='ward', 
                   metric='euclidean', z_score=0,
                   cmap='RdBu_r', center=0, 
                   figsize=(10, 8), 
                   row_colors=condition_colors,
                   cbar_kws={'label': 'Z-score'})

Distributions conjointes avec marges :

# Distribution bivariée avec contexte
g = sns.jointplot(data=df, x='gene1', y='gene2',
                  hue='treatment', kind='scatter',
                  height=6, ratio=4, marginal_kws={'kde': True})

Problèmes courants avec Seaborn et solutions

Problème : Légende en dehors de la zone de tracé

g = sns.relplot(...)
g._legend.set_bbox_to_anchor((0.9, 0.5))

Problème : Étiquettes qui se chevauchent

plt.xticks(rotation=45, ha='right')
plt.tight_layout()

Problème : Texte trop petit à la taille finale

sns.set_context('paper', font_scale=1.2)  # Augmenter si nécessaire

Ressources supplémentaires

Pour plus d'informations détaillées sur seaborn, voir :

• scientific-packages/seaborn/SKILL.md - Documentation complète de seaborn
• scientific-packages/seaborn/references/examples.md - Cas d'utilisation pratiques
• scientific-packages/seaborn/references/function_reference.md - Référence API complète
• scientific-packages/seaborn/references/objects_interface.md - API déclarative moderne

Plotly

• Figures interactives pour l'exploration
• Exporter les images statiques pour la publication
• Configurer pour la qualité publication :

  fig.update_layout(
    font=dict(family='Arial, sans-serif', size=10),
    plot_bgcolor='white',
    # ... voir matplotlib_examples.md Exemple 8
  )
  fig.write_image('figure.png', scale=3)  # scale=3 donne ~300 DPI

Ressources

Répertoire Références

Charger ces ressources au besoin pour des informations détaillées :

• publication_guidelines.md : Guide complet des bonnes pratiques

  • Exigences en matière de résolution et de format de fichier
  • Directives typographiques
  • Règles de mise en page et composition
  • Exigences de rigueur statistique
  • Liste de vérification complète de publication

• color_palettes.md : Guide d'utilisation des couleurs

  • Spécifications des palettes accessibles aux daltoniens avec valeurs RGB
  • Recommandations de colormaps séquentielles et divergentes
  • Procédures de test pour l'accessibilité
  • Palettes spécifiques au domaine (génomique, microscopie)

• journal_requirements.md : Spécifications spécifiques aux revues

  • Exigences techniques par éditeur
  • Spécifications de format de fichier et DPI
  • Exigences de dimension des figures
  • Tableau de référence rapide

• matplotlib_examples.md : Exemples de code pratiques

  • 10 exemples complets de travail
  • Graphiques linéaires, diagrammes en barres, cartes de chaleur, figures multi-panneaux
  • Exemples de figures spécifiques aux revues
  • Conseils pour chaque bibliothèque (matplotlib, seaborn, plotly)

Répertoire Scripts

Utiliser ces scripts d'assistance pour l'automatisation :

• figure_export.py : Utilitaires d'export

  • save_publication_figure() : Enregistrer dans plusieurs formats avec les bons DPI
  • save_for_journal() : Utiliser automatiquement les exigences spécifiques aux revues
  • check_figure_size() : Vérifier que les dimensions respectent les spécifications de la revue
  • Exécuter directement : python scripts/figure_export.py pour des exemples

• style_presets.py : Styles préconfigurés

  • apply_publication_style() : Appliquer des styles prédéfinis (default, nature, science, cell)
  • set_color_palette() : Changement rapide de palette
  • configure_for_journal() : Configuration en une seule commande pour une revue
  • Exécuter directement : python scripts/style_presets.py pour voir des exemples

Répertoire Assets

Utiliser ces fichiers dans les figures :

• color_palettes.py : Définitions de couleurs importables

  • Toutes les palettes recommandées en tant que constantes Python
  • Fonction d'assistance apply_palette()
  • Peut être importé directement dans les notebooks/scripts

• Fichiers de style Matplotlib : Utiliser avec plt.style.use()

  • publication.mplstyle : Qualité générale de publication
  • nature.mplstyle : Spécifications de la revue Nature
  • presentation.mplstyle : Polices plus grandes pour les affiches/diapositives

Résumé du flux de travail

Flux de travail recommandé pour créer des figures de publication :

1. Planifier : Déterminer la revue cible, le type de figure et le contenu
2. Configurer : Appliquer le style approprié pour la revue

   from style_presets import configure_for_journal
   configure_for_journal('nature', 'single')

3. Créer : Construire la figure avec des étiquettes, couleurs et statistiques appropriées
4. Vérifier : Vérifier la taille, les polices, les couleurs et l'accessibilité

   from figure_export import check_figure_size
   check_figure_size(fig, journal='nature')

5. Exporter : Enregistrer dans les formats requis

   from figure_export import save_for_journal
   save_for_journal(fig, 'figure1', 'nature', 'combination')

6. Réviser : Visualiser à la taille finale dans le contexte du manuscrit

Pièges courants à éviter

1. Police trop petite : Texte illisible lorsqu'imprimé à la taille finale
2. Format JPEG : Ne jamais utiliser JPEG pour les graphiques/tracés (crée des artefacts)
3. Couleurs rouge-vert : ~8% des hommes ne peuvent pas les distinguer
4. Basse résolution : Figures pixelisées dans la publication
5. Unités manquantes : Toujours étiqueter les axes avec les unités
6. Effets 3D : Distorsion de la perception, à éviter complètement
7. Chart junk : Supprimer les grilles inutiles et les décorations
8. Axes tronqués : Commencer les diagrammes en barres à zéro sauf justification scientifique
9. Style incohérent : Polices/couleurs différentes dans les figures du même manuscrit
10. Pas de barres d'erreur : Toujours afficher l'incertitude

Liste de vérification finale

Avant de soumettre les figures, vérifiez :

• [ ] La résolution respecte les exigences de la revue (300+ DPI)
• [ ] Le format de fichier est correct (vectoriel pour les tracés, TIFF pour les images)
• [ ] La taille de la figure correspond aux spécifications de la revue
• [ ] Tout le texte est lisible à la taille finale (≥6 pt)
• [ ] Les couleurs sont accessibles aux daltoniens
• [ ] La figure fonctionne en niveaux de gris
• [ ] Tous les axes sont étiquetés avec les unités
• [ ] Des barres d'erreur sont présentes avec définition dans la légende
• [ ] Les étiquettes des panneaux sont présentes et cohérentes
• [ ] Pas de chart junk ou d'effets 3D
• [ ] Les polices sont cohérentes sur toutes les figures
• [ ] La significativité statistique est clairement marquée
• [ ] La légende est claire et complète

Utilisez cette compétence pour vous assurer que les figures scientifiques respectent les plus hauts standards de publication tout en restant accessibles à tous les lecteurs.