Képfunkciók

A Nette\Utils\Image osztály leegyszerűsíti a képmanipulációt, például a méretváltoztatást, a képkivágást, az élesítést, a rajzolást vagy több kép összevonását.

A PHP széleskörű függvénykészlettel rendelkezik a képek manipulálásához. De az API nem túl szép. Nem lenne egy Neat Framework, ha egy szexi API-val állna elő.

Telepítés:

composer require nette/utils

A következő példák feltételezik, hogy a következő osztály alias van definiálva:

use Nette\Utils\Image;
use Nette\Utils\ImageColor;
use Nette\Utils\ImageType;

Kép létrehozása

Létrehozunk egy új színes képet, például 100×200-as méretben:

$image = Image::fromBlank(100, 200);

Opcionálisan megadhat egy háttérszínt (alapértelmezett a fekete):

$image = Image::fromBlank(100, 200, ImageColor::rgb(125, 0, 0));

Vagy betöltjük a képet egy fájlból:

$image = Image::fromFile('nette.jpg');

A kép mentése

A kép elmenthető egy fájlba:

$image->save('resampled.jpg');

A tömörítési minőséget a JPEG (alapértelmezett 85), WEBP (alapértelmezett 80) és AVIF (alapértelmezett 30) esetében 0..100, PNG (alapértelmezett 9) esetében pedig 0..9 tartományban adhatjuk meg:

$image->save('resampled.jpg', 80); // JPEG, minőség 80%

Ha a formátum nem egyértelmű a fájlkiterjesztésből, akkor konstanssal is megadható:

$image->save('resampled.tmp', null, ImageType::JPEG);

A képet lemez helyett egy változóba is ki lehet írni:

$data = $image->toString(ImageType::JPEG, 80); // JPEG, minőség 80%.

vagy közvetlenül a böngészőnek a megfelelő HTTP fejléccel Content-Type:

// fejlécet küld Content-Type: image/png
$image->send(ImageType::PNG);

Formátumok

Támogatott formátumok: JPEG, PNG, GIF, WebP, AVIF és BMP. Ezeket azonban a PHP verziójának is támogatnia kell, amit az isTypeSupported() függvény segítségével ellenőrizhet. Az animációk nem támogatottak.

A formátumokat a ImageType::JPEG, ImageType::PNG, ImageType::GIF, ImageType::WEBP, ImageType::AVIF és ImageType::BMP konstansok jelölik.

$supported = Image::isTypeSupported(ImageType::JPEG);

Fel kell ismernie egy kép formátumát betöltéskor? A módszer ezt a második paraméterben adja vissza:

$image = Image::fromFile('nette.jpg', $type);

A tényleges felismerést a kép betöltése nélkül a Image::detectTypeFromFile() végzi.

Kép átméretezése

Gyakori művelet a kép átméretezése. Az aktuális méreteket a getWidth() és a getHeight() metódusok adják vissza.

Az átméretezéshez a resize() módszer használható. Ez egy példa az arányos méretváltoztatásra úgy, hogy az nem haladja meg az 500×300 pixelt (vagy a szélesség lesz pontosan 500px, vagy a magasság lesz pontosan 300px, az egyik dimenzió a képarány megtartása érdekében kerül kiszámításra):

$image->resize(500, 300);

Lehetőség van arra, hogy csak egy dimenziót állítson be, és a második dimenzió kiszámításra kerül:

$image->resize(500, null); // szélesség 500px, magasság auto

$image->resize(null, 300); // szélesség auto, magasság 300px

Bármelyik dimenzió megadható százalékban:

$image->resize('75%', 300); // 75 % × 300px

A resize viselkedését a következő jelzőkkel lehet befolyásolni. A Image::Stretch kivételével mindegyik megőrzi a képarányt.

