Hoe verander je de grootte van figuren getekend met Matplotlib?

Hoe verander je de grootte van een figuur getekend met Matplotlib?


Antwoord 1, autoriteit 100%

figure vertelt u de roepnaam:

from matplotlib.pyplot import figure
figure(figsize=(8, 6), dpi=80)

figure(figsize=(1,1)) zou een inch-by-inch afbeelding maken, die 80 bij 80 pixels zou zijn, tenzij je ook een ander dpi-argument opgeeft.figure(figsize=(1,1))


Antwoord 2, autoriteit 63%

Als je het figuur al hebt gemaakt, kun je dit snel doen:

fig = matplotlib.pyplot.gcf()
fig.set_size_inches(18.5, 10.5)
fig.savefig('test2png.png', dpi=100)

Als u de wijziging van de grootte wilt doorgeven aan een bestaand GUI-venster, voegt u forward=True toe:

fig.set_size_inches(18.5, 10.5, forward=True)

Antwoord 3, autoriteit 34%

Plt.rcParams gebruiken

Er is ook deze oplossing voor het geval u de grootte wilt wijzigen zonder de afbeeldingsomgeving te gebruiken. Dus voor het geval u plt.plot() u kunt bijvoorbeeld een tuple instellen met breedte en hoogte.

import matplotlib.pyplot as plt
plt.rcParams["figure.figsize"] = (20,3)

Dit is erg handig wanneer u inline plotten (bijvoorbeeld met IPython Notebook). Zoals asmaier opmerkte, het verdient de voorkeur om deze verklaring niet in dezelfde cel van de invoerverklaringen te plaatsen.

Om de globale figuurgrootte terug te zetten naar de standaardwaarde voor volgende plots:

plt.rcParams["figure.figsize"] = plt.rcParamsDefault["figure.figsize"]

Conversie naar cm

Het figsize tupel accepteert inches, dus als je het in centimeters wilt instellen, moet je ze delen door 2,54. Bekijk deze vraag.


Antwoord 4, autoriteit 29%

Opmerking over beëindiging:
Volgens de officiële Matplotlib-gids, wordt het gebruik van de module pylab niet langer aanbevolen. Overweeg in plaats daarvan de module matplotlib.pyplot te gebruiken, zoals beschreven in dit andere antwoord.

Het volgende lijkt te werken:

from pylab import rcParams
rcParams['figure.figsize'] = 5, 10

Dit maakt de breedte van de figuur 5 inch en de hoogte 10 inch.

De klasse Figure gebruikt dit vervolgens als de standaardwaarde voor een van zijn argumenten.


Antwoord 5, autoriteit 25%

Probeer een eenvoudige code als volgt:

from matplotlib import pyplot as plt
plt.figure(figsize=(1,1))
x = [1,2,3]
plt.plot(x, x)
plt.show()

U moet de figuurgrootte instellen voordat u gaat plotten.


Antwoord 6, autoriteit 10%

Als u op zoek bent naar een manier om de grootte van het figuur in Panda’s te wijzigen, kunt u bijvoorbeeld het volgende doen:

df['some_column'].plot(figsize=(10, 5))

waarbij df een Pandas-dataframe is. Of, om een ​​bestaande figuur of assen te gebruiken:

fig, ax = plt.subplots(figsize=(10, 5))
df['some_column'].plot(ax=ax)

Als u de standaardinstellingen wilt wijzigen, kunt u het volgende doen:

import matplotlib
matplotlib.rc('figure', figsize=(10, 5))

Antwoord 7, autoriteit 6%

De eerste link in Google voor 'matplotlib figure size' is AdjustingImageSize (Google-cache van de pagina).

Hier is een testscript van de bovenstaande pagina. Het maakt test[1-3].png-bestanden van verschillende groottes van dezelfde afbeelding:

