Enregistrement des figures interactives de Matplotlib

Existe-t-il un moyen de sauvegarder une figure Matplotlib de sorte qu'elle puisse être rouverte et avoir une interaction typique restaurée? (Comme le format .fig dans MATLAB?)

Je me retrouve à exécuter les mêmes scripts plusieurs fois pour générer ces figures interactives. Ou j'envoie à mes collègues plusieurs fichiers PNG statiques pour montrer différents aspects d'un tracé. Je préfère envoyer l'objet figure et les faire interagir avec lui-même.

Ce serait une fonctionnalité intéressante, mais AFAIK n'est pas implémentée dans Matplotlib et serait probablement difficile à implémenter vous-même en raison de la façon dont les chiffres sont stockés.

Je suggérerais soit (a) de séparer le traitement des données de la génération de la figure (qui enregistre les données avec un nom unique) et d'écrire un script de génération de figure (charger un fichier spécifié des données enregistrées) et de le modifier comme bon vous semble ou (b ) enregistrez au format PDF / SVG / PostScript et modifiez-les dans un éditeur de figures sophistiqué comme Adobe Illustrator (ou Inkscape ).

EDIT post Automne 2012 : Comme d'autres l'ont souligné ci-dessous (bien que mentionnant ici car c'est la réponse acceptée), Matplotlib depuis la version 1.2 vous a permis de décaper les chiffres. Comme l' indiquent les notes de publication , il s'agit d'une fonctionnalité expérimentale et ne prend pas en charge l'enregistrement d'une figure dans une version de matplotlib et son ouverture dans une autre. Il est également généralement peu sûr de restaurer un cornichon à partir d'une source non fiable.

Pour le partage / l'édition ultérieure des parcelles (qui nécessitent d'abord un traitement de données important et peuvent devoir être peaufinées des mois plus tard, par exemple lors de l'examen par les pairs pour une publication scientifique), je recommande toujours le flux de travail de (1) avoir un script de traitement de données qui avant de générer un graphique enregistre les données traitées (qui vont dans votre tracé) dans un fichier, et (2) ont un script de génération de tracé séparé (que vous ajustez si nécessaire) pour recréer le tracé. De cette façon, pour chaque tracé, vous pouvez rapidement exécuter un script et le régénérer (et copier rapidement les paramètres de votre tracé avec de nouvelles données). Cela dit, le décapage d'une figure peut être pratique pour une analyse de données à court terme / interactive / exploratoire.

Je viens de découvrir comment faire cela. Le "support de cornichon expérimental" mentionné par @pelson fonctionne assez bien.

Essaye ça:

# Plot something
import matplotlib.pyplot as plt
fig,ax = plt.subplots()
ax.plot([1,2,3],[10,-10,30])

Après votre peaufinage interactif, enregistrez l'objet figure sous forme de fichier binaire:

import pickle
pickle.dump(fig, open('FigureObject.fig.pickle', 'wb')) # This is for Python 3 - py2 may need `file` instead of `open`

Plus tard, ouvrez la figure et les modifications doivent être enregistrées et l'interactivité de l'interface graphique doit être présente:

import pickle
figx = pickle.load(open('FigureObject.fig.pickle', 'rb'))

figx.show() # Show the figure, edit it, etc.!

Vous pouvez même extraire les données des tracés:

data = figx.axes[0].lines[0].get_data()

(Cela fonctionne pour les lignes, pcolor et imshow - pcolormesh fonctionne avec quelques astuces pour reconstruire les données aplaties .)

J'ai eu l'excellent conseil de Saving Matplotlib Figures Using Pickle .

Depuis Matplotlib 1.2, nous avons maintenant un support expérimental de pickle . Essayez-le et voyez si cela fonctionne bien pour votre cas. Si vous rencontrez des problèmes, veuillez nous en informer sur la liste de diffusion Matplotlib ou en ouvrant un numéro sur github.com/matplotlib/matplotlib .

Pourquoi ne pas simplement envoyer le script Python? Les fichiers .fig de MATLAB nécessitent que le destinataire dispose de MATLAB pour les afficher, c'est donc à peu près équivalent à l'envoi d'un script Python qui nécessite l'affichage de Matplotlib.

Alternativement (avertissement: je n'ai pas encore essayé cela), vous pouvez essayer de décaper la figure:

import pickle
output = open('interactive figure.pickle', 'wb')
pickle.dump(gcf(), output)
output.close()

Bonne question. Voici le texte du doc ​​de pylab.save:

pylab ne fournit plus de fonction de sauvegarde, bien que l'ancienne fonction pylab soit toujours disponible sous le nom matplotlib.mlab.save (vous pouvez toujours vous y référer dans pylab sous le nom de "mlab.save"). Cependant, pour les fichiers texte brut, nous recommandons numpy.savetxt. Pour enregistrer des tableaux numpy, nous vous recommandons numpy.save et son analogique numpy.load, qui sont disponibles dans pylab sous les noms np.save et np.load.

J'ai trouvé un moyen relativement simple (mais un peu non conventionnel) de sauvegarder mes figurines matplotlib. Cela fonctionne comme ceci:

import libscript

import matplotlib.pyplot as plt
import numpy as np

t = np.arange(0.0, 2.0, 0.01)
s = 1 + np.sin(2*np.pi*t)

#<plot>
plt.plot(t, s)
plt.xlabel('time (s)')
plt.ylabel('voltage (mV)')
plt.title('About as simple as it gets, folks')
plt.grid(True)
plt.show()
#</plot>

save_plot(fileName='plot_01.py',obj=sys.argv[0],sel='plot',ctx=libscript.get_ctx(ctx_global=globals(),ctx_local=locals()))

avec la fonction save_plotdéfinie comme ceci (version simple pour comprendre la logique):

def save_plot(fileName='',obj=None,sel='',ctx={}):
    """
    Save of matplolib plot to a stand alone python script containing all the data and configuration instructions to regenerate the interactive matplotlib figure.

    Parameters
    ----------
    fileName : [string] Path of the python script file to be created.
    obj : [object] Function or python object containing the lines of code to create and configure the plot to be saved.
    sel : [string] Name of the tag enclosing the lines of code to create and configure the plot to be saved.
    ctx : [dict] Dictionary containing the execution context. Values for variables not defined in the lines of code for the plot will be fetched from the context.

    Returns
    -------
    Return ``'done'`` once the plot has been saved to a python script file. This file contains all the input data and configuration to re-create the original interactive matplotlib figure.
    """
    import os
    import libscript

    N_indent=4

    src=libscript.get_src(obj=obj,sel=sel)
    src=libscript.prepend_ctx(src=src,ctx=ctx,debug=False)
    src='\n'.join([' '*N_indent+line for line in src.split('\n')])

    if(os.path.isfile(fileName)): os.remove(fileName)
    with open(fileName,'w') as f:
        f.write('import sys\n')
        f.write('sys.dont_write_bytecode=True\n')
        f.write('def main():\n')
        f.write(src+'\n')

        f.write('if(__name__=="__main__"):\n')
        f.write(' '*N_indent+'main()\n')

return 'done'

ou définir une fonction save_plotcomme celle-ci (meilleure version utilisant la compression zip pour produire des fichiers de figures plus légers):

def save_plot(fileName='',obj=None,sel='',ctx={}):

    import os
    import json
    import zlib
    import base64
    import libscript

    N_indent=4
    level=9#0 to 9, default: 6
    src=libscript.get_src(obj=obj,sel=sel)
    obj=libscript.load_obj(src=src,ctx=ctx,debug=False)
    bin=base64.b64encode(zlib.compress(json.dumps(obj),level))

    if(os.path.isfile(fileName)): os.remove(fileName)
    with open(fileName,'w') as f:
        f.write('import sys\n')
        f.write('sys.dont_write_bytecode=True\n')
        f.write('def main():\n')
        f.write(' '*N_indent+'import base64\n')
        f.write(' '*N_indent+'import zlib\n')
        f.write(' '*N_indent+'import json\n')
        f.write(' '*N_indent+'import libscript\n')
        f.write(' '*N_indent+'bin="'+str(bin)+'"\n')
        f.write(' '*N_indent+'obj=json.loads(zlib.decompress(base64.b64decode(bin)))\n')
        f.write(' '*N_indent+'libscript.exec_obj(obj=obj,tempfile=False)\n')

        f.write('if(__name__=="__main__"):\n')
        f.write(' '*N_indent+'main()\n')

return 'done'

Cela utilise libscriptmon propre module , qui repose principalement sur des modules inspectet ast. Je peux essayer de le partager sur Github si un intérêt est exprimé (cela nécessiterait d'abord un nettoyage et moi pour commencer avec Github).

L'idée derrière cette save_plotfonction et ce libscriptmodule est de récupérer les instructions python qui créent la figure (en utilisant le module inspect), de les analyser (en utilisant le module ast) pour extraire toutes les variables, fonctions et modules sur lesquels il s'appuie, les extraire du contexte d'exécution et les sérialiser comme instructions python (le code pour les variables sera comme t=[0.0,2.0,0.01]... et le code pour les modules sera comme import matplotlib.pyplot as plt...) ajouté aux instructions de la figure. Les instructions python résultantes sont enregistrées en tant que script python dont l'exécution reconstruira la figure originale de matplotlib.

Comme vous pouvez l'imaginer, cela fonctionne bien pour la plupart (sinon tous) des figures matplotlib.