Zászló	Leírás
`Image::OrSmaller` (alapértelmezett)	a kapott méretek kisebbek vagy egyenlőek lesznek a megadottakkal.
`Image::OrBigger`	kitölti a célterületet, és esetleg egy irányba kiterjeszti azt.
`Image::Cover`	kitölti az egész területet, és kivágja a túlnyúló részt.
`Image::ShrinkOnly`	csak lefelé skálázódik (nem bővíti ki a kis képet)
`Image::Stretch`	nem tartja meg a képarányt.

A zászlók a függvény harmadik argumentumaként kerülnek átadásra:

$image->resize(500, 300, Image::OrBigger);

A zászlók kombinálhatók:

$image->resize(500, 300, Image::ShrinkOnly | Image::Stretch);

A képek függőlegesen vagy vízszintesen megfordíthatók az egyik dimenzió (vagy mindkettő) negatív számként történő megadásával:

$flipped = $image->resize(null, '-100%'); // Függőlegesen átfordítva

$flipped = $image->resize('-100%', '-100%'); // 180°-kal elforgatni

$flipped = $image->resize(-125, 500); // átméretezés és átfordítás vízszintesen

A kép kicsinyítése után élesítéssel javíthatunk rajta:

$image->sharpen();

Vágás

A crop() módszer a termesztésre szolgál:

$image->crop($left, $top, $width, $height);

A resize() oldalhoz hasonlóan minden érték százalékban is megadható. A $left és a $top százalékos értékeit a fennmaradó helyből számítják ki, hasonlóan a background-position CSS-tulajdonsághoz:

$image->crop('100%', '50%', '80%', '80%');

A képet automatikusan is lehet vágni, pl. fekete élek vágása:

$image->cropAuto(IMG_CROP_BLACK);

A cropAuto() metódus a imagecropauto() függvény objektumkapszulázása, további információkért lásd a dokumentációját.

Színek

A ImageColor::rgb() módszer lehetővé teszi a színek meghatározását a vörös, zöld és kék (RGB) értékek segítségével. Opcionálisan egy átlátszósági értéket is megadhat 0 (teljesen átlátszó) és 1 (teljesen átlátszatlan) között, akárcsak a CSS-ben.

$color = ImageColor::rgb(255, 0, 0); // Red
$transparentBlue = ImageColor::rgb(0, 0, 255, 0.5); // Semi-transparent blue

A ImageColor::hex() módszerrel a CSS-hez hasonlóan hexadecimális formátumban adhat meg egy színt. Támogatja a #rgb, #rrggbb, #rgba és #rrggbbaa formátumokat:

$color = ImageColor::hex("#F00"); // Red
$transparentGreen = ImageColor::hex("#00FF0080"); // Semi-transparent green

A színeket más módszerekben is lehet használni, mint például a ellipse(), fill(), stb.

Rajzolás és szerkesztés

Rajzolhatsz, írhatsz, használhatod az összes PHP függvényt a képmanipulációhoz, lásd: A módszerek áttekintése, de egy objektumorientált burkolatban:

$image->filledEllipse($centerX, $centerY, $width, $height, ImageColor::rgb(255, 0, 0));

Mivel a téglalapok rajzolására szolgáló PHP függvények a koordináták megadása miatt nem praktikusak, a Image osztály a rectangleWH() és a filledRectangleWH() függvények formájában helyettesíti őket.

Több kép egyesítése

Könnyedén elhelyezhet egy másik képet a képbe:

$logo = Image::fromFile('logo.png');
$blank = Image::fromBlank(320, 240, ImageColor::rgb(52, 132, 210));

// a koordináták százalékban is megadhatók
$blank->place($logo, '80%', '80%'); // közel a jobb alsó sarokhoz

Beillesztéskor az alfa-csatornát tiszteletben tartjuk, emellett befolyásolhatjuk a beillesztett kép átlátszóságát (ún. vízjelet hozunk létre):

$blank->place($image, '80%', '80%', 25); // az átlátszóság 25 %-os

Egy ilyen API-t tényleg öröm használni, nem igaz?

A módszerek áttekintése

static fromBlank(int $width, int $height, ImageColor $color=null): Image

Új, valós színű képet hoz létre a megadott méretekkel. Az alapértelmezett szín a fekete.

static fromFile(string $file, int &$detectedFormat=null): Image

Beolvas egy képet egy fájlból, és visszaadja a típusát a $detectedFormat címen.

static fromString(string $s, int &$detectedFormat=null): Image

Beolvas egy képet egy karakterláncból, és visszaadja a típusát a $detectedFormat címen.

static rgb(int $red, int $green, int $blue, int $transparency=0): array

Ezt a funkciót a ImageColor osztály váltotta fel, lásd a színeket.

static typeToExtension(int $type): string

Visszaadja az adott típushoz tartozó fájlkiterjesztést.

static typeToMimeType(int $type): string

Visszaadja az adott típus mime típusát.

static extensionToType(string $extension): int

Visszaadja a kép típusát a fájlkiterjesztésnek megfelelően.

static detectTypeFromFile(string $file, int &$width=null, int &$height=null): ?int

Visszaadja a képfájl típusát és a $width és $height paraméterekben a méreteit is.

static detectTypeFromString(string $s, int &$width=null, int &$height=null): ?int

Visszaadja a kép típusát a stringből és a $width és $height paraméterekben a méreteit is.

static isTypeSupported(int $type): bool

Megállapítja, hogy az adott képtípus támogatott-e.

static getSupportedTypes(): array

Visszaadja a támogatott képtípusok tömbjét (konstansok ImageType::XXX).

static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array

Kiszámítja a megadott betűtípusú és méretű szöveget körülvevő téglalap méreteit. Egy asszociatív tömböt ad vissza, amely a left, top, width, height kulcsokat tartalmazza. A bal oldali margó negatív lehet, ha a szöveg bal oldali túlnyúlással kezdődik.

affine(array $affine, array $clip=null): Image

Visszaad egy képet, amely az affin transzformált src képet tartalmazza, egy opcionális vágási terület használatával. (tovább).

affineMatrixConcat(array $m1, array $m2): array

Két affin transzformációs mátrix összekapcsolását adja vissza, ami akkor hasznos, ha több transzformációt kell alkalmazni ugyanarra a képre egy menetben. (tovább)

affineMatrixGet(int $type, mixed $options=null): array

Visszaad egy affin transzformációs mátrixot. (tovább)

alphaBlending(bool $on): void

Két különböző rajzolási módot tesz lehetővé a truecolor képeken. Keverési módban az összes rajzolási funkcióhoz, például a setPixel() oldalhoz megadott szín alfa-csatorna komponense határozza meg, hogy az alapszínből mennyi látszódjon át. Ennek eredményeképpen a program automatikusan összekeveri az adott ponton meglévő színt a rajz színével, és az eredményt a képen tárolja. Az eredményül kapott képpont átlátszatlan. Nem keverési módban a rajz színe szó szerint az alfacsatorna információival együtt másolódik, és a célpixel helyébe lép. A palettás képekre való rajzoláskor a blending mód nem érhető el. (tovább)

antialias(bool $on): void

Aktiválja a gyors rajzolás antializált módszereit a vonalak és a vezetékes sokszögek esetében. Nem támogatja az alfa komponenseket. Közvetlen keverési művelettel működik. Csak színhű képekkel működik.

Az antialiased primitívek átlátszó háttérszínnel történő használata nem várt eredményekkel járhat. A keverési módszer a háttérszínt ugyanúgy használja, mint bármely más színt. Az alfa komponens támogatás hiánya nem teszi lehetővé az alfa alapú antialiasing módszert. (tovább)

arc(int $centerX, int $centerY, int $width, int $height, int $startAngle, int $endAngle, ImageColor $color): void

A megadott koordináták középpontjában lévő körív rajzolása. (tovább)

colorAllocate(int $red, int $green, int $blue): int

Visszaad egy színazonosítót, amely a megadott RGB-komponensekből álló színt reprezentálja. Minden egyes, a képen használni kívánt szín létrehozásához meg kell hívni. (tovább)