#!/usr/bin/env python
"""
This is a small demo file that helps teach how to adjust figure sizes
for matplotlib
"""
import matplotlib
print "using MPL version:", matplotlib.__version__
matplotlib.use("WXAgg") # do this before pylab so you don'tget the default back end.
import pylab
import numpy as np
# Generate and plot some simple data:
x = np.arange(0, 2*np.pi, 0.1)
y = np.sin(x)
pylab.plot(x,y)
F = pylab.gcf()
# Now check everything with the defaults:
DPI = F.get_dpi()
print "DPI:", DPI
DefaultSize = F.get_size_inches()
print "Default size in Inches", DefaultSize
print "Which should result in a %i x %i Image"%(DPI*DefaultSize[0], DPI*DefaultSize[1])
# the default is 100dpi for savefig:
F.savefig("test1.png")
# this gives me a 797 x 566 pixel image, which is about 100 DPI
# Now make the image twice as big, while keeping the fonts and all the
# same size
F.set_size_inches( (DefaultSize[0]*2, DefaultSize[1]*2) )
Size = F.get_size_inches()
print "Size in Inches", Size
F.savefig("test2.png")
# this results in a 1595x1132 image
# Now make the image twice as big, making all the fonts and lines
# bigger too.
F.set_size_inches( DefaultSize )# resetthe size
Size = F.get_size_inches()
print "Size in Inches", Size
F.savefig("test3.png", dpi = (200)) # change the dpi
# this also results in a 1595x1132 image, but the fonts are larger.

Uitvoer:

using MPL version: 0.98.1
DPI: 80
Default size in Inches [ 8.  6.]
Which should result in a 640 x 480 Image
Size in Inches [ 16.  12.]
Size in Inches [ 16.  12.]

Twee opmerkingen:

  1. De opmerkingen van de module en de daadwerkelijke output verschillen.

  2. Met dit antwoord kunt u eenvoudig alle drie de afbeeldingen in één afbeeldingsbestand combineren om het verschil in grootte te zien.


Antwoord 8, autoriteit 5%

import matplotlib.pyplot as plt
plt.figure(figsize=(20,10))
plt.plot(x,y) ## This is your plot
plt.show()

U kunt ook het volgende gebruiken:

fig, ax = plt.subplots(figsize=(20, 10))

Antwoord 9, autoriteit 4%

Je kunt gewoon (van matplotlib.figure.Figuur) :

fig.set_size_inches(width,height)

Vanaf Matplotlib 2.0.0 zijn wijzigingen aan uw canvas onmiddellijk zichtbaar, als het forward trefwoord standaard ingesteld op True.

Als je gewoon wijzig de breedte of hoogte in plaats van beide, u kunt

gebruiken

fig.set_figwidth(val) of fig.set_figheight(val)

Deze zullen je canvas ook onmiddellijk bijwerken, maar alleen in Matplotlib 2.2.0 en nieuwer.

Voor oudere versies

Je moet forward=True expliciet specificeren om je canvas live bij te werken in versies die ouder zijn dan wat hierboven is gespecificeerd. Merk op dat de functies set_figwidth en set_figheight de parameter forward niet ondersteunen in versies ouder dan Matplotlib 1.5.0.


Antwoord 10, autoriteit 3%

Probeer commentaar te geven op de regel fig = ...

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
N = 50
x = np.random.rand(N)
y = np.random.rand(N)
area = np.pi * (15 * np.random.rand(N))**2
fig = plt.figure(figsize=(18, 18))
plt.scatter(x, y, s=area, alpha=0.5)
plt.show()

Antwoord 11, autoriteit 3%

Dit werkt goed voor mij:

from matplotlib import pyplot as plt
F = plt.gcf()
Size = F.get_size_inches()
F.set_size_inches(Size[0]*2, Size[1]*2, forward=True) # Set forward to True to resize window along with plot in figure.
plt.show() # Or plt.imshow(z_array) if using an animation, where z_array is a matrix or NumPy array

Dit forumbericht kan ook helpen: Formaat wijzigen figuurvensters


Antwoord 12

Om je figuur N keer te vergroten, moet je dit invoegen net voor je pl.show():

N = 2
params = pl.gcf()
plSize = params.get_size_inches()
params.set_size_inches((plSize[0]*N, plSize[1]*N))

Het werkt ook goed met een IPython-notebook.


Antwoord 13

Algemeen en vereenvoudigen psihodelia’s antwoord:

Als je de huidige grootte van het figuur met een factor sizefactor wilt veranderen:

import matplotlib.pyplot as plt
# Here goes your code
fig_size = plt.gcf().get_size_inches() # Get current size
sizefactor = 0.8 # Set a zoom factor
# Modify the current size by the factor
plt.gcf().set_size_inches(sizefactor * fig_size) 

Na het wijzigen van de huidige grootte kan het voorkomen dat u de subplotlay-out moet verfijnen. U kunt dat doen in de GUI van het figuurvenster, of door middel van het commando subplots_adjust

Bijvoorbeeld

plt.subplots_adjust(left=0.16, bottom=0.19, top=0.82)

