web-dev-qa-db-fra.com

Comment faire pylab.savefig () enregistrer l'image pour la fenêtre 'maximisée' au lieu de la taille par défaut

J'utilise pylab dans matplotlib pour créer un tracé et l'enregistrer dans un fichier image. Cependant, lorsque je sauvegarde l'image à l'aide de pylab.savefig( image_name ), je constate que l'imageTAILLEimage enregistrée est identique à l'image affichée lorsque j'utilise pylab.show().

En l'occurrence, j'ai beaucoup de données dans l'intrigue et lorsque j'utilise pylab.show(), je dois agrandir la fenêtre avant de pouvoir visualiser l'intégralité de l'intrigue, et les tickers xlabel ne se superposent pas.

Y at-il de toute façon que je puisse par programme "agrandir" la fenêtre avant d'enregistrer l'image dans un fichier? - pour le moment, je ne reçois que l'image "par défaut" de la taille de la fenêtre, ce qui a pour effet de superposer les étiquettes de l'axe des x.

pythonmatplotlib
41
Homunculus Reticulli

Vous définissez la taille à l'initialisation:

fig2 = matplotlib.pyplot.figure(figsize=(8.0, 5.0)) # in inches!

Modifier :

Si le problème concerne les ticks de l'axe des x, vous pouvez les définir "manuellement":

fig2.add_subplot(111).set_xticks(arange(1,3,0.5)) # You can actually compute the interval You need - and substitute here

Et ainsi de suite avec d'autres aspects de votre parcelle. Vous pouvez tout configurer. Voici un exemple:

from numpy import arange
import matplotlib
# import matplotlib as mpl
import matplotlib.pyplot
# import matplotlib.pyplot as plt

x1 = [1,2,3]
y1 = [4,5,6]
x2 = [1,2,3]
y2 = [5,5,5]

# initialization
fig2 = matplotlib.pyplot.figure(figsize=(8.0, 5.0)) # The size of the figure is specified as (width, height) in inches

# lines:
l1 = fig2.add_subplot(111).plot(x1,y1, label=r"Text $formula$", "r-", lw=2)
l2 = fig2.add_subplot(111).plot(x2,y2, label=r"$legend2$" ,"g--", lw=3)
fig2.add_subplot(111).legend((l1,l2), loc=0)

# axes:
fig2.add_subplot(111).grid(True)
fig2.add_subplot(111).set_xticks(arange(1,3,0.5))
fig2.add_subplot(111).axis(xmin=3, xmax=6) # there're also ymin, ymax
fig2.add_subplot(111).axis([0,4,3,6]) # all!
fig2.add_subplot(111).set_xlim([0,4])
fig2.add_subplot(111).set_ylim([3,6])

# labels:
fig2.add_subplot(111).set_xlabel(r"x $2^2$", fontsize=15, color = "r")
fig2.add_subplot(111).set_ylabel(r"y $2^2$")
fig2.add_subplot(111).set_title(r"title $6^4$")
fig2.add_subplot(111).text(2, 5.5, r"an equation: $E=mc^2$", fontsize=15, color = "y")
fig2.add_subplot(111).text(3, 2, unicode('f\374r', 'latin-1'))

# saving:
fig2.savefig("fig2.png")

Alors, que voulez-vous exactement configurer?

23
Adobe

Matplotlib (pylab) propose deux options principales pour contrôler la taille de l'image:

  1. Vous pouvez définir la taille de l'image résultante en pouces 
  2. Vous pouvez définir le DPI (points par pouce) pour le fichier de sortie (il s’agit d’une résolution)

Normalement, vous voudriez faire les deux, car vous aurez ainsi le contrôle total sur la taille de l'image résultante en pixels. Par exemple, si vous souhaitez rendre une image exactement 800x600, vous pouvez utiliser DPI = 100 et définir la taille sur 8 x 6 pouces:

import matplotlib.pyplot as plt
# plot whatever you need...
# now, before saving to file:
figure = plt.gcf() # get current figure
figure.set_size_inches(8, 6)
# when saving, specify the DPI
plt.savefig("myplot.png", dpi = 100)

On peut utiliser n'importe quel DPI. En fait, vous pouvez jouer avec différentes valeurs de DPI et de taille pour obtenir le résultat que vous préférez. Attention, toutefois, l'utilisation de très petites DPI n'est pas une bonne idée, car matplotlib peut ne pas trouver une bonne police pour restituer la légende et d'autres textes. Par exemple, vous ne pouvez pas définir le DPI = 1, car il n'y a pas de polices avec des caractères rendus avec 1 pixel :)

