0 dní v řadě · 0 bodů

Užitečné knihovny · 25 min

Pillow: úprava obrázků

Ořízneš, zmenšíš, otočíš a složíš obrázky kódem, pochopíš pixely, režimy a formáty a zpracuješ celou složku fotek naráz.

Hloubka
Úkoly
Lidsky řečeno

Digitální obrázek je mozaika z malých kachliček. Každá kachlička má jednu barvu a svoje místo. Pillow je parta obkladačů: řekneš „uřízni tenhle kus“, „zmenši to na polovinu“ nebo „nalep sem logo“ a oni to udělají na tisíci fotkách, zatímco ty piješ kávu.

Obrázek je mřížka čísel

Jedné kachličce se říká pixel. Pozice pixelu se zapisuje jako dvojice (x, y): x roste doprava a y dolů, počátek je v levém horním rohu. To je opak grafu ze školy.

text
        x →
        0   1   2   3   4
y  0  (0,0)
↓  1          (1,1)
   2                      (4,2)

Knihovna se instaluje pod jménem pillow, ale importuje se jako PIL. Je to pozůstatek po starší knihovně Python Imaging Library, na kterou Pillow navázal.

bash
pip install pillow

Nemusíš mít žádný soubor. Obrázek vytvoříš přímo v paměti a můžeš se ho vyptávat.

from PIL import Image

img = Image.new("RGB", (4, 3), "white")

print(img.size)
print(img.width, img.height)
print(img.mode)
print(img.getpixel((0, 0)))

img.putpixel((1, 2), (255, 0, 0))
print(img.getpixel((1, 2)))
Výstup
(4, 3)
4 3
RGB
(255, 255, 255)
(255, 0, 0)

Image.new dostane režim, rozměr a barvu. (255, 255, 255) je bílá: tři čísla od 0 do 255 říkají, kolik je v pixelu červené, zelené a modré. Tomu se říká RGB.

Tady na stránce obrázky nezobrazujeme, ale nevadí. Malý obrázek si můžeme vypsat jako text a každá operace pak bude vidět. Funkce ukaz tiskne # za rozsvícený pixel a tečku za černý. Režim "L" znamená odstíny šedi, kde má pixel jediné číslo.

from PIL import Image

def ukaz(img):
    for y in range(img.height):
        print("".join("#" if img.getpixel((x, y)) else "." for x in range(img.width)))

img = Image.new("L", (5, 3), 0)
for x, y in [(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)]:
    img.putpixel((x, y), 255)

ukaz(img)
Výstup
#....
#....
###..

Režimy a barvy

Režim říká, co znamená jeden pixel.

RežimPixelPoužití
RGBtři čísla 0 až 255běžné barevné fotky
RGBARGB a průhlednostloga, překryvy, PNG
Ljedno číslo 0 až 255odstíny šedi
1černá nebo bíláčistě dvoubarevné obrázky
Pindex do palety barevGIF, malé PNG

Mezi režimy převádí convert. Vrací nový obrázek a originál nechá být. Většina metod Pillow se chová stejně.

from PIL import Image

barvy = {"červená": (255, 0, 0), "zelená": (0, 255, 0), "modrá": (0, 0, 255)}

for nazev, rgb in barvy.items():
    img = Image.new("RGB", (1, 1), rgb)
    print(nazev, "->", img.convert("L").getpixel((0, 0)))

img = Image.new("RGB", (2, 1), (10, 20, 30))
cervena, zelena, modra = img.split()
print(cervena.mode, cervena.getpixel((0, 0)), modra.getpixel((1, 0)))

prehozeno = Image.merge("RGB", (modra, zelena, cervena))
print(prehozeno.getpixel((0, 0)))
Výstup
červená -> 76
zelená -> 150
modrá -> 29
L 10 30
(30, 20, 10)

Zelená vyšla ve stupních šedi nejsvětlejší, protože ji lidské oko vnímá jako nejjasnější. Převod na šedou proto není prostý průměr tří čísel.

Ořez, změna velikosti a otočení

crop dostane čtveřici (vlevo, nahoře, vpravo, dole). Pravý a dolní okraj se do výsledku nepočítají, stejně jako konec u řezu seznamu.

from PIL import Image

def ukaz(img):
    for y in range(img.height):
        print("".join("#" if img.getpixel((x, y)) else "." for x in range(img.width)))
    print()

