Salva la trama nel file di immagine invece di visualizzarla utilizzando Matplotlib

Sto scrivendo uno script veloce e sporco per generare trame al volo. Sto usando il codice seguente (dalla documentazione di Matplotlib ) come punto di partenza:

from pylab import figure, axes, pie, title, show

# Make a square figure and axes
figure(1, figsize=(6, 6))
ax = axes([0.1, 0.1, 0.8, 0.8])

labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
fracs = [15, 30, 45, 10]

explode = (0, 0.05, 0, 0)
pie(fracs, explode=explode, labels=labels, autopct='%1.1f%%', shadow=True)
title('Raining Hogs and Dogs', bbox={'facecolor': '0.8', 'pad': 5})

show()  # Actually, don't show, just save to foo.png

Non voglio visualizzare la trama su una GUI, invece, voglio salvare la trama in un file (diciamo foo.png), in modo che, ad esempio, possa essere utilizzata negli script batch. Come lo faccio?

Mentre alla domanda è stata data una risposta, vorrei aggiungere alcuni suggerimenti utili quando si utilizza matplotlib.pyplot.savefig . Il formato del file può essere specificato dall'estensione:

from matplotlib import pyplot as plt

plt.savefig('foo.png')
plt.savefig('foo.pdf')

Fornirà rispettivamente un output rasterizzato o vettorizzato, entrambi utili. Inoltre, troverai che pylablascia uno spazio generoso, spesso indesiderabile, intorno all'immagine. Rimuovilo con:

savefig('foo.png', bbox_inches='tight')

Come altri hanno già detto, plt.savefig()o fig1.savefig()è davvero il modo di salvare un'immagine.

Tuttavia ho scoperto che in alcuni casi la figura è sempre mostrata . (es. con Spyder con plt.ion(): modalità interattiva = Attivo.) Mi aggiro forzando la chiusura della finestra della figura nel mio loop gigante con plt.close(figure_object)(vedi documentazione ), quindi non ho un milione di figure aperte durante il loop:

import matplotlib.pyplot as plt
fig, ax = plt.subplots( nrows=1, ncols=1 )  # create figure & 1 axis
ax.plot([0,1,2], [10,20,3])
fig.savefig('path/to/save/image/to.png')   # save the figure to file
plt.close(fig)    # close the figure window

Dovresti essere in grado di riaprire la figura in seguito, se necessario, con fig.show()(non ho testato me stesso).

La soluzione è:

pylab.savefig('foo.png')

Ho appena trovato questo link nella documentazione di MatPlotLib che risolve esattamente questo problema: http://matplotlib.org/faq/howto_faq.html#generate-images-without-having-a-window-appear

Dicono che il modo più semplice per impedire alla figura di spuntare sia usare un backend non interattivo (es. Agg), tramite matplotib.use(<backend>), ad es .:

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
plt.plot([1,2,3])
plt.savefig('myfig')

Personalmente preferisco ancora usare plt.close( fig ), da allora hai la possibilità di nascondere determinate figure (durante un ciclo), ma visualizzare comunque le figure per l'elaborazione dei dati post-ciclo. Probabilmente è più lento della scelta di un backend non interattivo - sarebbe interessante se qualcuno lo provasse.

AGGIORNAMENTO : per Spyder, di solito non è possibile impostare il backend in questo modo (poiché Spyder di solito carica matplotlib in anticipo, impedendoti di utilizzarlo matplotlib.use()).

Invece, usa plt.switch_backend('Agg')o Disattiva " abilita supporto " nelle preferenze di Spyder ed esegui matplotlib.use('Agg')tu stesso il comando.

Da questi due suggerimenti: uno , due

Se non ti piace il concetto della figura "attuale", fai:

import matplotlib.image as mpimg

img = mpimg.imread("src.png")
mpimg.imsave("out.png", img)

Le altre risposte sono corrette. Tuttavia, a volte trovo che voglio aprire l' oggetto figura in un secondo momento. Ad esempio, potrei voler modificare le dimensioni dell'etichetta, aggiungere una griglia o eseguire altre elaborazioni. In un mondo perfetto, vorrei semplicemente rieseguire il codice che genera la trama e adattare le impostazioni. Purtroppo il mondo non è perfetto. Pertanto, oltre al salvataggio in PDF o PNG, aggiungo:

with open('some_file.pkl', "wb") as fp:
    pickle.dump(fig, fp, protocol=4)

In questo modo, in seguito posso caricare l'oggetto figura e manipolare le impostazioni come preferisco.

Scrivo anche lo stack con il codice sorgente e il locals()dizionario per ogni funzione / metodo nello stack, in modo da poter dire in seguito esattamente cosa ha generato la figura.

NB: fai attenzione, poiché a volte questo metodo genera file di grandi dimensioni.

import datetime
import numpy as np
from matplotlib.backends.backend_pdf import PdfPages
import matplotlib.pyplot as plt

# Create the PdfPages object to which we will save the pages:
# The with statement makes sure that the PdfPages object is closed properly at
# the end of the block, even if an Exception occurs.
with PdfPages('multipage_pdf.pdf') as pdf:
    plt.figure(figsize=(3, 3))
    plt.plot(range(7), [3, 1, 4, 1, 5, 9, 2], 'r-o')
    plt.title('Page One')
    pdf.savefig()  # saves the current figure into a pdf page
    plt.close()

    plt.rc('text', usetex=True)
    plt.figure(figsize=(8, 6))
    x = np.arange(0, 5, 0.1)
    plt.plot(x, np.sin(x), 'b-')
    plt.title('Page Two')
    pdf.savefig()
    plt.close()

    plt.rc('text', usetex=False)
    fig = plt.figure(figsize=(4, 5))
    plt.plot(x, x*x, 'ko')
    plt.title('Page Three')
    pdf.savefig(fig)  # or you can pass a Figure object to pdf.savefig
    plt.close()

    # We can also set the file's metadata via the PdfPages object:
    d = pdf.infodict()
    d['Title'] = 'Multipage PDF Example'
    d['Author'] = u'Jouni K. Sepp\xe4nen'
    d['Subject'] = 'How to create a multipage pdf file and set its metadata'
    d['Keywords'] = 'PdfPages multipage keywords author title subject'
    d['CreationDate'] = datetime.datetime(2009, 11, 13)
    d['ModDate'] = datetime.datetime.today()

Dopo aver utilizzato la trama () e altre funzioni per creare il contenuto desiderato, è possibile utilizzare una clausola come questa per selezionare tra la stampa sullo schermo o il file:

import matplotlib.pyplot as plt

fig = plt.figure(figsize=(4, 5))       # size in inches
# use plot(), etc. to create your plot.

# Pick one of the following lines to uncomment
# save_file = None
# save_file = os.path.join(your_directory, your_file_name)  

if save_file:
    plt.savefig(save_file)
    plt.close(fig)
else:
    plt.show()

Ho usato il seguente:

import matplotlib.pyplot as plt

p1 = plt.plot(dates, temp, 'r-', label="Temperature (celsius)")  
p2 = plt.plot(dates, psal, 'b-', label="Salinity (psu)")  
plt.legend(loc='upper center', numpoints=1, bbox_to_anchor=(0.5, -0.05),        ncol=2, fancybox=True, shadow=True)

plt.savefig('data.png')  
plt.show()  
f.close()
plt.close()

Ho trovato molto importante usare plt.show dopo aver salvato la figura, altrimenti non funzionerà. figura esportata in png

Puoi fare:

plt.show(hold=False)
plt.savefig('name.pdf')

e ricorda di lasciare che savefig finisca prima di chiudere il grafico della GUI. In questo modo puoi vedere l'immagine in anticipo.

In alternativa, puoi guardarlo con plt.show() Quindi chiudere la GUI ed eseguire nuovamente lo script, ma questa volta sostituirlo plt.show()con plt.savefig().

In alternativa, puoi usare

fig, ax = plt.figure(nrows=1, ncols=1)
plt.plot(...)
plt.show()
fig.savefig('out.pdf')

Se, come me, usi Spyder IDE, devi disabilitare la modalità interattiva con:

plt.ioff()

(questo comando viene avviato automaticamente con l'avvio scientifico)

Se si desidera abilitarlo di nuovo, utilizzare:

plt.ion()

La soluzione :

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.style.use('ggplot')
ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))
ts = ts.cumsum()
plt.figure()
ts.plot()
plt.savefig("foo.png", bbox_inches='tight')