Antwoord 14

Aangezien Matplotlib niet in staat is om het metrische systeem native te gebruiken, als je wilt om de grootte van uw figuur in een redelijke lengte-eenheid zoals centimeters te specificeren, kunt u het volgende doen (code van gns-ank):

def cm2inch(*tupl):
    inch = 2.54
    if isinstance(tupl[0], tuple):
        return tuple(i/inch for i in tupl[0])
    else:
        return tuple(i/inch for i in tupl)

Dan kun je het volgende gebruiken:

plt.figure(figsize=cm2inch(21, 29.7))

Antwoord 15

Vergelijking van verschillende benaderingen om exacte afbeeldingsformaten in pixels in te stellen

Dit antwoord gaat over:

  • savefig
  • grootte instellen in pixels

Hier is een snelle vergelijking van enkele van de benaderingen die ik heb geprobeerd met afbeeldingen die laten zien wat het geeft.

Basisvoorbeeld zonder te proberen de afmetingen van de afbeelding in te stellen

Gewoon om een ​​vergelijkingspunt te hebben:

base.py

#!/usr/bin/env python3
import sys
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
fig, ax = plt.subplots()
print('fig.dpi = {}'.format(fig.dpi))
print('fig.get_size_inches() = ' + str(fig.get_size_inches())
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(0., 60., 'Hello', fontdict=dict(size=25))
plt.savefig('base.png', format='png')

rennen:

./base.py
identify base.png

uitgangen:

fig.dpi = 100.0
fig.get_size_inches() = [6.4 4.8]
base.png PNG 640x480 640x480+0+0 8-bit sRGB 13064B 0.000u 0:00.000

voer hier de afbeeldingsbeschrijving in

Mijn beste aanpak tot nu toe: plt.savefig(dpi=h/fig.get_size_inches()[1] alleen hoogteregeling

Ik denk dat ik dit meestal zal gebruiken, omdat het eenvoudig is en schaalbaar is:

get_size.py

#!/usr/bin/env python3
import sys
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
height = int(sys.argv[1])
fig, ax = plt.subplots()
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(0., 60., 'Hello', fontdict=dict(size=25))
plt.savefig(
    'get_size.png',
    format='png',
    dpi=height/fig.get_size_inches()[1]
)

rennen:

./get_size.py 431

uitgangen:

get_size.png PNG 574x431 574x431+0+0 8-bit sRGB 10058B 0.000u 0:00.000

voer hier de afbeeldingsbeschrijving in

en

./get_size.py 1293

uitgangen:

main.png PNG 1724x1293 1724x1293+0+0 8-bit sRGB 46709B 0.000u 0:00.000

voer hier de afbeeldingsbeschrijving in

Ik heb de neiging om alleen de hoogte in te stellen, omdat ik me meestal zorgen maak over hoeveel verticale ruimte de afbeelding in het midden van mijn tekst inneemt.

plt.savefig(bbox_inches='tight' verandert de afbeeldingsgrootte

Ik heb altijd het gevoel dat er te veel witruimte is rond afbeeldingen en had de neiging om bbox_inches='tight' toe te voegen van:
Witruimte rond een opgeslagen afbeelding in matplotlib verwijderen

Dat werkt echter door de afbeelding bij te snijden en u krijgt er niet de gewenste formaten bij.

In plaats daarvan lijkt deze andere benadering die in dezelfde vraag wordt voorgesteld goed te werken:

plt.tight_layout(pad=1)
plt.savefig(...

wat de exacte gewenste hoogte geeft voor hoogte is gelijk aan 431:

voer hier de afbeeldingsbeschrijving in

Vaste hoogte, set_aspect, automatisch formaat van breedte en kleine marges

Ermmm, set_aspect gooit de boel weer in de war en voorkomt dat plt.tight_layout de marges daadwerkelijk verwijdert…

Gevraagd op: Hoe krijg ik een vaste hoogte in pixels, een vaste gegevens x/y-beeldverhouding en verwijder automatisch de horizontale witruimtemarge in Matplotlib?

plt.savefig(dpi=h/fig.get_size_inches()[1] + breedteregeling

Als je echt een specifieke breedte nodig hebt naast de hoogte, lijkt dit goed te werken:

breedte.py

#!/usr/bin/env python3
import sys
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
h = int(sys.argv[1])
w = int(sys.argv[2])
fig, ax = plt.subplots()
wi, hi = fig.get_size_inches()
fig.set_size_inches(hi*(w/h), hi)
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(0., 60., 'Hello', fontdict=dict(size=25))
plt.savefig(
    'width.png',
    format='png',
    dpi=h/hi
)

rennen:

./width.py 431 869

uitvoer:

width.png PNG 869x431 869x431+0+0 8-bit sRGB 10965B 0.000u 0:00.000

voer hier de afbeeldingsbeschrijving in

en voor een kleine breedte:

./width.py 431 869

uitvoer:

width.png PNG 211x431 211x431+0+0 8-bit sRGB 6949B 0.000u 0:00.000

voer hier de afbeeldingsbeschrijving in

Dus het lijkt erop dat lettertypen correct worden geschaald, we krijgen alleen wat problemen voor zeer kleine breedtes waarbij labels worden afgesneden, b.v. de 100 links bovenaan.

Ik heb die kunnen omzeilen met Witruimte verwijderen rond een opgeslagen afbeelding in matplotlib

plt.tight_layout(pad=1)

wat geeft:

width.png PNG 211x431 211x431+0+0 8-bit sRGB 7134B 0.000u 0:00.000

voer hier de afbeeldingsbeschrijving in

Hieruit zien we ook dat tight_layout veel van de lege ruimte bovenaan de afbeelding verwijdert, dus ik gebruik het over het algemeen altijd.

Vaste magische basishoogte, dpi op fig.set_size_inches en plt.savefig(dpi= schaling

Ik geloof dat dit equivalent is aan de aanpak die wordt genoemd op: https://stackoverflow.com/a/13714720/895245

magic.py

#!/usr/bin/env python3
import sys
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
magic_height = 300
w = int(sys.argv[1])
h = int(sys.argv[2])
dpi = 80
fig, ax = plt.subplots(dpi=dpi)
fig.set_size_inches(magic_height*w/(h*dpi), magic_height/dpi)
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(0., 60., 'Hello', fontdict=dict(size=25))
plt.savefig(
    'magic.png',
    format='png',
    dpi=h/magic_height*dpi,
)

rennen:

./magic.py 431 231

uitgangen:

magic.png PNG 431x231 431x231+0+0 8-bit sRGB 7923B 0.000u 0:00.000

voer hier de afbeeldingsbeschrijving in

En om te zien of het mooi schaalt:

./magic.py 1291 693

uitgangen:

magic.png PNG 1291x693 1291x693+0+0 8-bit sRGB 25013B 0.000u 0:00.000

voer hier de afbeeldingsbeschrijving in

We zien dus dat deze aanpak ook goed werkt. Het enige probleem dat ik ermee heb, is dat je die magic_height-parameter of equivalent moet instellen.

Vaste DPI + set_size_inches

Deze aanpak gaf een enigszins verkeerde pixelgrootte en het is moeilijk om alles naadloos te schalen.

set_size_inches.py

#!/usr/bin/env python3
import sys
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
w = int(sys.argv[1])
h = int(sys.argv[2])
fig, ax = plt.subplots()
fig.set_size_inches(w/fig.dpi, h/fig.dpi)
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(
    0,
    60.,
    'Hello',
    # Keep font size fixed independently of DPI.
    # https://stackoverflow.com/questions/39395616/matplotlib-change-figsize-but-keep-fontsize-constant
    fontdict=dict(size=10*h/fig.dpi),
)
plt.savefig(
    'set_size_inches.png',
    format='png',
)

rennen:

./set_size_inches.py 431 231

uitgangen:

set_size_inches.png PNG 430x231 430x231+0+0 8-bit sRGB 8078B 0.000u 0:00.000

dus de hoogte is iets afwijkend, en de afbeelding:

voer hier de afbeeldingsbeschrijving in

De pixelgroottes zijn ook correct als ik het 3 keer groter maak:

./set_size_inches.py 1291 693

uitgangen:

set_size_inches.png PNG 1291x693 1291x693+0+0 8-bit sRGB 19798B 0.000u 0:00.000

voer hier de afbeeldingsbeschrijving in

Hieruit begrijpen we echter dat om deze benadering goed te schalen, je elke DPI-afhankelijke instelling evenredig moet maken aan de grootte in inches.

In het vorige voorbeeld hebben we alleen de "Hallo" tekst proportioneel, en het behield zijn hoogte tussen 60 en 80 zoals we zouden verwachten. Maar alles waarvoor we dat niet hebben gedaan, ziet er klein uit, inclusief:

  • lijnbreedte van assen
  • labels aanvinken
  • puntmarkeringen

SVG

Ik kon niet vinden hoe ik het voor SVG-afbeeldingen moest instellen, mijn aanpak werkte alleen voor PNG, bijvoorbeeld:

get_size_svg.py

#!/usr/bin/env python3
import sys
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
height = int(sys.argv[1])
fig, ax = plt.subplots()
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(0., 60., 'Hello', fontdict=dict(size=25))
plt.savefig(
    'get_size_svg.svg',
    format='svg',
    dpi=height/fig.get_size_inches()[1]
)

rennen:

./get_size_svg.py 431

en de gegenereerde output bevat:

<svg height="345.6pt" version="1.1" viewBox="0 0 460.8 345.6" width="460.8pt"

en identificeren zegt:

get_size_svg.svg SVG 614x461 614x461+0+0 8-bit sRGB 17094B 0.000u 0:00.000

en als ik het in Chromium 86 open, bevestigen de browser debug tools muis afbeelding hover die hoogte als 460.79.

Maar aangezien SVG een vectorformaat is, zou alles in theorie moeten schalen, dus je kunt het gewoon converteren naar elk formaat met een vast formaat zonder verlies van resolutie, bijvoorbeeld:

inkscape -h 431 get_size_svg.svg -b FFF -e get_size_svg.png

geeft de exacte hoogte:

voer hier de afbeeldingsbeschrijving in

Ik gebruik Inkscape in plaats van Imagemagick’s convert hier omdat je ook moet knoeien met -density om scherpe SVG-groottes te krijgen met ImageMagick:

En het instellen van <img height="" in de HTML zou ook gewoon moeten werken voor de browser.

Getest op matplotlib==3.2.2.


Antwoord 16

Dit verkleint de afbeelding onmiddellijk, zelfs nadat de afbeelding is getekend (tenminste met Qt4Agg/TkAgg – maar niet met Mac OS X – met Matplotlib 1.4.0):

matplotlib.pyplot.get_current_fig_manager().resize(width_px, height_px)

Antwoord 17

Gebruik dit:

plt.figure(figsize=(width,height))

De width en height zijn in inches.
Indien niet opgegeven, is het standaard rcParams["figure.figsize"] = [6.4, 4.8]. Zie hier.


Antwoord 18

Het volgende zal zeker werken, maar zorg ervoor dat je de regel plt.figure(figsize=(20,10)) toevoegt boven plt.plot(x,y), plt.pie(), enz.

import matplotlib.pyplot as plt
plt.figure(figsize=(20,10))
plt.plot(x,y) ## This is your plot
plt.show()

De code is gekopieerd van amalik2205.


Antwoord 19

Een andere optie is om de functie rc() in Matplotlib te gebruiken (de eenheid is inch):

import matplotlib
matplotlib.rc('figure', figsize=[10,5])

Antwoord 20

Als je een nieuw figuur maakt, kun je de grootte (in inches) specificeren met de figsize argument:

import matplotlib.pyplot as plt
fig = plt.figure(figsize=(w,h))

Als je een bestaand figuur wilt wijzigen, gebruik dan de set_size_inches() methode:

fig.set_size_inches(w,h)

Als u de standaard-figuurgrootte (6,4" x 4,8") wilt wijzigen, gebruikt u "opdrachten uitvoeren" rc:

plt.rc('figure', figsize=(w,h))

Antwoord 21

Zo heb ik mijn aangepaste grafiek met aangepast formaat afgedrukt

import matplotlib.pyplot as plt
from matplotlib.pyplot import figure
figure(figsize=(16, 8), dpi=80)
plt.plot(x_test, color = 'red', label = 'Predicted Price')
plt.plot(y_test, color = 'blue', label = 'Actual Price')
plt.title('Dollar to PKR Prediction')
plt.xlabel('Predicted Price')
plt.ylabel('Actual Dollar Price')
plt.legend()
plt.show()

Antwoord 22

Ik gebruik altijd het volgende patroon:

x_inches = 150*(1/25.4)     # [mm]*constant
y_inches = x_inches*(0.8)
dpi = 96
fig = plt.figure(1, figsize = (x_inches,y_inches), dpi = dpi, constrained_layout = True)

Met dit voorbeeld kunt u de afmetingen van figuren in inches of in millimeters instellen. Als je constrained_layout instelt op True, vullen plots je figuur zonder grenzen.

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes