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;

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, Image::rgb(125, 0, 0));

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

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

Fel kell ismernie a képformátumot betöltéskor? A módszer a formátumot adja vissza a második paraméterben:

$image = Image::fromFile('nette.jpg', $type);
// $típusa Image::JPEG, Image::PNG, Image::GIF, Image::WEBP vagy Image::BMP

A terhelés nélküli észlelést a Image::detectTypeFromFile() végezheti.

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) és WEBP (alapértelmezett 80) 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 a Image::JPEG, Image::PNG, Image::GIF, Image::WEBP és Image::BMP konstansok egyikével adhatja meg:

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

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

$data = $image->toString(Image::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(Image::PNG);

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.

Rajzolás és szerkesztés

Rajzolhatsz, írhatsz, használhatod az összes PHP függvényt a képekkel való munkához, mint például az imagefilledellipse(), de objektum stílusban:

$image->filledEllipse($cx, $cy, $width, $height, Image::rgb(255, 0, 0, 63));

Lásd a módszerek áttekintését.

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, Image::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, array $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. A támogatott típusok: Image::JPEG, Image::PNG, Image::GIF, Image::WEBP és Image::BMP.

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. A támogatott típusok: Image::JPEG, Image::PNG, Image::GIF, Image::WEBP és Image::BMP.

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

Létrehoz egy színt, amely más módszerekben, például a ellipse(), fill(), stb. használható.

static typeToExtension(int $type): string

Visszaadja az adott Image::XXX konstans fájlkiterjesztését.

static typeToMimeType(int $type): string

Visszaadja a megadott Image::XXX konstans mime típusát.

static extensionToType(string $extension): int

Visszaadja a kép típusát a Image::XXX konstansként 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 a Image::XXX konstansként, valamint 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 a Image::XXX konstansként, és a $width és $height paraméterekben a méreteit is.

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 $x, int $y, int $w, int $h, int $start, int $end, int $color): void

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

char(int $font, int $x, int $y, string $char, int $color): void

A $char első karakterét a képen a $x,$y (a bal felső rész 0, 0) színnel rajzolja meg a $color színnel a első karakterét. (tovább)

charUp(int $font, int $x, int $y, string $char, int $color): void

A $char karaktert függőlegesen rajzolja a megadott koordinátán a megadott képen. (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, int $color=-1): Image

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

ellipse(int $cx, int $cy, int $w, int $h, int $color): void

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

fill(int $x, int $y, int $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 $cx, int $cy, int $w, int $h, int $s, int $e, int $color, int $style): void

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

filledEllipse(int $cx, int $cy, int $w, int $h, int $color): void

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

filledPolygon(array $points, int $numPoints, int $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, int $color): void

Egy téglalapot hoz létre a képen a $color címmel, amely az 1. pontban kezdődik és a 2. pontban végződik. 0, 0 a kép bal felső sarka. (tovább)

fillToBorder(int $x, int $y, int $border, int $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(int $size, int $angle, int $x, int $y, int $col, string $fontFile, string $text, array $extrainfo=null): array

Írjon szöveget a képre a FreeType 2 betűtípusok segítségével. (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, int $color): void

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

openPolygon(array $points, int $numPoints, int $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, int $numPoints, int $color): void

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

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

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

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) és a WEBP (alapértelmezett 80) esetében 0..100, a PNG (alapértelmezett 9) esetében pedig 0..9 tartományban van. Ha a típus nem egyértelmű a fájlkiterjesztésből, akkor a Image::JPEG, Image::PNG, Image::GIF, Image::WEBP és Image::BMP konstansok valamelyiké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=Image::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) és a WEBP (alapértelmezett 80) esetében 0..100, a PNG (alapértelmezett 9) esetében pedig 0..9 tartományban van. A típus a Image::JPEG, Image::PNG, Image::GIF, Image::WEBP és Image::BMP konstansok egyike.

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, int $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.

string(int $font, int $x, int $y, string $str, int $col): void

Egy karakterláncot rajzol a megadott koordinátákhoz. (tovább)

stringUp(int $font, int $x, int $y, string $s, int $col): void

Egy sztringet rajzol függőlegesen a megadott koordinátákhoz. (tovább)

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

Kimeneti képet ad ki stringként.

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

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

ttfText(int $size, int $angle, int $x, int $y, int $color, string $fontfile, string $text): array

A megadott szöveget TrueType betűtípusok használatával írja a képbe. (tovább)