img = Image.new("L", (5, 3), 0)
for x, y in [(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)]:
    img.putpixel((x, y), 255)

ukaz(img.crop((0, 1, 3, 3)))
ukaz(img.rotate(90, expand=True))
ukaz(img.transpose(Image.Transpose.FLIP_LEFT_RIGHT))
ukaz(img.resize((10, 3), Image.Resampling.NEAREST))
Výstup
#..
###

...
...
..#
..#
###

....#
....#
..###

##........
##........
######....

rotate otáčí proti směru hodinových ručiček. Bez expand=True by si obrázek nechal původní rozměr a rohy by se ořízly. resize naopak udělá přesně to, co mu řekneš, i kdyby výsledek vypadal roztaženě, jako v poslední ukázce.

Na běžné zmenšování fotek je proto lepší thumbnail. Zachová poměr stran a obrázek nikdy nezvětší. Má ale jednu zradu.

from PIL import Image

img = Image.new("RGB", (4000, 3000))
img.thumbnail((800, 800))
print(img.size)

mala = img.thumbnail((400, 400))
print(mala)
print(mala.size)
Výstup
(800, 600)
None

Když potřebuješ přesný rozměr, třeba čtvercové náhledy do galerie, pomůže ImageOps. Rozdíl je v tom, co se stane s přebývajícím místem.

from PIL import Image, ImageOps

foto = Image.new("RGB", (400, 200), "gray")

print("contain", ImageOps.contain(foto, (100, 100)).size)  # fits inside, keeps ratio
print("fit    ", ImageOps.fit(foto, (100, 100)).size)      # fills it, crops the rest
print("pad    ", ImageOps.pad(foto, (100, 100)).size)      # fits it, adds bars
Výstup
contain (100, 50)
fit     (100, 100)
pad     (100, 100)
Úkol

Čtverec ze středu

Doplň funkci stredovy_ctverec(img). Vrátí největší možný čtverec vyříznutý ze středu obrázku. Hrana čtverce je kratší ze stran.

from PIL import Image

def stredovy_ctverec(img):
    return img
Výstup
Úkol

Náhled bez poškození originálu

Doplň funkci nahled(img, maximum). Vrátí nový obrázek, jehož delší strana je nejvýš maximum a poměr stran zůstane stejný. Malý obrázek se nezvětšuje. Původní obrázek se nesmí změnit.

from PIL import Image

def nahled(img, maximum):
    return img.thumbnail((maximum, maximum))
Výstup

Kreslení a skládání

ImageDraw kreslí přímo do obrázku. A pozor na další nesoulad: u obdélníku je pravý dolní bod součástí kresby, kdežto u crop nebyl. getbbox vrátí rámeček kolem všeho, co není černé, a to ve stylu crop.

from PIL import Image, ImageDraw

def ukaz(img):
    for y in range(img.height):
        print("".join("#" if img.getpixel((x, y)) else "." for x in range(img.width)))

img = Image.new("L", (7, 4), 0)
kresba = ImageDraw.Draw(img)
kresba.rectangle((1, 1, 3, 2), fill=255)
kresba.line((5, 0, 5, 3), fill=255)

ukaz(img)
print(img.crop((0, 0, 4, 4)).getbbox())
Výstup
.....#.
.###.#.
.###.#.
.....#.
(1, 1, 4, 3)

Text se kreslí přes kresba.text((x, y), "Ahoj", font=pismo, fill="white"). Písmo načteš přes ImageFont.truetype("cesta/k/pismu.ttf", 32). Soubor písma musí na počítači existovat, a proto si to vyzkoušej až u sebe.

Logo na fotku vloží paste. Třetí argument je maska, která určuje, jak moc je který pixel vidět. Průhledný obrázek je sám sobě maskou.

from PIL import Image

pozadi = Image.new("RGB", (4, 2), "white")
logo = Image.new("RGBA", (2, 2), (255, 0, 0, 128))

bez_masky = pozadi.copy()
bez_masky.paste(logo, (0, 0))
print(bez_masky.getpixel((0, 0)))

s_maskou = pozadi.copy()
s_maskou.paste(logo, (0, 0), logo)
print(s_maskou.getpixel((0, 0)))
print(s_maskou.getpixel((3, 0)))
Výstup
(255, 0, 0)
(255, 127, 127)
(255, 255, 255)