Se si desidera visualizzare l'immagine e salvarla, utilizzare:

%matplotlib inline

dopo import matplotlib

Secondo la domanda Matplotlib (pyplot) savefig genera un'immagine vuota .

Una cosa dovrebbe notare: se si utilizza plt.showe dovrebbe dopoplt.savefig , o darai un'immagine vuota.

Un esempio dettagliato:

import numpy as np
import matplotlib.pyplot as plt


def draw_result(lst_iter, lst_loss, lst_acc, title):
    plt.plot(lst_iter, lst_loss, '-b', label='loss')
    plt.plot(lst_iter, lst_acc, '-r', label='accuracy')

    plt.xlabel("n iteration")
    plt.legend(loc='upper left')
    plt.title(title)
    plt.savefig(title+".png")  # should before plt.show method

    plt.show()


def test_draw():
    lst_iter = range(100)
    lst_loss = [0.01 * i + 0.01 * i ** 2 for i in xrange(100)]
    # lst_loss = np.random.randn(1, 100).reshape((100, ))
    lst_acc = [0.01 * i - 0.01 * i ** 2 for i in xrange(100)]
    # lst_acc = np.random.randn(1, 100).reshape((100, ))
    draw_result(lst_iter, lst_loss, lst_acc, "sgd_method")


if __name__ == '__main__':
    test_draw()

import matplotlib.pyplot as plt
plt.savefig("image.png")

In Jupyter Notebook devi rimuovere plt.show()e aggiungere plt.savefig(), insieme al resto del codice plt in una cella. L'immagine verrà comunque visualizzata sul tuo blocco note.

Dato che oggi (non era disponibile quando la questione è stata fatta) un sacco di persone usano Jupyter Notebook come console di pitone, c'è un modo estremamente semplice per salvare le trame come .png, basta chiamare il matplotlib's pylabclasse da Jupyter notebook, tracciare la figura' inline 'jupyter, quindi trascina quella figura / immagine in una directory locale. Non dimenticare %matplotlib inlinein prima linea!

Oltre a quelli sopra, ho aggiunto __file__il nome in modo che l'immagine e il file Python ottengano gli stessi nomi. Ho anche aggiunto alcuni argomenti per renderlo migliore:

# Saves a PNG file of the current graph to the folder and updates it every time
# (nameOfimage, dpi=(sizeOfimage),Keeps_Labels_From_Disappearing)
plt.savefig(__file__+".png",dpi=(250), bbox_inches='tight')
# Hard coded name: './test.png'

Quando si utilizza matplotlib.pyplot, è necessario prima salvare la trama e quindi chiuderla utilizzando queste 2 righe:

fig.savefig('plot.png') # save the plot, place the path you want to save the figure in quotation
plt.close(fig) # close the figure window

Come suggerito prima, puoi utilizzare:

import matplotlib.pyplot as plt
plt.savefig("myfig.png")

Per salvare qualsiasi immagine IPhython che stai visualizzando. O su una nota diversa (guardando da una prospettiva diversa), se mai dovessi lavorare con open cv o se hai importato open cv, puoi scegliere:

import cv2

cv2.imwrite ( "myfig.png", immagine)

Ma questo è nel caso in cui devi lavorare con Open CV. Altrimenti plt.savefig () dovrebbe essere sufficiente.

Puoi salvare la tua immagine con qualsiasi estensione (png, jpg, ecc.) E con la risoluzione che desideri. Ecco una funzione per salvare la tua figura.

import os

def save_fig(fig_id, tight_layout=True, fig_extension="png", resolution=300):
    path = os.path.join(IMAGES_PATH, fig_id + "." + fig_extension)
    print("Saving figure", fig_id)
    if tight_layout:
        plt.tight_layout()
    plt.savefig(path, format=fig_extension, dpi=resolution)

'fig_id' è il nome con cui vuoi salvare la tua figura. Spero che sia d'aiuto:)

Puoi farlo in questo modo:

def plotAFig():
  plt.figure()
  plt.plot(x,y,'b-')
  plt.savefig("figurename.png")
  plt.close()