D’autres commentaires, j’ai compris qu’un autre problème était le bon rendu du texte. Pour cela, vous pouvez également changer la taille de la police. Par exemple, vous pouvez utiliser 6 pixels par caractère, au lieu de 12 pixels par caractère utilisé par défaut (ce qui rend tout le texte deux fois plus petit).

import matplotlib
#...
matplotlib.rc('font', size=6)

Enfin, quelques références à la documentation originale: http://matplotlib.sourceforge.net/api/pyplot_api.html#matplotlib.pyplot.savefig , http://matplotlib.sourceforge.net/ api/pyplot_api.html # matplotlib.pyplot.gcf , http://matplotlib.sourceforge.net/api/figure_api.html#matplotlib.figure.Figure.set_size_inches /, - http: // matplotlib. sourceforge.net/users/customizing.html#dynamic-rc-settings

P.S. Désolé, je n'ai pas utilisé pylab, mais autant que je sache, tout le code ci-dessus fonctionnera de la même manière dans pylab - remplacez simplement plt dans mon code par la pylab (ou le nom que vous avez attribué lors de l'importation de pylab). Idem pour matplotlib - utilisez plutôt pylab.

43
Timur

Je pense que vous devez spécifier une résolution différente lorsque vous enregistrez la figure dans un fichier:

fig = matplotlib.pyplot.figure()
# generate your plot
fig.savefig("myfig.png",dpi=600)

La spécification d'une valeur dpi élevée devrait avoir un effet similaire à celui de la maximisation de la fenêtre de l'interface graphique.

7
silvado

Vérifiez ceci: Comment maximiser une fenêtre plt.show () en utilisant Python

La commande est différente selon le backend que vous utilisez. Je trouve que c’est le meilleur moyen de s’assurer que les images sauvegardées ont la même mise à l’échelle que ce que je vois sur mon écran.

Depuis que j'utilise Canopy avec le backend QT:

pylab.get_current_fig_manager().window.showMaximized()

J'appelle ensuite savefig () selon les besoins, avec une réponse DPI supérieure par réponse.

4
Maximus

J'ai fait la même recherche il y a longtemps, il semble que la solution exacte dépende du backend.

J'ai lu un tas de sources et le plus utile était probablement la réponse de Pythonio ici Comment maximiser une fenêtre plt.show () en utilisant Python J'ai ajusté le code et fini avec la fonction ci-dessous. Cela fonctionne décemment pour moi sur Windows, j'utilise principalement Qt, où je l'utilise assez souvent, alors qu'il est testé de manière minimale avec d'autres serveurs.

En gros, cela consiste à identifier le serveur et à appeler la fonction appropriée. Notez que j'ai ajouté une pause après parce que j'avais des problèmes avec certaines fenêtres maximisées et d'autres non, il semble que cela soit résolu pour moi. 

def maximize(backend=None,fullscreen=False):
    """Maximize window independently on backend.
    Fullscreen sets fullscreen mode, that is same as maximized, but it doesn't have title bar (press key F to toggle full screen mode)."""
    if backend is None:
        backend=matplotlib.get_backend()
    mng = plt.get_current_fig_manager()

    if fullscreen:
        mng.full_screen_toggle()
    else:
        if backend == 'wxAgg':
            mng.frame.Maximize(True)
        Elif backend == 'Qt4Agg' or backend == 'Qt5Agg':
            mng.window.showMaximized()
        Elif backend == 'TkAgg':
            mng.window.state('zoomed') #works fine on Windows!
        else:
            print ("Unrecognized backend: ",backend) #not tested on different backends (only Qt)
    plt.show()

    plt.pause(0.1) #this is needed to make sure following processing gets applied (e.g. tight_layout)
1
Vincenzooo

Si je comprends bien ce que vous voulez faire, vous pouvez créer votre figure et définir la taille de la fenêtre. Ensuite, vous pouvez enregistrer votre graphique avec le bouton de la boîte à outils matplotlib. Voici un exemple:

from pylab import get_current_fig_manager,show,plt,imshow

plt.Figure()
thismanager = get_current_fig_manager()
thismanager.window.wm_geometry("500x500+0+0") 
#in this case 500 is the size (in pixel) of the figure window. In your case you want to maximise to the size of your screen or whatever

imshow(your_data)
show()
0
maupertius