Matplotlib-Diagramme: Entfernen von Achsen, Legenden und Leerzeichen

Ich bin neu in Python und Matplotlib. Ich möchte einfach eine Farbkarte auf ein Bild anwenden und das resultierende Bild schreiben, ohne Achsen, Beschriftungen, Titel oder irgendetwas zu verwenden, das normalerweise automatisch von matplotlib hinzugefügt wird. Folgendes habe ich getan:

def make_image(inputname,outputname):
    data = mpimg.imread(inputname)[:,:,0]
    fig = plt.imshow(data)
    fig.set_cmap('hot')
    fig.axes.get_xaxis().set_visible(False)
    fig.axes.get_yaxis().set_visible(False)
    plt.savefig(outputname)

Die Achse der Figur wird erfolgreich entfernt, aber die gespeicherte Figur zeigt eine weiße Polsterung und einen Rahmen um das eigentliche Bild. Wie kann ich sie entfernen (zumindest die weiße Polsterung)? Vielen Dank

Ich denke, dass der Befehl axis('off')eines der Probleme prägnanter behandelt, als jede Achse und den Rand separat zu ändern. Es bleibt jedoch immer noch der weiße Raum um die Grenze. Wenn Sie bbox_inches='tight'den savefigBefehl hinzufügen, gelangen Sie fast dorthin. Im folgenden Beispiel sehen Sie, dass der verbleibende Leerraum viel kleiner ist, aber immer noch vorhanden ist.

Beachten Sie, dass neuere Versionen von matplotlib möglicherweise bbox_inches=0anstelle der Zeichenfolge erforderlich sind 'tight'(über @episodeyang und @kadrach).

from numpy import random
import matplotlib.pyplot as plt

data = random.random((5,5))
img = plt.imshow(data, interpolation='nearest')
img.set_cmap('hot')
plt.axis('off')
plt.savefig("test.png", bbox_inches='tight')

Diesen Trick habe ich hier von matehat gelernt :

import matplotlib.pyplot as plt
import numpy as np

def make_image(data, outputname, size=(1, 1), dpi=80):
    fig = plt.figure()
    fig.set_size_inches(size)
    ax = plt.Axes(fig, [0., 0., 1., 1.])
    ax.set_axis_off()
    fig.add_axes(ax)
    plt.set_cmap('hot')
    ax.imshow(data, aspect='equal')
    plt.savefig(outputname, dpi=dpi)

# data = mpimg.imread(inputname)[:,:,0]
data = np.arange(1,10).reshape((3, 3))

make_image(data, '/tmp/out.png')

ergibt

Mögliche einfachste Lösung:

Ich habe einfach die in der Frage beschriebene Methode und die Methode aus der Antwort von Hooked kombiniert.

fig = plt.imshow(my_data)
plt.axis('off')
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
plt.savefig('pict.png', bbox_inches='tight', pad_inches = 0)

Nach diesem Code gibt es keine Leerzeichen und keinen Frame.

imsaveNoch niemand erwähnt , was dies zu einem Einzeiler macht:

import matplotlib.pyplot as plt
import numpy as np

data = np.arange(10000).reshape((100, 100))
plt.imsave("/tmp/foo.png", data, format="png", cmap="hot")

Das Bild wird direkt so gespeichert, wie es ist, dh es werden keine Achsen oder Rahmen / Auffüllungen hinzugefügt.

Sie können auch den Umfang der Abbildung für das bbox_inchesArgument angeben . Dies würde die weiße Polsterung um die Figur herum beseitigen.

def make_image(inputname,outputname):
    data = mpimg.imread(inputname)[:,:,0]
    fig = plt.imshow(data)
    fig.set_cmap('hot')
    ax = fig.gca()
    ax.set_axis_off()
    ax.autoscale(False)
    extent = ax.get_window_extent().transformed(plt.gcf().dpi_scale_trans.inverted())
    plt.savefig(outputname, bbox_inches=extent)

Dies sollte alle Polster und Ränder entfernen:

from matplotlib import pyplot as plt

fig = plt.figure()
fig.patch.set_visible(False)

ax = fig.add_subplot(111)

plt.axis('off')
plt.imshow(data)

extent = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
plt.savefig("../images/test.png", bbox_inches=extent)

Ich fand, dass alles dokumentiert ist ...

https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.axes.Axes.axis.html#matplotlib.axes.Axes.axis

Mein Code…. "bcK" ist ein 512 x 512 Bild

plt.figure()
plt.imshow(bck)
plt.axis("off")   # turns off axes
plt.axis("tight")  # gets rid of white border
plt.axis("image")  # square up the image instead of filling the "figure" space
plt.show()

Ich mochte die Antwort von Ubuntu , aber sie zeigte nicht explizit, wie die Größe für nicht quadratische Bilder sofort eingestellt werden kann. Deshalb habe ich sie für einfaches Kopieren und Einfügen geändert:

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