colorAllocateAlpha(int $red, int $green, int $blue, int $alpha): int

Ugyanúgy viselkedik, mint a colorAllocate(), kiegészítve a $alpha átlátszósági paraméterrel. (tovább)

colorAt(int $x, int $y): int

Visszaadja a kép megadott helyén lévő pixel színének indexét. Ha a kép valódi színű kép, ez a függvény egész számként adja vissza az adott pixel RGB-értékét. A biteltolás és a maszkolás segítségével hozzáférhet a különböző piros, zöld és kék komponens értékekhez: (tovább)

colorClosest(int $red, int $green, int $blue): int

Visszaadja a kép palettáján annak a színnek az indexét, amelyik a legközelebb áll a megadott RGB-értékhez. A kívánt szín és a paletta egyes színei közötti “távolság” úgy kerül kiszámításra, mintha az RGB-értékek a háromdimenziós tér pontjai lennének. (tovább)

colorClosestAlpha(int $red, int $green, int $blue, int $alpha): int

Visszaadja a kép palettáján annak a színnek az indexét, amelyik a legközelebb áll a megadott RGB-értékhez és a $alpha szinthez. (tovább)

colorClosestHWB(int $red, int $green, int $blue): int

Annak a színnek az indexét kapja meg, amelynek árnyalata, fehérsége és feketesége a legközelebb áll az adott színhez. (tovább)

colorDeallocate(int $color): void

Feloldja a korábban a colorAllocate() vagy a colorAllocateAlpha() segítségével kiosztott színt. (tovább)

colorExact(int $red, int $green, int $blue): int

Visszaadja a megadott szín indexét a kép palettáján. (tovább)

colorExactAlpha(int $red, int $green, int $blue, int $alpha): int

Visszaadja a megadott szín+alfa indexét a kép palettáján. (tovább)

colorMatch(Image $image2): void

A kép palettás változatának színei jobban megfelelnek a valódi színváltozatnak. (tovább)

colorResolve(int $red, int $green, int $blue): int

Visszaadja a kért szín szín indexét, vagy a pontos színt, vagy a legközelebbi lehetséges alternatívát. (tovább)

colorResolveAlpha(int $red, int $green, int $blue, int $alpha): int

Visszaadja a kért szín szín indexét, vagy a pontos színt, vagy a legközelebbi lehetséges alternatívát. (tovább)

colorSet(int $index, int $red, int $green, int $blue): void

Ez a palettán a megadott indexet a megadott színre állítja. (tovább)

colorsForIndex(int $index): array

Megkapja a színt egy megadott indexhez. (tovább)

colorsTotal(): int

Visszaadja a színek számát egy képpalettán (more).

colorTransparent(int $color=null): int

A kép átlátszó színének lekérdezése vagy beállítása. (tovább)

convolution(array $matrix, float $div, float $offset): void

Egy konvolúciós mátrixot alkalmaz a képre a megadott együttható és eltolás segítségével. (tovább)

Igényli a Bundled GD kiterjesztést, így nem biztos, hogy mindenhol működik.

copy(Image $src, int $dstX, int $dstY, int $srcX, int $srcY, int $srcW, int $srcH): void

A $src egy részét a $srcX, $srcY koordinátáknál kezdődő képre másolja a $srcW szélességű és $srcH magasságú képre. A meghatározott rész a koordinátákra, a $dstX és a $dstY koordinátákra lesz másolva. (tovább)

copyMerge(Image $src, int $dstX, int $dstY, int $srcX, int $srcY, int $srcW, int $srcH, int $opacity): void

copyMergeGray(Image $src, int $dstX, int $dstY, int $srcX, int $srcY, int $srcW, int $srcH, int $opacity): void

Ez a funkció megegyezik a copyMerge() funkcióval, azzal a különbséggel, hogy az összevonás során megőrzi a forrás színárnyalatát azáltal, hogy a célpixeleket a másolási művelet előtt szürkeárnyalatúvá alakítja. (tovább)