Bez masky Pillow pixely prostě přepsal a průhlednost zahodil. S maskou se poloprůhledná červená smíchala s bílou.

Hromadnou změnu všech pixelů obstará point, který dostane funkci pro jednu hodnotu. Rozmazání a další efekty najdeš v ImageFilter.

from PIL import Image, ImageFilter

img = Image.new("L", (5, 5), 0)
img.putpixel((2, 2), 255)

negativ = img.point(lambda v: 255 - v)
print(negativ.getpixel((0, 0)), negativ.getpixel((2, 2)))

rozmazany = img.filter(ImageFilter.BoxBlur(1))
print(rozmazany.getpixel((2, 2)), rozmazany.getpixel((1, 1)), rozmazany.getpixel((0, 0)))
Výstup
255 0
28 28 0

Při počítání barev se hodí getcolors. Vrátí dvojice (počet, barva). Má ale limit: při více než 256 různých barvách vrátí None, pokud mu nedáš vyšší maxcolors.

from PIL import Image

img = Image.new("RGB", (20, 20))
for x in range(20):
    for y in range(20):
        img.putpixel((x, y), (x, y, 0))

print(img.getcolors())
print(len(img.getcolors(maxcolors=img.width * img.height)))
Výstup
None
400
Úkol

Kolik je tam červené

Doplň funkci spocitej(img, barva). Vrátí počet pixelů přesně dané barvy. Musí fungovat i pro obrázek s velkým množstvím různých barev.

from PIL import Image

def spocitej(img, barva):
    return 0
Výstup

Soubory a formáty

Soubor se otevírá přes Image.open, ukládá přes save. Formát Pillow pozná z přípony. Na svém počítači tak zpracuješ celou složku pár řádky. Tenhle kód potřebuje tvoje fotky, takže ho spusť až doma.

python
from pathlib import Path
from PIL import Image, ImageOps

vstup = Path("fotky")
vystup = Path("web")
vystup.mkdir(exist_ok=True)

for cesta in vstup.glob("*.jpg"):
    with Image.open(cesta) as img:
        hotovo = ImageOps.exif_transpose(img).convert("RGB")
    hotovo.thumbnail((1600, 1600))
    hotovo.save(vystup / cesta.name, quality=85, optimize=True)
    print(cesta.name, hotovo.size)

Místo souboru na disku může posloužit BytesIO, tedy „soubor“ v paměti. Hodí se ve webových aplikacích a tady i pro pokus. Vyrobíme dva obrázky, šum a jednolitou plochu, a oba uložíme jako PNG i JPEG.

import random
from io import BytesIO
from PIL import Image, ImageChops

def uloz(img, fmt, **volby):
    soubor = BytesIO()
    img.save(soubor, fmt, **volby)
    return soubor.getvalue()

nahoda = random.Random(7)
obrazky = {
    "šum": Image.frombytes("L", (64, 64), nahoda.randbytes(64 * 64)),
    "plocha": Image.new("L", (64, 64), 200),
}

for nazev, img in obrazky.items():
    png = uloz(img, "PNG")
    jpeg = uloz(img, "JPEG", quality=75)
    print(nazev, "- menší soubor má", "PNG" if len(png) < len(jpeg) else "JPEG")

    z_png = Image.open(BytesIO(png))
    z_jpeg = Image.open(BytesIO(jpeg))
    print("  PNG beze změny:", ImageChops.difference(img, z_png).getbbox() is None)
    print("  JPEG beze změny:", ImageChops.difference(img, z_jpeg).getbbox() is None)
Výstup
šum - menší soubor má JPEG
  PNG beze změny: True
  JPEG beze změny: False
plocha - menší soubor má PNG
  PNG beze změny: True
  JPEG beze změny: True

PNG je bezeztrátový: co uložíš, to přečteš. Hodí se na loga, snímky obrazovky a grafiku s ostrými hranami. JPEG je ztrátový: zahodí detaily, které oko tolik nevnímá, a na fotkách tak ušetří hodně místa. Každé další uložení do JPEG kvalitu znovu trochu sníží, proto upravuj originál, ne předchozí výstup. WebP umí obojí a hodí se na web.

JPEG navíc neumí průhlednost. Tohle je jedna z nejčastějších chyb při práci s Pillow.

