Wykresy Matplotlib: usuwanie osi, legend i białych znaków

Jestem nowy w Pythonie i Matplotlib, chciałbym po prostu zastosować mapę kolorów do obrazu i napisać obraz wynikowy, bez używania osi, etykiet, tytułów lub czegokolwiek zwykle automatycznie dodawanego przez matplotlib. Oto co zrobiłem:

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)

Z powodzeniem usuwa oś figury, ale zapisana figura przedstawia białe wypełnienie i ramkę wokół rzeczywistego obrazu. Jak mogę je usunąć (przynajmniej białe wypełnienie)? Dzięki

Myślę, że polecenie axis('off')zajmuje się jednym z problemów bardziej zwięźle niż osobna zmiana każdej osi i granicy. Jednak nadal pozostawia biały obszar wokół granicy. Dodanie bbox_inches='tight'do savefigpolecenia prawie Cię tam prowadzi, możesz zobaczyć w poniższym przykładzie, że biała przestrzeń po lewej jest znacznie mniejsza, ale wciąż obecna.

Zauważ, że nowsze wersje matplotlib mogą wymagać bbox_inches=0zamiast ciągu znaków 'tight'(przez @episodeyang i @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')

Nauczyłem się tej sztuczki od matehat, tutaj :

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')

daje

Możliwe najprostsze rozwiązanie:

Po prostu połączyłem metodę opisaną w pytaniu i metodę z odpowiedzi Hooked.

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)

Po tym kodzie nie ma białych znaków ani ramki.

Nikt imsavejeszcze o tym nie wspominał , co sprawia, że ​​jest to jeden liniowiec:

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")

Bezpośrednio przechowuje obraz takim, jaki jest, tzn. Nie dodaje żadnych osi ani obramowania / wypełnienia.

Możesz także określić zakres liczby dla bbox_inchesargumentu. Pozbyłoby się to białej wyściółki wokół postaci.

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)

To powinno usunąć wszystkie wypełnienia i obramowania:

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)

Odkryłem, że wszystko jest udokumentowane ...

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

Mój kod… „bcK” to obraz o wymiarach 512 x 512

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()

Pozytywna odpowiedź już nie działa. Aby to zadziałało, musisz ręcznie dodać zestaw osi do [0, 0, 1, 1] lub usunąć łatkę pod rysunkiem.

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")

Możesz też po prostu usunąć łatkę. Nie trzeba dodawać wątku podrzędnego, aby usunąć wypełnienia. Upraszcza to poniższa odpowiedź Vlady

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')

Zostało to przetestowane w wersji 3.0.32019/06/19. Zdjęcie patrz poniżej:

Znacznie prostszą rzeczą jest użycie pyplot.imsave. Aby uzyskać szczegółowe informacje, patrz odpowiedź luatora poniżej

Podobała mi się odpowiedź ubuntu , ale nie pokazywała wyraźnie, jak ustawić rozmiar niekwadratowych obrazów od razu po wyjęciu z pudełka, więc zmodyfikowałem go, aby łatwo skopiować i wkleić:

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()

Zapisywanie obrazów bez obramowania jest łatwe bez względu na wybraną rozdzielczość, jeśli zachowany jest rozmiar piksela / dpi = rozmiar.

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

Jednak wyświetlanie jest upiorne. Jeśli wybierzesz małą rozdzielczość, rozmiar obrazu może być większy niż ekran, a ramka będzie wyświetlana podczas wyświetlania. Niemniej jednak nie wpływa to na oszczędzanie.

Więc dla

save_image_fix_dpi(data, dpi=20)

Wyświetlacz zostaje otoczony (ale zapisywanie działa):

Po pierwsze, w przypadku niektórych formatów obrazów (np. TIFF ) można faktycznie zapisać mapę kolorów w nagłówku, a większość przeglądających wyświetli dane za pomocą mapy kolorów.

Do zapisania rzeczywistego matplotlibobrazu, który może być przydatny do dodawania adnotacji lub innych danych do obrazów, zastosowałem następujące rozwiązanie:

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)

Dzięki za niesamowite odpowiedzi od wszystkich ... Miałem dokładnie ten sam problem z chęcią wykreślenia obrazu bez dodatkowej wypełnienia / miejsca itp., Więc byłem bardzo szczęśliwy, że znalazłem tutaj pomysły wszystkich.

Oprócz obrazu bez wypełnienia, chciałem również móc łatwo dodawać adnotacje itp., Poza prostą fabułą.

Skończyło się na tym, że połączyłem odpowiedź Davida z csnemes ', by stworzyć proste opakowanie w momencie tworzenia postaci. Kiedy tego użyjesz, nie potrzebujesz później żadnych zmian za pomocą imsave () lub czegokolwiek innego:

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