copyResampled(Image $src, int $dstX, int $dstY, int $srcX, int $srcY, int $dstW, int $dstH, int $srcW, int $srcH): void

Egy kép téglalap alakú részét átmásolja egy másik képre, simán interpolálva a pixelértékeket, így különösen a kép méretének csökkentése esetén továbbra is nagyfokú tisztaságot biztosít.

Más szóval, a copyResampled() a $src egy téglalap alakú területet vesz a $srcW szélességű és a $srcH magasságú -ből a ($srcX,$srcY) pozícióban, és elhelyezi a kép egy téglalap alakú, $dstW szélességű és a $dstH magasságú$dstX,$dstY) pozícióban lévő téglalap alakú területébe.

Ha a forrás- és a célkoordináták, valamint a szélesség és a magasság eltér, a képfragmentum megfelelő nyújtása vagy zsugorítása történik. A koordináták a bal felső sarokra vonatkoznak. Ez a funkció használható ugyanazon a képen belüli régiók másolására, de ha a régiók átfedik egymást, az eredmény kiszámíthatatlan lesz. (tovább)

copyResized(Image $src, int $dstX, int $dstY, int $srcX, int $srcY, int $dstW, int $dstH, int $srcW, int $srcH): void

Egy kép téglalap alakú részét másolja át egy másik képre. Más szóval, a copyResized() a $src egy téglalap alakú területet vesz a $srcW szélességű és a $srcH magasságú -ből a ($srcX,$srcY) pozícióban, és elhelyezi a kép egy téglalap alakú, $dstW szélességű és a $dstH magasságú$dstX,$dstY) pozícióban lévő téglalap alakú területébe.

crop(int|string $left, int|string $top, int|string $width, int|string $height): Image

A képet a megadott téglalap alakú területre vágja. A méretek átadhatók egész számokként pixelben vagy karakterláncokként százalékban (pl. '50%').

cropAuto(int $mode=-1, float $threshold=.5, ?ImageColor $color=null): Image

Automatikusan levágja a képet a megadott $mode címnek megfelelően. (tovább)

ellipse(int $centerX, int $centerY, int $width, int $height, ImageColor $color): void

Egy ellipszist rajzol a megadott koordináták középpontjába. (tovább)

fill(int $x, int $y, ImageColor $color): void

A megadott koordinátánál (balra fent 0, 0) kezdődő áradásos kitöltést hajt végre a megadott $color címen a képen. (tovább)

filledArc(int $centerX, int $centerY, int $width, int $height, int $startAngle, int $endAngle, ImageColor $color, int $style): void

Egy részleges ívet rajzol, amelynek középpontja a kép megadott koordinátája. (tovább)

filledEllipse(int $centerX, int $centerY, int $width, int $height, ImageColor $color): void

Egy ellipszist rajzol, amelynek középpontja a kép megadott koordinátája. (tovább)

filledPolygon(array $points, ImageColor $color): void

Egy kitöltött sokszöget hoz létre a $image-ben. (tovább)

filledRectangle(int $x1, int $y1, int $x2, int $y2, ImageColor $color): void

Egy téglalapot hoz létre a képen a $color címmel, amely a $x1 és a $y1 címen kezdődik és a $x2 és a $y2 címen végződik. 0, 0 pont a kép bal felső sarka. (tovább)

filledRectangleWH(int $left, int $top, int $width, int $height, ImageColor $color): void

Létrehoz egy téglalapot, amely a $color képen a $left és a $top pontból kiindulva $width szélességű és $height magasságú téglalapot hoz létre. A 0,0 pont a kép bal felső sarka.

fillToBorder(int $x, int $y, int $border, ImageColor $color): void

Olyan áradásos kitöltést végez, amelynek határszínét a $border határozza meg. A kitöltés kezdőpontja a $x, $y (balra fent 0, 0), és a régiót a $color színnel töltjük ki. (tovább)

filter(int $filtertype, int …$args): void

A megadott $filtertype szűrőt alkalmazza a képre. (tovább)

