Suppression d'espace blanc autour d'une image enregistrée dans matplotlib

J'ai besoin de prendre une image et de la sauvegarder après un certain processus. La figure semble correcte lorsque je l'affiche, mais après avoir sauvegardé la figure, j'ai obtenu un espace blanc autour de l'image enregistrée. J'ai essayé l' 'tight'option savefigméthode, cela n'a pas fonctionné non plus. Le code:

  import matplotlib.image as mpimg
  import matplotlib.pyplot as plt

  fig = plt.figure(1)
  img = mpimg.imread(path)
  plt.imshow(img)
  ax=fig.add_subplot(1,1,1)

  extent = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
  plt.savefig('1.png', bbox_inches=extent)

  plt.axis('off') 
  plt.show()

J'essaie de dessiner un graphique de base en utilisant NetworkX sur une figure et de l'enregistrer. Je me suis rendu compte que sans graphique, cela fonctionne, mais lors de l'ajout d'un graphique, j'obtiens un espace blanc autour de l'image enregistrée;

import matplotlib.image as mpimg
import matplotlib.pyplot as plt
import networkx as nx

G = nx.Graph()
G.add_node(1)
G.add_node(2)
G.add_node(3)
G.add_edge(1,3)
G.add_edge(1,2)
pos = {1:[100,120], 2:[200,300], 3:[50,75]}

fig = plt.figure(1)
img = mpimg.imread("C:\\images\\1.jpg")
plt.imshow(img)
ax=fig.add_subplot(1,1,1)

nx.draw(G, pos=pos)

extent = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
plt.savefig('1.png', bbox_inches = extent)

plt.axis('off') 
plt.show()

Je ne peux pas prétendre savoir exactement pourquoi ou comment ma «solution» fonctionne, mais c'est ce que j'ai dû faire lorsque je voulais tracer le contour de quelques sections de voilure - sans marges blanches - dans un fichier PDF. (Notez que j'ai utilisé matplotlib dans un notebook IPython, avec l'indicateur -pylab.)

plt.gca().set_axis_off()
plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0, 
            hspace = 0, wspace = 0)
plt.margins(0,0)
plt.gca().xaxis.set_major_locator(plt.NullLocator())
plt.gca().yaxis.set_major_locator(plt.NullLocator())
plt.savefig("filename.pdf", bbox_inches = 'tight',
    pad_inches = 0)

J'ai essayé de désactiver différentes parties de ceci, mais cela conduit toujours à une marge blanche quelque part. Vous pouvez même avoir modifié cela pour empêcher les lignes grasses proches des limites de la figure d'être rasées par le manque de marges.

Vous pouvez supprimer le remplissage des espaces blancs en définissant bbox_inches="tight"dans savefig:

plt.savefig("test.png",bbox_inches='tight')

Vous devrez mettre l'argument bbox_inchessous forme de chaîne, c'est peut-être pour cette raison que cela n'a pas fonctionné plus tôt pour vous.

Doublons possibles:

Graphiques Matplotlib: suppression des axes, des légendes et des espaces blancs

Comment définir les marges d'une figure matplotlib?

Réduisez les marges gauche et droite dans le tracé matplotlib

Après avoir essayé les réponses ci-dessus sans succès (et une multitude d'autres messages de pile), ce qui a finalement fonctionné pour moi était juste

plt.gca().set_axis_off()
plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0, 
            hspace = 0, wspace = 0)
plt.margins(0,0)
plt.savefig("myfig.pdf")

Il est important de noter que cela n'inclut pas les arguments bbox ou padding.

J'ai trouvé quelque chose d'Arvind Pereira ( http://robotics.usc.edu/~ampereir/wordpress/?p=626 ) et j'ai semblé fonctionner pour moi:

plt.savefig(filename, transparent = True, bbox_inches = 'tight', pad_inches = 0)

La fonction suivante incorpore la réponse de johannes ci-dessus. Je l'ai testé avec plt.figureet plt.subplots()avec plusieurs axes, et cela fonctionne bien.

def save(filepath, fig=None):
    '''Save the current image with no whitespace
    Example filepath: "myfig.png" or r"C:\myfig.pdf" 
    '''
    import matplotlib.pyplot as plt
    if not fig:
        fig = plt.gcf()

    plt.subplots_adjust(0,0,1,1,0,0)
    for ax in fig.axes:
        ax.axis('off')
        ax.margins(0,0)
        ax.xaxis.set_major_locator(plt.NullLocator())
        ax.yaxis.set_major_locator(plt.NullLocator())
    fig.savefig(filepath, pad_inches = 0, bbox_inches='tight')

J'ai trouvé que les codes suivants fonctionnent parfaitement pour le travail.

fig = plt.figure(figsize=[6,6])
ax = fig.add_subplot(111)
ax.imshow(data)
ax.axes.get_xaxis().set_visible(False)
ax.axes.get_yaxis().set_visible(False)
ax.set_frame_on(False)
plt.savefig('data.png', dpi=400, bbox_inches='tight',pad_inches=0)

J'ai suivi cette séquence et cela a fonctionné comme un charme.

plt.axis("off")
fig=plt.imshow(image array,interpolation='nearest')
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
plt.savefig('destination_path.pdf',
    bbox_inches='tight', pad_inches=0, format='pdf', dpi=1200)

Pour tous ceux qui souhaitent travailler en pixels plutôt qu'en pouces, cela fonctionnera.

De plus, vous aurez également besoin de l'habituel

from matplotlib.transforms import Bbox

Ensuite, vous pouvez utiliser ce qui suit:

my_dpi = 100 # Good default - doesn't really matter

# Size of output in pixels
h = 224
w = 224

fig, ax = plt.subplots(1, figsize=(w/my_dpi, h/my_dpi), dpi=my_dpi)

ax.set_position([0, 0, 1, 1]) # Critical!

# Do some stuff
ax.imshow(img)
ax.imshow(heatmap) # 4-channel RGBA
ax.plot([50, 100, 150], [50, 100, 150], color="red")

ax.axis("off")

fig.savefig("saved_img.png",
            bbox_inches=Bbox([[0, 0], [w/my_dpi, h/my_dpi]]),
            dpi=my_dpi)

Une approche beaucoup plus simple que j'ai trouvée consiste à utiliser plt.imsave:

    import matplotlib.pyplot as plt
    arr = plt.imread(path)
    plt.imsave('test.png', arr)

Vous pouvez essayer ceci. Cela a résolu mon problème.

import matplotlib.image as mpimg
img = mpimg.imread("src.png")
mpimg.imsave("out.png", img, cmap=cmap)

Cela a fonctionné pour moi plt.savefig(save_path,bbox_inches='tight', pad_inches=0, transparent=True)

Si vous souhaitez afficher ce qui doit être enregistré, je vous recommande d'utiliser la plt.tight_layouttransformation qui est en fait plus préférable car elle ne fait pas de recadrage inutile lors de l'utilisationplt.savefig

import matplotlib as plt    
plt.plot([1,2,3], [1,2,3])
plt.tight_layout(pad=0)
plt.savefig('plot.png')

Cela fonctionne pour moi en enregistrant un tableau numpy tracé avec imshow to file

import matplotlib.pyplot as plt

fig = plt.figure(figsize=(10,10))
plt.imshow(img) # your image here
plt.axis("off")
plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0, 
        hspace = 0, wspace = 0)
plt.savefig("example2.png", box_inches='tight', dpi=100)
plt.show()