from io import BytesIO
from PIL import Image

logo = Image.new("RGBA", (2, 2), (255, 0, 0, 128))
logo.convert("RGB").save(BytesIO(), "JPEG")
print("Po převodu na RGB to jde.")

logo.save(BytesIO(), "JPEG")
Výstup
Po převodu na RGB to jde.

Pozor, convert("RGB") průhlednost jen zahodí a poloprůhledná červená zčervená úplně. Chceš-li výsledek jako na bílém papíře, vlož obrázek na bílé pozadí přes paste s maskou.

Telefony fotku často neotáčejí. Uloží ji tak, jak leží snímač, a do metadat EXIF připíšou, jak se má zobrazit. Prohlížeč to respektuje, Pillow sám ne. Bez exif_transpose ti tak z portrétu vznikne náhled ležící na boku.

from io import BytesIO
from PIL import Image, ImageOps

ORIENTATION = 0x0112

exif = Image.Exif()
exif[ORIENTATION] = 6  # "rotate 90 degrees clockwise to display"
soubor = BytesIO()
Image.new("RGB", (4, 2)).save(soubor, "JPEG", exif=exif)

foto = Image.open(BytesIO(soubor.getvalue()))
print(foto.size, foto.getexif().get(ORIENTATION))

opravena = ImageOps.exif_transpose(foto)
print(opravena.size, opravena.getexif().get(ORIENTATION))
Výstup
(4, 2) 6
(2, 4) None
Kvíz

Co obsahuje proměnná b po řádku b = img.thumbnail((100, 100))?

Kvíz

Kde je pixel (0, 2) v obrázku?

Pod kapotou · líné načítání, bomby a barvy

Líné otevírání. Image.open přečte jen hlavičku. Dekódování proběhne až při první potřebě, případně po load(). Rozměr tedy zjistíš levně i u obřího souboru a rozbitá data se projeví až později (ukázka níže). Soubor zůstává otevřený, dokud se pixely nenačtou, takže v dávkách používej with.

Dekompresní bomba. Malý PNG se může rozbalit na gigabajty. Image.MAX_IMAGE_PIXELS je ve výchozím stavu 89 478 485. Nad tímto limitem Pillow vydá DecompressionBombWarning, nad dvojnásobkem vyvolá DecompressionBombError. U nahrávek od uživatelů nejdřív zkontroluj img.size, povol jen očekávané formáty přes Image.open(f, formats=["JPEG", "PNG"]) a dekódování pouštěj s limitem paměti. Pillow má bohatou historii CVE v dekodérech, takže aktualizace nejsou volitelné.

Barevný prostor. resize počítá přímo s hodnotami sRGB, tedy v gama prostoru. U jemných vzorů a kontrastních hran proto vychází zmenšenina o něco tmavší než při výpočtu v lineárním světle. Profil ICC se při ukládání do JPEG neuchová sám: předej icc_profile=img.info.get("icc_profile"), jinak fotka z Display P3 vybledne.

Soukromí. save do JPEG bez parametru exif metadata nepřenese, včetně GPS. U veřejných nahrávek je to výhoda, jen nejdřív aplikuj exif_transpose.

Výkon. getpixel v cyklu je pomalý. Na hromadné výpočty použij point, ImageChops nebo numpy.asarray(img). Pozor na pořadí: NumPy má tvar (výška, šířka, kanály), Pillow size je (šířka, výška). U zmenšování velkých JPEG pomůže img.draft("RGB", cil) a parametr reducing_gap v resize a thumbnail.

from io import BytesIO
from PIL import Image

soubor = BytesIO()
Image.effect_noise((64, 64), 40).save(soubor, "PNG")
data = soubor.getvalue()

rozbity = Image.open(BytesIO(data[: len(data) // 2]))
print("Hlavička je v pořádku:", rozbity.size, rozbity.format)

try:
    rozbity.load()
except (OSError, SyntaxError):
    print("Chyba se ukázala až při načtení pixelů.")
Výstup
Hlavička je v pořádku: (64, 64) PNG
Chyba se ukázala až při načtení pixelů.

Vyzkoušej si: Co dělá úprava obrázku

Na malém vygenerovaném obrázku vyzkoušej jas, odstíny šedi, práh, převrácení a ořez a sleduj, jak se mění pixely.