flip(int $mode): void

Megfordítja a képet a megadott $mode segítségével. (tovább)

ftText(float $size, float $angle, int $x, int $y, ImageColor $color, string $fontFile, string $text, array $options=[]): array

Írja a képen látható szöveget. (tovább)

gammaCorrect(float $inputgamma, float $outputgamma): void

Gammakorrekciót alkalmaz a képre egy bemeneti és egy kimeneti gamma megadásával. (tovább)

getClip(): array

Az aktuális vágási téglalap, azaz az a terület, amelyen túl nem rajzolunk pixeleket. (tovább)

getHeight(): int

Visszaadja a kép magasságát.

getImageResource(): resource|GdImage

Visszaadja az eredeti erőforrást.

getWidth(): int

Visszaadja a kép szélességét.

interlace(int $interlace=null): int

Be- vagy kikapcsolja az interlace bitet. Ha az interlace bit be van állítva, és a képet JPEG-ként használják, a kép progresszív JPEG-ként jön létre. (tovább)

isTrueColor(): bool

Megállapítja, hogy a kép színhű-e. (tovább)

layerEffect(int $effect): void

Állítsa be az alpha blending flaget a réteghatások használatához. (tovább)

line(int $x1, int $y1, int $x2, int $y2, ImageColor $color): void

Vonalat húz a két megadott pont közé. (tovább)

openPolygon(array $points, ImageColor $color): void

Egy nyitott sokszöget rajzol a képre. A polygon() címmel ellentétben az utolsó és az első pont között nem húzódik vonal. (tovább)

paletteCopy(Image $source): void

A palettát a $source oldalról átmásolja a képre. (tovább)

paletteToTrueColor(): void

Az olyan funkciókkal létrehozott paletta alapú képet, mint a create(), valódi színű képpé alakítja, mint a createtruecolor(). (tovább)

place(Image $image, int|string $left=0, int|string $top=0, int $opacity=100): Image

Másolja a $image címet a képre a $left és a $top koordinátáknál. A koordináták átadhatók egész számokként pixelben vagy karakterláncokként százalékban (pl. '50%').

polygon(array $points, ImageColor $color): void

Egy sokszöget hoz létre a képen. (tovább)

rectangle(int $x1, int $y1, int $x2, int $y2, ImageColor $color): void

A megadott koordinátáknál kezdődő téglalapot hoz létre. (tovább)

rectangleWH(int $left, int $top, int $width, int $height, ImageColor $color): void

Egy téglalapot hoz létre a megadott koordinátákon.

resize(int|string $width, int|string $height, int $flags=Image::OrSmaller): Image

Méretezi a képet, további információk. A méretek átadhatók egész számokként pixelben vagy karakterláncokként százalékban (pl. '50%').

resolution(int $resX=null, int $resY=null): mixed

Lehetővé teszi a kép felbontásának beállítását és lekérdezését DPI-ben (dots per inch). Ha az opcionális paraméterek egyike sincs megadva, az aktuális felbontás indexelt tömbként kerül visszaadásra. Ha csak a $resX értéket adja meg, a vízszintes és függőleges felbontás erre az értékre kerül beállításra. Ha mindkét opcionális paramétert megadjuk, a vízszintes és függőleges felbontás ezekre az értékekre kerül beállításra.

A felbontást csak akkor használjuk meta információként, amikor a képeket az ilyen információt támogató formátumokból olvassuk be és írjuk ki (jelenleg PNG és JPEG). Ez nem befolyásolja a rajzolási műveleteket. Az új képek alapértelmezett felbontása 96 DPI. (tovább)

rotate(float $angle, int $backgroundColor): Image

Elforgatja a képet a megadott $angle értékkel fokban. Az elforgatás középpontja a kép középpontja, és az elforgatott kép mérete eltérhet az eredeti képtől. (tovább)

Igényli a Bundled GD kiterjesztést, így nem biztos, hogy mindenhol működik.