def save_image_fix_dpi(data, dpi=100):
    shape=np.shape(data)[0:2][::-1]
    size = [float(i)/dpi for i in shape]

    fig = plt.figure()
    fig.set_size_inches(size)
    ax = plt.Axes(fig,[0,0,1,1])
    ax.set_axis_off()
    fig.add_axes(ax)
    ax.imshow(data)
    fig.savefig('out.png', dpi=dpi)
    plt.show()

Das Speichern von Bildern ohne Rahmen ist unabhängig von der gewählten Auflösung einfach, wenn pixel_size / dpi = size beibehalten wird.

data = mpimg.imread('test.png')
save_image_fix_dpi(data, dpi=100)

Die Anzeige ist jedoch gruselig. Wenn Sie eine kleine Auflösung wählen, kann Ihre Bildgröße größer als Ihr Bildschirm sein und Sie erhalten während der Anzeige einen Rand. Dies hat jedoch keinen Einfluss auf das Speichern.

So für

save_image_fix_dpi(data, dpi=20)

Die Anzeige wird eingefasst (aber das Speichern funktioniert):

Die optimierte Antwort funktioniert nicht mehr. Damit es funktioniert, müssen Sie manuell eine Achse hinzufügen, die auf [0, 0, 1, 1] eingestellt ist, oder den Patch unter der Abbildung entfernen.

import matplotlib.pyplot as plt

fig = plt.figure(figsize=(5, 5), dpi=20)
ax = plt.Axes(fig, [0., 0., 1., 1.])
fig.add_axes(ax)
plt.imshow([[0, 1], [0.5, 0]], interpolation="nearest")
plt.axis('off')                                # same as: ax.set_axis_off()

plt.savefig("test.png")

Alternativ können Sie den Patch auch einfach entfernen. Sie müssen keine Nebenhandlung hinzufügen, um die Auffüllungen zu entfernen. Dies wird durch die Antwort von Vlady unten vereinfacht

fig = plt.figure(figsize=(5, 5))
fig.patch.set_visible(False)                   # turn off the patch

plt.imshow([[0, 1], [0.5, 0]], interpolation="nearest")
plt.axis('off')

plt.savefig("test.png", cmap='hot')

Dies wird mit der Version 3.0.3am 19.06.2019 getestet . Bild siehe unten:

Eine viel einfachere Sache ist die Verwendung pyplot.imsave. Für Details, Sie in der Antwort von luator unten

Erstens für bestimmte Bildformate (z. B. TIFF) ) die Farbkarte tatsächlich in der Kopfzeile speichern, und die meisten Betrachter zeigen Ihre Daten mit der Farbkarte an.

Zum Speichern eines tatsächlichen matplotlibBildes, das zum Hinzufügen von Anmerkungen oder anderen Daten zu Bildern hilfreich sein kann, habe ich die folgende Lösung verwendet:

fig, ax = plt.subplots(figsize=inches)
ax.matshow(data)  # or you can use also imshow
# add annotations or anything else
# The code below essentially moves your plot so that the upper
# left hand corner coincides with the upper left hand corner
# of the artist
fig.subplots_adjust(left=0, right=1, top=1, bottom=0, wspace=0, hspace=0)
# now generate a Bbox instance that is the same size as your
# single axis size (this bbox will only encompass your figure)
bbox = matplotlib.transforms.Bbox(((0, 0), inches))
# now you can save only the part of the figure with data
fig.savefig(savename, bbox_inches=bbox, **kwargs)

Vielen Dank für die tollen Antworten von allen ... Ich hatte genau das gleiche Problem damit, nur ein Bild ohne zusätzliche Polsterung / Platz usw. zeichnen zu wollen, also war ich super glücklich, hier alle Ideen zu finden.

Abgesehen von Bildern ohne Auffüllung wollte ich auch einfach Anmerkungen usw. hinzufügen können, die über ein einfaches Bilddiagramm hinausgehen.

Am Ende kombinierte ich Davids Antwort mit der von csnemes, um zur Zeit der Figurenerstellung einen einfachen Wrapper zu erstellen . Wenn Sie das verwenden, brauchen Sie später keine Änderungen mit imsave () oder irgendetwas anderem:

def get_img_figure(image, dpi):
    """
    Create a matplotlib (figure,axes) for an image (numpy array) setup so that
        a) axes will span the entire figure (when saved no whitespace)
        b) when saved the figure will have the same x/y resolution as the array, 
           with the dpi value you pass in.

    Arguments:
        image -- numpy 2d array
        dpi -- dpi value that the figure should use

    Returns: (figure, ax) tuple from plt.subplots
    """

    # get required figure size in inches (reversed row/column order)
    inches = image.shape[1]/dpi, image.shape[0]/dpi

    # make figure with that size and a single axes
    fig, ax = plt.subplots(figsize=inches, dpi=dpi)

    # move axes to span entire figure area
    fig.subplots_adjust(left=0, right=1, top=1, bottom=0, wspace=0, hspace=0)

    return fig, ax