save(string $file, int $quality=null, int $type=null): void

Kép mentése egy fájlba.

A tömörítési minőség a JPEG (alapértelmezett 85), WEBP (alapértelmezett 80) és AVIF (alapértelmezett 30) esetében 0..100, PNG (alapértelmezett 9) esetében 0..9 tartományban van. Ha a típus nem egyértelmű a fájlkiterjesztésből, akkor a ImageType konstansok egyikével adhatja meg.

saveAlpha(bool $saveflag): void

Beállítja azt a jelzőt, amely meghatározza, hogy a PNG-képek mentésekor megmaradjon-e a teljes alfa-csatorna információ (szemben az egyszínű átlátszósággal).

Az alfacsatorna megtartásához az alfacsatornát ki kell kapcsolni (alphaBlending(false)). (tovább)

scale(int $newWidth, int $newHeight=-1, int $mode=IMG_BILINEAR_FIXED): Image

A megadott interpolációs algoritmus segítségével méretezi a képet. (tovább)

send(int $type=ImageType::JPEG, int $quality=null): void

Kimeneti egy képet a böngészőbe.

A tömörítési minőség a JPEG (alapértelmezett 85), WEBP (alapértelmezett 80) és AVIF (alapértelmezett 30) esetében 0..100, PNG (alapértelmezett 9) esetében 0..9 tartományban van.

setBrush(Image $brush): void

Beállítja az ecsetképet, amelyet az összes vonalrajzoló funkció (például a line() és a polygon()) használ, amikor az IMG_COLOR_BRUSHED vagy IMG_COLOR_STYLEDBRUSHED speciális színekkel rajzol. (tovább)

setClip(int $x1, int $y1, int $x2, int $y2): void

Beállítja az aktuális vágási téglalapot, azaz azt a területet, amelyen túl nem rajzolunk pixeleket. (tovább)

setInterpolation(int $method=IMG_BILINEAR_FIXED): void

Beállítja az interpolációs módszert, amely hatással van a rotate() és a affine() módszerekre. (tovább)

setPixel(int $x, int $y, ImageColor $color): void

Egy pixelt rajzol a megadott koordinátára. (tovább)

setStyle(array $style): void

Beállítja az IMG_COLOR_STYLED speciális színnel vagy IMG_COLOR_STYLEDBRUSHED színű képek vonalainak rajzolásakor az összes vonalrajzoló funkció (például line() és polygon()) által használt stílust. (tovább)

setThickness(int $thickness): void

A téglalapok, sokszögek, ívek stb. rajzolásakor rajzolt vonalak vastagságát a $thickness pixelre állítja be. (tovább)

setTile(Image $tile): void

Beállítja a csempeképet, amelyet az összes régiókitöltő funkció (például a fill() és a filledPolygon()) az IMG_COLOR_TILED speciális színnel való kitöltéskor használ.

A csempe egy olyan kép, amelyet egy terület ismétlődő mintával való kitöltésére használnak. Bármilyen kép használható csempeként, és a csempekép átlátszó színindexének a colorTransparent() segítségével történő beállításával olyan csempe hozható létre, amely lehetővé teszi az alapterület bizonyos részeinek átvilágítását. (tovább)

sharpen(): Image

Egy kicsit élesíti a képet.

Igényli a Bundled GD kiterjesztést, így nem biztos, hogy mindenhol működik.

toString(int $type=ImageType::JPEG, int $quality=null): string

Kimeneti képet ad ki stringként.

A tömörítési minőség a JPEG (alapértelmezett 85), WEBP (alapértelmezett 80) és AVIF (alapértelmezett 30) esetében 0..100, PNG (alapértelmezett 9) esetében 0..9 tartományban van.

trueColorToPalette(bool $dither, int $ncolors): void

Egy valódi színű képet palettaképpé alakít át. (tovább)

ttfText(float $size, float $angle, int $x, int $y, ImageColor $color, string $fontFile, string $text, array $options=[]): array

A megadott szöveget írja a képbe. (tovább)