Nette Documentation Preview

syntax
Funcții de imagine
******************

.[perex]
Clasa [api:Nette\Utils\Image] simplifică manipularea imaginilor, cum ar fi redimensionarea, decuparea, ascuțirea, desenarea sau fuzionarea mai multor imagini.


PHP dispune de un set extins de funcții pentru manipularea imaginilor. Dar API-ul nu este foarte frumos. Nu ar fi un cadru de lucru îngrijit pentru a veni cu un API sexy.

Instalare:

```shell
composer require nette/utils
```

Următoarele exemple presupun că este definit următorul alias de clasă:

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


Crearea unei imagini .[#toc-creating-an-image]
==============================================

Vom crea o nouă imagine în culori reale, de exemplu, cu dimensiunile de 100×200:

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

Opțional, puteți specifica o culoare de fundal (culoarea implicită este negru):

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

Sau încărcăm imaginea dintr-un fișier:

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


Salvați imaginea .[#toc-save-the-image]
=======================================

Imaginea poate fi salvată într-un fișier:

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

Putem specifica calitatea compresiei în intervalul 0..100 pentru JPEG (implicit 85), WEBP (implicit 80) și AVIF (implicit 30) și 0..9 pentru PNG (implicit 9):

```php
$image->save('resampled.jpg', 80); // JPEG, calitate 80%
```

În cazul în care formatul nu este evident din extensia fișierului, acesta poate fi specificat prin [constantă |#Formats]:

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

Imaginea poate fi scrisă într-o variabilă în loc de pe disc:

```php
$data = $image->toString(ImageType::JPEG, 80); // JPEG, calitate 80%
```

sau trimiteți direct la browser cu antetul HTTP corespunzător `Content-Type`:

```php
// trimite antet Content-Type: image/png
$image->send(ImageType::PNG);
```


Formate .[#toc-formats]
=======================

Formatele acceptate sunt JPEG, PNG, GIF, WebP, AVIF și BMP. Cu toate acestea, ele trebuie să fie acceptate și de versiunea dumneavoastră de PHP, ceea ce poate fi verificat cu ajutorul funcției [isTypeSupported() |#isTypeSupported()]. Animațiile nu sunt acceptate.

Formatele sunt reprezentate de constantele `ImageType::JPEG`, `ImageType::PNG`, `ImageType::GIF`, `ImageType::WEBP`, `ImageType::AVIF`, și `ImageType::BMP`.

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

Aveți nevoie să detectați formatul unei imagini la încărcare? Metoda îl returnează în cel de-al doilea parametru:

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

Detectarea efectivă fără a încărca imaginea este realizată de `Image::detectTypeFromFile()`.


Redimensionarea imaginii .[#toc-image-resize]
=============================================

O operațiune obișnuită este redimensionarea unei imagini. Dimensiunile curente sunt returnate prin metodele `getWidth()` și `getHeight()`.

Metoda `resize()` este utilizată pentru redimensionare. Acesta este un exemplu de modificare proporțională a dimensiunii, astfel încât aceasta să nu depășească 500×300 pixeli (fie lățimea va fi exact 500px, fie înălțimea va fi exact 300px, una dintre dimensiuni fiind calculată pentru a menține raportul de aspect):

```php
$image->resize(500, 300);
```

Este posibil să setați doar o singură dimensiune, iar cea de-a doua va fi calculată:

```php
$image->resize(500, null); // lățime 500px, înălțime auto

$image->resize(null, 300); // lățime auto, înălțime 300px
```

Orice dimensiune poate fi specificată în procente:

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

Comportamentul `resize` poate fi influențat de următoarele indicatori. Toate, cu excepția `Image::Stretch`, păstrează raportul de aspect.

|---------------------------------------------------------------------------------------
| Steag | Descriere
|---------------------------------------------------------------------------------------
| `Image::OrSmaller` (implicit) | dimensiunile rezultate vor fi mai mici sau egale cu cele specificate
| `Image::OrBigger` | umple zona țintă și, eventual, o extinde într-o singură direcție
| `Image::Cover` | umple întreaga zonă și taie ceea ce o depășește
| `Image::ShrinkOnly` | doar se micșorează (nu extinde o imagine mică)
| `Image::Stretch` | nu păstrează raportul de aspect


Steagurile sunt transmise ca al treilea argument al funcției:

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

Steagurile pot fi combinate:

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

Imaginile pot fi răsturnate pe verticală sau pe orizontală prin specificarea uneia dintre dimensiuni (sau a ambelor) ca număr negativ:

```php
$flipped = $image->resize(null, '-100%'); // flip vertical

$flipped = $image->resize('-100%', '-100%'); // rotiți cu 180°.

$flipped = $image->resize(-125, 500); // redimensionare și întoarcere orizontală
```

După reducerea imaginii, o putem îmbunătăți prin sharppening:

```php
$image->sharpen();
```


Recoltare .[#toc-cropping]
==========================

Metoda `crop()` este utilizată pentru recoltare:

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

Ca și în cazul `resize()`, toate valorile pot fi specificate în procente. Procentele pentru `$left` și `$top` sunt calculate din spațiul rămas, similar cu proprietatea CSS `background-position`:

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

[* crop.svg *]


Imaginea poate fi, de asemenea, decupată automat, de exemplu, marginile negre decupate:

```php
$image->cropAuto(IMG_CROP_BLACK);
```

Metoda `cropAuto()` este o încapsulare în obiect a funcției `imagecropauto()`, a se vedea [documentația acesteia |https://www.php.net/manual/en/function.imagecropauto] pentru mai multe informații.


Culori .[#toc-colors]
=====================

Metoda `ImageColor::rgb()` vă permite să definiți o culoare folosind valorile roșu, verde și albastru (RGB). Opțional, puteți specifica, de asemenea, o valoare de transparență de la 0 (complet transparent) la 1 (complet opac), la fel ca în CSS.

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

Metoda `ImageColor::hex()` vă permite să definiți o culoare utilizând formatul hexazecimal, similar cu CSS. Aceasta acceptă formatele `#rgb`, `#rrggbb`, `#rgba` și `#rrggbbaa`:

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

Culorile pot fi utilizate în alte metode, cum ar fi `ellipse()`, `fill()`, etc.


Desen și editare .[#toc-drawing-and-editing]
============================================

Puteți desena, puteți scrie, puteți utiliza toate funcțiile PHP pentru manipularea imaginilor, vedeți [Prezentare generală a metodelor |#Overview of methods], dar într-o învelitoare orientată pe obiecte:

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

Deoarece funcțiile PHP pentru desenarea [dreptunghiurilor |#filledRectangleWH()] sunt nepractice din cauza specificării coordonatelor, clasa `Image` oferă înlocuitori sub forma funcțiilor [rectangleWH() |#rectangleWH()] și [filledRectangleWH() |#filledRectangleWH()].


Îmbinarea mai multor imagini .[#toc-merge-multiple-images]
==========================================================

Puteți plasa cu ușurință o altă imagine în imagine:

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

// coordonatele pot fi stabilite și în procente
$blank->place($logo, '80%', '80%'); // lângă colțul din dreapta jos
```

La lipire, canalul alfa este respectat, în plus, putem influența transparența imaginii inserate (vom crea un așa-numit filigran):

```php
$blank->place($image, '80%', '80%', 25); // transparența este de 25 %.
```

O astfel de API este într-adevăr o plăcere de utilizat, nu-i așa?


Prezentare generală a metodelor .[#toc-overview-of-methods]
===========================================================


static fromBlank(int $width, int $height, ImageColor $color=null): Image .[method]
----------------------------------------------------------------------------------
Creează o nouă imagine în culori reale cu dimensiunile date. Culoarea implicită este negru.


static fromFile(string $file, int &$detectedFormat=null): Image .[method]
-------------------------------------------------------------------------
Citește o imagine dintr-un fișier și returnează [tipul |#Formats] acesteia în `$detectedFormat`.


static fromString(string $s, int &$detectedFormat=null): Image .[method]
------------------------------------------------------------------------
Citește o imagine dintr-un șir de caractere și returnează [tipul |#Formats] acesteia în `$detectedFormat`.


static rgb(int $red, int $green, int $blue, int $transparency=0): array .[method][deprecated]
---------------------------------------------------------------------------------------------
Această caracteristică a fost înlocuită de clasa `ImageColor`, a se vedea [culori |#Colors].


static typeToExtension(int $type): string .[method]
---------------------------------------------------
Returnează extensia de fișier pentru [tipul |#Formats] dat.


static typeToMimeType(int $type): string .[method]
--------------------------------------------------
Returnează tipul mime pentru [tipul |#Formats] dat.


static extensionToType(string $extension): int .[method]
--------------------------------------------------------
Returnează [tipul de |#Formats] imagine în funcție de extensia fișierului.


static detectTypeFromFile(string $file, int &$width=null, int &$height=null): ?int .[method]
--------------------------------------------------------------------------------------------
Returnează [tipul |#Formats] de fișier imagine și, în parametrii `$width` și `$height`, și dimensiunile acestuia.


static detectTypeFromString(string $s, int &$width=null, int &$height=null): ?int .[method]
-------------------------------------------------------------------------------------------
Returnează [tipul |#Formats] de imagine din șirul de caractere, iar în parametrii `$width` și `$height` și dimensiunile acesteia.


static isTypeSupported(int $type): bool .[method]
-------------------------------------------------
Determină dacă [tipul de |#Formats] imagine dat este acceptat.


static getSupportedTypes(): array .[method]{data-version:4.0.4}
---------------------------------------------------------------
Returnează o matrice de tipuri de imagini acceptate (constante `ImageType::XXX`).


static calculateTextBox(string $text, string $fontFile, float $size, float $angle=0, array $options=[]): array .[method]
------------------------------------------------------------------------------------------------------------------------
Calculează dimensiunile dreptunghiului care înconjoară textul cu un font și o dimensiune specificate. Se returnează un tablou asociativ care conține cheile `left`, `top`, `width`, `height`. Marja stângă poate fi negativă dacă textul începe cu o depășire la stânga.


affine(array $affine, array $clip=null): Image .[method]
--------------------------------------------------------
Returnează o imagine care conține imaginea sursă transformată afine, folosind o zonă de tăiere opțională. ([mai mult |https://www.php.net/manual/en/function.imageaffine]).


affineMatrixConcat(array $m1, array $m2): array .[method]
---------------------------------------------------------
Returnează concatenarea a două matrici de transformare afină, ceea ce este util în cazul în care mai multe transformări trebuie aplicate aceleiași imagini dintr-o singură dată. ([mai mult |https://www.php.net/manual/en/function.imageaffinematrixconcat])


affineMatrixGet(int $type, mixed $options=null): array .[method]
----------------------------------------------------------------
Returnează o matrice de transformare afină. ([mai mult |https://www.php.net/manual/en/function.imageaffinematrixget])


alphaBlending(bool $on): void .[method]
---------------------------------------
Permite două moduri diferite de a desena pe imaginile truecolor. În modul de amestecare, componenta canalului alfa a culorii furnizată tuturor funcțiilor de desen, cum ar fi `setPixel()`, determină cât de mult din culoarea de bază trebuie să fie lăsată să strălucească. Ca urmare, amestecă automat culoarea existentă în acel punct cu culoarea desenului și stochează rezultatul în imagine. Pixelul rezultat este opac. În modul de neamestec, culoarea desenului este copiată literal cu informațiile canalului său alfa, înlocuind pixelul de destinație. Modul de amestecare nu este disponibil atunci când se desenează pe imagini de paletă. ([mai mult |https://www.php.net/manual/en/function.imagealphablending])


antialias(bool $on): void .[method]
-----------------------------------
Activați metodele de desenare rapidă antialiasată pentru linii și poligoane cablate. Nu acceptă componente alfa. Funcționează cu ajutorul unei operațiuni de amestecare directă. Funcționează numai cu imagini în culori reale.

Utilizarea primitivelor antialiasate cu o culoare de fundal transparentă poate avea rezultate neașteptate. Metoda de amestecare utilizează culoarea de fundal ca orice altă culoare. Lipsa suportului pentru componenta alfa nu permite o metodă de antialiasing bazată pe alfa. ([mai mult |https://www.php.net/manual/en/function.imageantialias])


arc(int $centerX, int $centerY, int $width, int $height, int $startAngle, int $endAngle, ImageColor $color): void .[method]
---------------------------------------------------------------------------------------------------------------------------
Desenează un arc de cerc centrat pe coordonatele date. ([mai mult |https://www.php.net/manual/en/function.imagearc])


colorAllocate(int $red, int $green, int $blue): int .[method]
-------------------------------------------------------------
Returnează un identificator de culoare care reprezintă culoarea compusă din componentele RGB date. Acesta trebuie apelat pentru a crea fiecare culoare care urmează să fie utilizată în imagine. ([mai mult |https://www.php.net/manual/en/function.imagecolorallocate])


colorAllocateAlpha(int $red, int $green, int $blue, int $alpha): int .[method]
------------------------------------------------------------------------------
Se comportă în mod identic cu `colorAllocate()`, cu adăugarea parametrului de transparență `$alpha`. ([mai mult |https://www.php.net/manual/en/function.imagecolorallocatealpha])


colorAt(int $x, int $y): int .[method]
--------------------------------------
Returnează indicele culorii pixelului din locația specificată în imagine. În cazul în care imaginea este o imagine în culori reale, această funcție returnează valoarea RGB a pixelului respectiv ca număr întreg. Utilizați deplasarea de biți și mascarea pentru a accesa valorile distincte ale componentelor roșu, verde și albastru: ([mai mult |https://www.php.net/manual/en/function.imagecolorat])


colorClosest(int $red, int $green, int $blue): int .[method]
------------------------------------------------------------
Returnează indicele culorii din paleta imaginii care este "cea mai apropiată" de valoarea RGB specificată. "Distanța" dintre culoarea dorită și fiecare culoare din paletă este calculată ca și cum valorile RGB ar reprezenta puncte în spațiul tridimensional. ([mai mult |https://www.php.net/manual/en/function.imagecolorclosest])


colorClosestAlpha(int $red, int $green, int $blue, int $alpha): int .[method]
-----------------------------------------------------------------------------
Returnează indicele culorii din paleta imaginii care este "cel mai apropiat" de valoarea RGB și de nivelul `$alpha` specificate. ([mai mult |https://www.php.net/manual/en/function.imagecolorclosestalpha])


colorClosestHWB(int $red, int $green, int $blue): int .[method]
---------------------------------------------------------------
Obține indexul culorii care are nuanța, albul și negrul cele mai apropiate de culoarea dată. ([mai mult |https://www.php.net/manual/en/function.imagecolorclosesthwb])


colorDeallocate(int $color): void .[method]
-------------------------------------------
De-alocă o culoare alocată anterior cu `colorAllocate()` sau `colorAllocateAlpha()`. ([mai mult |https://www.php.net/manual/en/function.imagecolordeallocate])


colorExact(int $red, int $green, int $blue): int .[method]
----------------------------------------------------------
Returnează indicele culorii specificate în paleta imaginii. ([mai mult |https://www.php.net/manual/en/function.imagecolorexact])


colorExactAlpha(int $red, int $green, int $blue, int $alpha): int .[method]
---------------------------------------------------------------------------
Returnează indicele culorii+alfa specificate în paleta de culori a imaginii. ([mai mult |https://www.php.net/manual/en/function.imagecolorexactalpha])


colorMatch(Image $image2): void .[method]
-----------------------------------------
Face ca culorile din versiunea de paletă a unei imagini să se apropie mai mult de versiunea în culori reale. ([mai mult |https://www.php.net/manual/en/function.imagecolormatch])


colorResolve(int $red, int $green, int $blue): int .[method]
------------------------------------------------------------
Returnează un indice de culoare pentru o culoare solicitată, fie culoarea exactă, fie cea mai apropiată alternativă posibilă. ([mai mult |https://www.php.net/manual/en/function.imagecolorresolve])


colorResolveAlpha(int $red, int $green, int $blue, int $alpha): int .[method]
-----------------------------------------------------------------------------
Returnează un indice de culoare pentru o culoare solicitată, fie culoarea exactă, fie cea mai apropiată alternativă posibilă. ([mai mult |https://www.php.net/manual/en/function.imagecolorresolvealpha])


colorSet(int $index, int $red, int $green, int $blue): void .[method]
---------------------------------------------------------------------
Aceasta setează indexul specificat în paletă la culoarea specificată. ([mai mult |https://www.php.net/manual/en/function.imagecolorset])


colorsForIndex(int $index): array .[method]
-------------------------------------------
Obține culoarea pentru un indice specificat. ([mai mult |https://www.php.net/manual/en/function.imagecolorsforindex])


colorsTotal(): int .[method]
----------------------------
Returnează numărul de culori dintr-o paletă de imagini ([mai multe |https://www.php.net/manual/en/function.imagecolorstotal]).


colorTransparent(int $color=null): int .[method]
------------------------------------------------
Obține sau stabilește culoarea transparentă a imaginii. ([mai mult |https://www.php.net/manual/en/function.imagecolortransparent])


convolution(array $matrix, float $div, float $offset): void .[method]
---------------------------------------------------------------------
Aplică o matrice de convoluție pe imagine, folosind coeficientul și decalajul date. ([mai mult |https://www.php.net/manual/en/function.imageconvolution])

.[note]
Necesită *Extensie GD la pachet*, deci nu este sigur că va funcționa peste tot.


copy(Image $src, int $dstX, int $dstY, int $srcX, int $srcY, int $srcW, int $srcH): void .[method]
--------------------------------------------------------------------------------------------------
Copiază o parte din `$src` pe imagine începând de la coordonatele `$srcX`, `$srcY` cu o lățime de `$srcW` și o înălțime de `$srcH`. Porțiunea definită va fi copiată pe coordonatele, `$dstX` și `$dstY`. ([mai mult |https://www.php.net/manual/en/function.imagecopy])


copyMerge(Image $src, int $dstX, int $dstY, int $srcX, int $srcY, int $srcW, int $srcH, int $opacity): void .[method]
---------------------------------------------------------------------------------------------------------------------
Copiază o parte din `$src` pe imagine începând de la coordonatele `$srcX`, `$srcY` cu o lățime de `$srcW` și o înălțime de `$srcH`. Porțiunea definită va fi copiată pe coordonatele, `$dstX` și `$dstY`. ([mai mult |https://www.php.net/manual/en/function.imagecopymerge])


copyMergeGray(Image $src, int $dstX, int $dstY, int $srcX, int $srcY, int $srcW, int $srcH, int $opacity): void .[method]
-------------------------------------------------------------------------------------------------------------------------
Copiază o parte din `$src` pe imagine începând de la coordonatele `$srcX`, `$srcY` cu o lățime de `$srcW` și o înălțime de `$srcH`. Porțiunea definită va fi copiată pe coordonatele, `$dstX` și `$dstY`.

Această funcție este identică cu `copyMerge()`, cu excepția faptului că, la fuziune, păstrează nuanța sursei prin convertirea pixelilor de destinație în scala de gri înainte de operațiunea de copiere. ([mai mult |https://www.php.net/manual/en/function.imagecopymergegray])


copyResampled(Image $src, int $dstX, int $dstY, int $srcX, int $srcY, int $dstW, int $dstH, int $srcW, int $srcH): void .[method]
---------------------------------------------------------------------------------------------------------------------------------
Copiază o porțiune dreptunghiulară dintr-o imagine în altă imagine, interpolând lin valorile pixelilor, astfel încât, în special, reducerea dimensiunii unei imagini să păstreze în continuare o mare claritate.

Cu alte cuvinte, `copyResampled()` va lua o zonă dreptunghiulară din `$src` cu lățimea `$srcW` și înălțimea `$srcH` în poziția (`$srcX`,`$srcY`) și o va plasa într-o zonă dreptunghiulară a imaginii cu lățimea `$dstW` și înălțimea `$dstH` în poziția (`$dstX`,`$dstY`).

În cazul în care coordonatele, lățimea și înălțimile sursei și ale destinației diferă, se va efectua o întindere sau o micșorare corespunzătoare a fragmentului de imagine. Coordonatele se referă la colțul din stânga sus. Această funcție poate fi utilizată pentru a copia regiuni din cadrul aceleiași imagini, dar dacă regiunile se suprapun, rezultatele vor fi imprevizibile. ([mai mult |https://www.php.net/manual/en/function.imagecopyresampled])


copyResized(Image $src, int $dstX, int $dstY, int $srcX, int $srcY, int $dstW, int $dstH, int $srcW, int $srcH): void .[method]
-------------------------------------------------------------------------------------------------------------------------------
Copiază o porțiune dreptunghiulară dintr-o imagine în altă imagine. Cu alte cuvinte, `copyResized()` va lua o zonă dreptunghiulară din `$src` cu lățimea `$srcW` și înălțimea `$srcH` în poziția (`$srcX`,`$srcY`) și o va plasa într-o zonă dreptunghiulară a imaginii cu lățimea `$dstW` și înălțimea `$dstH` în poziția (`$dstX`,`$dstY`).

În cazul în care coordonatele, lățimea și înălțimile sursei și ale destinației diferă, se va efectua o întindere sau o micșorare corespunzătoare a fragmentului de imagine. Coordonatele se referă la colțul din stânga sus. Această funcție poate fi utilizată pentru a copia regiuni din cadrul aceleiași imagini, dar dacă regiunile se suprapun, rezultatele vor fi imprevizibile. ([mai mult |https://www.php.net/manual/en/function.imagecopyresized])


crop(int|string $left, int|string $top, int|string $width, int|string $height): Image .[method]
-----------------------------------------------------------------------------------------------
Recuperează o imagine în zona dreptunghiulară dată. Dimensiunile pot fi transmise ca numere întregi în pixeli sau ca șiruri de caractere în procente (de exemplu, `'50%'`).


cropAuto(int $mode=-1, float $threshold=.5, ?ImageColor $color=null): Image .[method]
-------------------------------------------------------------------------------------
Recuperează automat o imagine în funcție de datele furnizate `$mode`. ([mai mult |https://www.php.net/manual/en/function.imagecropauto])


ellipse(int $centerX, int $centerY, int $width, int $height, ImageColor $color): void .[method]
-----------------------------------------------------------------------------------------------
Desenează o elipsă centrată la coordonatele specificate. ([mai mult |https://www.php.net/manual/en/function.imageellipse])


fill(int $x, int $y, ImageColor $color): void .[method]
-------------------------------------------------------
Efectuează o umplere de inundație începând de la coordonata dată (stânga sus este 0, 0) cu `$color` în imagine. ([mai mult |https://www.php.net/manual/en/function.imagefill])


filledArc(int $centerX, int $centerY, int $width, int $height, int $startAngle, int $endAngle, ImageColor $color, int $style): void .[method]
---------------------------------------------------------------------------------------------------------------------------------------------
Desenează un arc parțial centrat pe coordonata specificată în imagine. ([mai mult |https://www.php.net/manual/en/function.imagefilledarc])


filledEllipse(int $centerX, int $centerY, int $width, int $height, ImageColor $color): void .[method]
-----------------------------------------------------------------------------------------------------
Desenează o elipsă centrată la coordonatele specificate în imagine. ([mai mult |https://www.php.net/manual/en/function.imagefilledellipse])


filledPolygon(array $points, ImageColor $color): void .[method]
---------------------------------------------------------------
Creează un poligon umplut în imaginea $image. ([mai mult |https://www.php.net/manual/en/function.imagefilledpolygon])


filledRectangle(int $x1, int $y1, int $x2, int $y2, ImageColor $color): void .[method]
--------------------------------------------------------------------------------------
Creează un dreptunghi umplut cu `$color` în imagine, începând cu `$x1` & `$y1` și terminând cu `$x2` & `$y2`. Punctul 0, 0 este colțul din stânga sus al imaginii. ([mai mult |https://www.php.net/manual/en/function.imagefilledrectangle])


filledRectangleWH(int $left, int $top, int $width, int $height, ImageColor $color): void .[method]
--------------------------------------------------------------------------------------------------
Creează un dreptunghi umplut cu `$color` în imagine pornind de la punctul `$left` & `$top` cu lățimea `$width` și înălțimea `$height`. Punctul 0, 0 este colțul din stânga sus al imaginii.


fillToBorder(int $x, int $y, int $border, ImageColor $color): void .[method]
----------------------------------------------------------------------------
Efectuează o umplere de inundație a cărei culoare a marginii este definită de `$border`. Punctul de plecare pentru umplere este `$x`, `$y` (stânga sus este 0, 0) și regiunea este umplută cu culoarea `$color`. ([mai mult |https://www.php.net/manual/en/function.imagefilltoborder])


filter(int $filtertype, int ...$args): void .[method]
-----------------------------------------------------
Aplică filtrul dat `$filtertype` pe imagine. ([mai mult |https://www.php.net/manual/en/function.imagefilter])


flip(int $mode): void .[method]
-------------------------------
Întoarce imaginea folosind datele `$mode`. ([mai mult |https://www.php.net/manual/en/function.imageflip])


ftText(float $size, float $angle, int $x, int $y, ImageColor $color, string $fontFile, string $text, array $options=[]): array .[method]
----------------------------------------------------------------------------------------------------------------------------------------
Scrieți textul din imagine. ([mai mult |https://www.php.net/manual/en/function.imagefttext])


gammaCorrect(float $inputgamma, float $outputgamma): void .[method]
-------------------------------------------------------------------
Aplică corecția gamma imaginii, având în vedere o gamă de intrare și una de ieșire. ([mai mult |https://www.php.net/manual/en/function.imagegammacorrect])


getClip(): array .[method]
--------------------------
Obține dreptunghiul de tăiere curent, adică zona dincolo de care nu se va desena niciun pixel. ([mai mult |https://www.php.net/manual/en/function.imagegetclip])


getHeight(): int .[method]
--------------------------
Returnează înălțimea imaginii.


getImageResource(): resource|GdImage .[method]
----------------------------------------------
Returnează resursa originală.


getWidth(): int .[method]
-------------------------
Returnează lățimea imaginii.


interlace(int $interlace=null): int .[method]
---------------------------------------------
Activează sau dezactivează bitul de întrepătrundere. Dacă bitul de întrepătrundere este setat și imaginea este utilizată ca imagine JPEG, imaginea este creată ca o imagine JPEG progresivă. ([mai mult |https://www.php.net/manual/en/function.imageinterlace])


isTrueColor(): bool .[method]
-----------------------------
Află dacă imaginea este un truecolor. ([mai mult |https://www.php.net/manual/en/function.imageistruecolor])


layerEffect(int $effect): void .[method]
----------------------------------------
Setați indicatorul de amestecare alfa pentru a utiliza efectele de stratificare. ([mai mult |https://www.php.net/manual/en/function.imagelayereffect])


line(int $x1, int $y1, int $x2, int $y2, ImageColor $color): void .[method]
---------------------------------------------------------------------------
Trasează o linie între cele două puncte date. ([mai mult |https://www.php.net/manual/en/function.imageline])


openPolygon(array $points, ImageColor $color): void .[method]
-------------------------------------------------------------
Desenează un poligon deschis pe imagine. Spre deosebire de `polygon()`, nu se trasează nicio linie între ultimul și primul punct. ([mai mult |https://www.php.net/manual/en/function.imageopenpolygon])


paletteCopy(Image $source): void .[method]
------------------------------------------
Copiază paleta de pe `$source` pe imagine. ([mai mult |https://www.php.net/manual/en/function.imagepalettecopy])


paletteToTrueColor(): void .[method]
------------------------------------
Convertește o imagine bazată pe palete, creată de funcții precum `create()`, într-o imagine în culori reale, precum `createtruecolor()`. ([mai mult |https://www.php.net/manual/en/function.imagepalettetotruecolor])


place(Image $image, int|string $left=0, int|string $top=0, int $opacity=100): Image .[method]
---------------------------------------------------------------------------------------------
Copiază `$image` în imagine la coordonatele `$left` și `$top`. Coordonatele pot fi transmise ca numere întregi în pixeli sau ca șiruri de caractere în procente (de exemplu, `'50%'`).


polygon(array $points, ImageColor $color): void .[method]
---------------------------------------------------------
Creează un poligon în imagine. ([mai mult |https://www.php.net/manual/en/function.imagepolygon])


rectangle(int $x1, int $y1, int $x2, int $y2, ImageColor $color): void .[method]
--------------------------------------------------------------------------------
Creează un dreptunghi care începe la coordonatele specificate. ([mai mult |https://www.php.net/manual/en/function.imagerectangle])


rectangleWH(int $left, int $top, int $width, int $height, ImageColor $color): void .[method]
--------------------------------------------------------------------------------------------
Creează un dreptunghi la coordonatele date.


resize(int|string $width, int|string $height, int $flags=Image::OrSmaller): Image .[method]
-------------------------------------------------------------------------------------------
Scală o imagine, vezi [mai multe informații |#Image Resize]. Dimensiunile pot fi transmise ca numere întregi în pixeli sau ca șiruri de caractere în procente (de exemplu, `'50%'`).


resolution(int $resX=null, int $resY=null): mixed .[method]
-----------------------------------------------------------
Permite setarea și obținerea rezoluției unei imagini în DPI (dots per inch). Dacă nu se furnizează niciunul dintre parametrii opționali, rezoluția curentă este returnată sub formă de matrice indexată. Dacă se indică doar `$resX`, rezoluția orizontală și verticală este setată la această valoare. În cazul în care sunt furnizați ambii parametri opționali, rezoluția orizontală și verticală sunt stabilite la aceste valori.

Rezoluția este utilizată ca meta-informație doar atunci când imaginile sunt citite și scrise în formate care acceptă acest tip de informații (în prezent PNG și JPEG). Aceasta nu afectează nicio operațiune de desenare. Rezoluția implicită pentru imaginile noi este de 96 DPI. ([mai mult |https://www.php.net/manual/en/function.imageresolution])


rotate(float $angle, int $backgroundColor): Image .[method]
-----------------------------------------------------------
Rotește imaginea folosind `$angle` în grade. Centrul de rotație este centrul imaginii, iar imaginea rotită poate avea dimensiuni diferite de cele ale imaginii originale. ([mai mult |https://www.php.net/manual/en/function.imagerotate])

.[note]
Necesită *Extensie GD la pachet*, deci nu este sigur că va funcționa peste tot.


save(string $file, int $quality=null, int $type=null): void .[method]
---------------------------------------------------------------------
Salvează o imagine într-un fișier.

Calitatea compresiei este cuprinsă în intervalul 0...100 pentru JPEG (implicit 85), WEBP (implicit 80) și AVIF (implicit 30) și 0...9 pentru PNG (implicit 9). În cazul în care tipul nu este evident din extensia fișierului, îl puteți specifica folosind una dintre constantele `ImageType`.


saveAlpha(bool $saveflag): void .[method]
-----------------------------------------
Setează stegulețul care determină dacă se păstrează informațiile complete ale canalului alfa (spre deosebire de transparența unei singure culori) la salvarea imaginilor PNG.

Alphablending trebuie să fie dezactivat (`alphaBlending(false)`) pentru a păstra canalul alfa în primul rând. ([mai mult |https://www.php.net/manual/en/function.imagesavealpha])


scale(int $newWidth, int $newHeight=-1, int $mode=IMG_BILINEAR_FIXED): Image .[method]
--------------------------------------------------------------------------------------
Redimensionează o imagine folosind algoritmul de interpolare dat. ([mai mult |https://www.php.net/manual/en/function.imagescale])


send(int $type=ImageType::JPEG, int $quality=null): void .[method]
------------------------------------------------------------------
Trimite o imagine în browser.

Calitatea compresiei este cuprinsă în intervalul 0...100 pentru JPEG (implicit 85), WEBP (implicit 80) și AVIF (implicit 30) și 0...9 pentru PNG (implicit 9).


setBrush(Image $brush): void .[method]
--------------------------------------
Stabilește imaginea pensulei care va fi utilizată de toate funcțiile de desenare a liniilor (cum ar fi `line()` și `polygon()`) atunci când se desenează cu culorile speciale IMG_COLOR_BRUSHED sau IMG_COLOR_STYLEDBRUSHED. ([mai mult |https://www.php.net/manual/en/function.imagesetbrush])


setClip(int $x1, int $y1, int $x2, int $y2): void .[method]
-----------------------------------------------------------
Stabilește dreptunghiul de decupaj curent, adică zona dincolo de care nu se va desena niciun pixel. ([mai mult |https://www.php.net/manual/en/function.imagesetclip])


setInterpolation(int $method=IMG_BILINEAR_FIXED): void .[method]
----------------------------------------------------------------
Stabilește metoda de interpolare care afectează metodele `rotate()` și `affine()`. ([mai mult |https://www.php.net/manual/en/function.imagesetinterpolation])


setPixel(int $x, int $y, ImageColor $color): void .[method]
-----------------------------------------------------------
Desenează un pixel la coordonatele specificate. ([mai mult |https://www.php.net/manual/en/function.imagesetpixel])


setStyle(array $style): void .[method]
--------------------------------------
Stabilește stilul care va fi utilizat de toate funcțiile de desenare a liniilor (cum ar fi `line()` și `polygon()`) atunci când se desenează cu culoarea specială IMG_COLOR_STYLED sau linii de imagini cu culoarea IMG_COLOR_STYLEDBRUSHED. ([mai mult |https://www.php.net/manual/en/function.imagesetstyle])


setThickness(int $thickness): void .[method]
--------------------------------------------
Stabilește grosimea liniilor desenate atunci când se desenează dreptunghiuri, poligoane, arcuri etc. la `$thickness` pixeli. ([mai mult |https://www.php.net/manual/en/function.imagesetthickness])


setTile(Image $tile): void .[method]
------------------------------------
Definește imaginea de țiglă care trebuie utilizată de toate funcțiile de umplere a regiunii (cum ar fi `fill()` și `filledPolygon()`) atunci când se completează cu culoarea specială IMG_COLOR_TILED.

O țiglă este o imagine utilizată pentru a umple o zonă cu un model repetat. Orice imagine poate fi utilizată ca o țiglă, iar prin setarea indicelui de culoare transparentă a imaginii țiglă cu `colorTransparent()`, se poate crea o țiglă care permite strălucirea anumitor părți ale zonei de bază. ([mai mult |https://www.php.net/manual/en/function.imagesettile])


sharpen(): Image .[method]
--------------------------
Acutizează puțin imaginea.

.[note]
Necesită *Extensie GD la pachet*, deci nu este sigur că va funcționa peste tot.


toString(int $type=ImageType::JPEG, int $quality=null): string .[method]
------------------------------------------------------------------------
Produce o imagine în șir de caractere.

Calitatea compresiei este cuprinsă în intervalul 0...100 pentru JPEG (implicit 85), WEBP (implicit 80) și AVIF (implicit 30) și 0...9 pentru PNG (implicit 9).


trueColorToPalette(bool $dither, int $ncolors): void .[method]
--------------------------------------------------------------
Convertește o imagine truecolor într-o imagine paletă. ([mai mult |https://www.php.net/manual/en/function.imagetruecolortopalette])


ttfText(float $size, float $angle, int $x, int $y, ImageColor $color, string $fontFile, string $text, array $options=[]): array .[method]
-----------------------------------------------------------------------------------------------------------------------------------------
Scrie textul dat în imagine. ([mai mult |https://www.php.net/manual/en/function.imagettftext])

Funcții de imagine

Clasa Nette\Utils\Image simplifică manipularea imaginilor, cum ar fi redimensionarea, decuparea, ascuțirea, desenarea sau fuzionarea mai multor imagini.

PHP dispune de un set extins de funcții pentru manipularea imaginilor. Dar API-ul nu este foarte frumos. Nu ar fi un cadru de lucru îngrijit pentru a veni cu un API sexy.

Instalare:

composer require nette/utils

Următoarele exemple presupun că este definit următorul alias de clasă:

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

Crearea unei imagini

Vom crea o nouă imagine în culori reale, de exemplu, cu dimensiunile de 100×200:

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

Opțional, puteți specifica o culoare de fundal (culoarea implicită este negru):

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

Sau încărcăm imaginea dintr-un fișier:

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

Salvați imaginea

Imaginea poate fi salvată într-un fișier:

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

Putem specifica calitatea compresiei în intervalul 0..100 pentru JPEG (implicit 85), WEBP (implicit 80) și AVIF (implicit 30) și 0..9 pentru PNG (implicit 9):

$image->save('resampled.jpg', 80); // JPEG, calitate 80%

În cazul în care formatul nu este evident din extensia fișierului, acesta poate fi specificat prin constantă:

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

Imaginea poate fi scrisă într-o variabilă în loc de pe disc:

$data = $image->toString(ImageType::JPEG, 80); // JPEG, calitate 80%

sau trimiteți direct la browser cu antetul HTTP corespunzător Content-Type:

// trimite antet Content-Type: image/png
$image->send(ImageType::PNG);

Formate

Formatele acceptate sunt JPEG, PNG, GIF, WebP, AVIF și BMP. Cu toate acestea, ele trebuie să fie acceptate și de versiunea dumneavoastră de PHP, ceea ce poate fi verificat cu ajutorul funcției isTypeSupported(). Animațiile nu sunt acceptate.

Formatele sunt reprezentate de constantele ImageType::JPEG, ImageType::PNG, ImageType::GIF, ImageType::WEBP, ImageType::AVIF, și ImageType::BMP.

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

Aveți nevoie să detectați formatul unei imagini la încărcare? Metoda îl returnează în cel de-al doilea parametru:

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

Detectarea efectivă fără a încărca imaginea este realizată de Image::detectTypeFromFile().

Redimensionarea imaginii

O operațiune obișnuită este redimensionarea unei imagini. Dimensiunile curente sunt returnate prin metodele getWidth() și getHeight().

Metoda resize() este utilizată pentru redimensionare. Acesta este un exemplu de modificare proporțională a dimensiunii, astfel încât aceasta să nu depășească 500×300 pixeli (fie lățimea va fi exact 500px, fie înălțimea va fi exact 300px, una dintre dimensiuni fiind calculată pentru a menține raportul de aspect):

$image->resize(500, 300);

Este posibil să setați doar o singură dimensiune, iar cea de-a doua va fi calculată:

$image->resize(500, null); // lățime 500px, înălțime auto

$image->resize(null, 300); // lățime auto, înălțime 300px

Orice dimensiune poate fi specificată în procente:

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

Comportamentul resize poate fi influențat de următoarele indicatori. Toate, cu excepția Image::Stretch, păstrează raportul de aspect.

Steag Descriere
Image::OrSmaller (implicit) dimensiunile rezultate vor fi mai mici sau egale cu cele specificate
Image::OrBigger umple zona țintă și, eventual, o extinde într-o singură direcție
Image::Cover umple întreaga zonă și taie ceea ce o depășește
Image::ShrinkOnly doar se micșorează (nu extinde o imagine mică)
Image::Stretch nu păstrează raportul de aspect

Steagurile sunt transmise ca al treilea argument al funcției:

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

Steagurile pot fi combinate:

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

Imaginile pot fi răsturnate pe verticală sau pe orizontală prin specificarea uneia dintre dimensiuni (sau a ambelor) ca număr negativ:

$flipped = $image->resize(null, '-100%'); // flip vertical

$flipped = $image->resize('-100%', '-100%'); // rotiți cu 180°.

$flipped = $image->resize(-125, 500); // redimensionare și întoarcere orizontală

După reducerea imaginii, o putem îmbunătăți prin sharppening:

$image->sharpen();

Recoltare

Metoda crop() este utilizată pentru recoltare:

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

Ca și în cazul resize(), toate valorile pot fi specificate în procente. Procentele pentru $left și $top sunt calculate din spațiul rămas, similar cu proprietatea CSS background-position:

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

Imaginea poate fi, de asemenea, decupată automat, de exemplu, marginile negre decupate:

$image->cropAuto(IMG_CROP_BLACK);

Metoda cropAuto() este o încapsulare în obiect a funcției imagecropauto(), a se vedea documentația acesteia pentru mai multe informații.

Culori

Metoda ImageColor::rgb() vă permite să definiți o culoare folosind valorile roșu, verde și albastru (RGB). Opțional, puteți specifica, de asemenea, o valoare de transparență de la 0 (complet transparent) la 1 (complet opac), la fel ca în CSS.

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

Metoda ImageColor::hex() vă permite să definiți o culoare utilizând formatul hexazecimal, similar cu CSS. Aceasta acceptă formatele #rgb, #rrggbb, #rgba și #rrggbbaa:

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

Culorile pot fi utilizate în alte metode, cum ar fi ellipse(), fill(), etc.

Desen și editare

Puteți desena, puteți scrie, puteți utiliza toate funcțiile PHP pentru manipularea imaginilor, vedeți Prezentare generală a metodelor, dar într-o învelitoare orientată pe obiecte:

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

Deoarece funcțiile PHP pentru desenarea dreptunghiurilor sunt nepractice din cauza specificării coordonatelor, clasa Image oferă înlocuitori sub forma funcțiilor rectangleWH() și filledRectangleWH().

Îmbinarea mai multor imagini

Puteți plasa cu ușurință o altă imagine în imagine:

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

// coordonatele pot fi stabilite și în procente
$blank->place($logo, '80%', '80%'); // lângă colțul din dreapta jos

La lipire, canalul alfa este respectat, în plus, putem influența transparența imaginii inserate (vom crea un așa-numit filigran):

$blank->place($image, '80%', '80%', 25); // transparența este de 25 %.

O astfel de API este într-adevăr o plăcere de utilizat, nu-i așa?

Prezentare generală a metodelor

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

Creează o nouă imagine în culori reale cu dimensiunile date. Culoarea implicită este negru.

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

Citește o imagine dintr-un fișier și returnează tipul acesteia în $detectedFormat.

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

Citește o imagine dintr-un șir de caractere și returnează tipul acesteia în $detectedFormat.

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

Această caracteristică a fost înlocuită de clasa ImageColor, a se vedea culori.

static typeToExtension(int $type)string

Returnează extensia de fișier pentru tipul dat.

static typeToMimeType(int $type)string

Returnează tipul mime pentru tipul dat.

static extensionToType(string $extension)int

Returnează tipul de imagine în funcție de extensia fișierului.

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

Returnează tipul de fișier imagine și, în parametrii $width și $height, și dimensiunile acestuia.

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

Returnează tipul de imagine din șirul de caractere, iar în parametrii $width și $height și dimensiunile acesteia.

static isTypeSupported(int $type)bool

Determină dacă tipul de imagine dat este acceptat.

static getSupportedTypes(): array

Returnează o matrice de tipuri de imagini acceptate (constante ImageType::XXX).

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

Calculează dimensiunile dreptunghiului care înconjoară textul cu un font și o dimensiune specificate. Se returnează un tablou asociativ care conține cheile left, top, width, height. Marja stângă poate fi negativă dacă textul începe cu o depășire la stânga.

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

Returnează o imagine care conține imaginea sursă transformată afine, folosind o zonă de tăiere opțională. (mai mult).

affineMatrixConcat(array $m1, array $m2)array

Returnează concatenarea a două matrici de transformare afină, ceea ce este util în cazul în care mai multe transformări trebuie aplicate aceleiași imagini dintr-o singură dată. (mai mult)

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

Returnează o matrice de transformare afină. (mai mult)

alphaBlending(bool $on): void

Permite două moduri diferite de a desena pe imaginile truecolor. În modul de amestecare, componenta canalului alfa a culorii furnizată tuturor funcțiilor de desen, cum ar fi setPixel(), determină cât de mult din culoarea de bază trebuie să fie lăsată să strălucească. Ca urmare, amestecă automat culoarea existentă în acel punct cu culoarea desenului și stochează rezultatul în imagine. Pixelul rezultat este opac. În modul de neamestec, culoarea desenului este copiată literal cu informațiile canalului său alfa, înlocuind pixelul de destinație. Modul de amestecare nu este disponibil atunci când se desenează pe imagini de paletă. (mai mult)

antialias(bool $on): void

Activați metodele de desenare rapidă antialiasată pentru linii și poligoane cablate. Nu acceptă componente alfa. Funcționează cu ajutorul unei operațiuni de amestecare directă. Funcționează numai cu imagini în culori reale.

Utilizarea primitivelor antialiasate cu o culoare de fundal transparentă poate avea rezultate neașteptate. Metoda de amestecare utilizează culoarea de fundal ca orice altă culoare. Lipsa suportului pentru componenta alfa nu permite o metodă de antialiasing bazată pe alfa. (mai mult)

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

Desenează un arc de cerc centrat pe coordonatele date. (mai mult)

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

Returnează un identificator de culoare care reprezintă culoarea compusă din componentele RGB date. Acesta trebuie apelat pentru a crea fiecare culoare care urmează să fie utilizată în imagine. (mai mult)

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

Se comportă în mod identic cu colorAllocate(), cu adăugarea parametrului de transparență $alpha. (mai mult)

colorAt(int $x, int $y)int

Returnează indicele culorii pixelului din locația specificată în imagine. În cazul în care imaginea este o imagine în culori reale, această funcție returnează valoarea RGB a pixelului respectiv ca număr întreg. Utilizați deplasarea de biți și mascarea pentru a accesa valorile distincte ale componentelor roșu, verde și albastru: (mai mult)

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

Returnează indicele culorii din paleta imaginii care este „cea mai apropiată“ de valoarea RGB specificată. „Distanța“ dintre culoarea dorită și fiecare culoare din paletă este calculată ca și cum valorile RGB ar reprezenta puncte în spațiul tridimensional. (mai mult)

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

Returnează indicele culorii din paleta imaginii care este „cel mai apropiat“ de valoarea RGB și de nivelul $alpha specificate. (mai mult)

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

Obține indexul culorii care are nuanța, albul și negrul cele mai apropiate de culoarea dată. (mai mult)

colorDeallocate(int $color)void

De-alocă o culoare alocată anterior cu colorAllocate() sau colorAllocateAlpha(). (mai mult)

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

Returnează indicele culorii specificate în paleta imaginii. (mai mult)

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

Returnează indicele culorii+alfa specificate în paleta de culori a imaginii. (mai mult)

colorMatch(Image $image2)void

Face ca culorile din versiunea de paletă a unei imagini să se apropie mai mult de versiunea în culori reale. (mai mult)

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

Returnează un indice de culoare pentru o culoare solicitată, fie culoarea exactă, fie cea mai apropiată alternativă posibilă. (mai mult)

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

Returnează un indice de culoare pentru o culoare solicitată, fie culoarea exactă, fie cea mai apropiată alternativă posibilă. (mai mult)

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

Aceasta setează indexul specificat în paletă la culoarea specificată. (mai mult)

colorsForIndex(int $index)array

Obține culoarea pentru un indice specificat. (mai mult)

colorsTotal(): int

Returnează numărul de culori dintr-o paletă de imagini (mai multe).

colorTransparent(int $color=null)int

Obține sau stabilește culoarea transparentă a imaginii. (mai mult)

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

Aplică o matrice de convoluție pe imagine, folosind coeficientul și decalajul date. (mai mult)

Necesită Extensie GD la pachet, deci nu este sigur că va funcționa peste tot.

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

Copiază o parte din $src pe imagine începând de la coordonatele $srcX, $srcY cu o lățime de $srcW și o înălțime de $srcH. Porțiunea definită va fi copiată pe coordonatele, $dstX și $dstY. (mai mult)

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

Copiază o parte din $src pe imagine începând de la coordonatele $srcX, $srcY cu o lățime de $srcW și o înălțime de $srcH. Porțiunea definită va fi copiată pe coordonatele, $dstX și $dstY. (mai mult)

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

Copiază o parte din $src pe imagine începând de la coordonatele $srcX, $srcY cu o lățime de $srcW și o înălțime de $srcH. Porțiunea definită va fi copiată pe coordonatele, $dstX și $dstY.

Această funcție este identică cu copyMerge(), cu excepția faptului că, la fuziune, păstrează nuanța sursei prin convertirea pixelilor de destinație în scala de gri înainte de operațiunea de copiere. (mai mult)

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

Copiază o porțiune dreptunghiulară dintr-o imagine în altă imagine, interpolând lin valorile pixelilor, astfel încât, în special, reducerea dimensiunii unei imagini să păstreze în continuare o mare claritate.

Cu alte cuvinte, copyResampled() va lua o zonă dreptunghiulară din $src cu lățimea $srcW și înălțimea $srcH în poziția ($srcX,$srcY) și o va plasa într-o zonă dreptunghiulară a imaginii cu lățimea $dstW și înălțimea $dstH în poziția ($dstX,$dstY).

În cazul în care coordonatele, lățimea și înălțimile sursei și ale destinației diferă, se va efectua o întindere sau o micșorare corespunzătoare a fragmentului de imagine. Coordonatele se referă la colțul din stânga sus. Această funcție poate fi utilizată pentru a copia regiuni din cadrul aceleiași imagini, dar dacă regiunile se suprapun, rezultatele vor fi imprevizibile. (mai mult)

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

Copiază o porțiune dreptunghiulară dintr-o imagine în altă imagine. Cu alte cuvinte, copyResized() va lua o zonă dreptunghiulară din $src cu lățimea $srcW și înălțimea $srcH în poziția ($srcX,$srcY) și o va plasa într-o zonă dreptunghiulară a imaginii cu lățimea $dstW și înălțimea $dstH în poziția ($dstX,$dstY).

În cazul în care coordonatele, lățimea și înălțimile sursei și ale destinației diferă, se va efectua o întindere sau o micșorare corespunzătoare a fragmentului de imagine. Coordonatele se referă la colțul din stânga sus. Această funcție poate fi utilizată pentru a copia regiuni din cadrul aceleiași imagini, dar dacă regiunile se suprapun, rezultatele vor fi imprevizibile. (mai mult)

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

Recuperează o imagine în zona dreptunghiulară dată. Dimensiunile pot fi transmise ca numere întregi în pixeli sau ca șiruri de caractere în procente (de exemplu, '50%').

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

Recuperează automat o imagine în funcție de datele furnizate $mode. (mai mult)

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

Desenează o elipsă centrată la coordonatele specificate. (mai mult)

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

Efectuează o umplere de inundație începând de la coordonata dată (stânga sus este 0, 0) cu $color în imagine. (mai mult)

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

Desenează un arc parțial centrat pe coordonata specificată în imagine. (mai mult)

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

Desenează o elipsă centrată la coordonatele specificate în imagine. (mai mult)

filledPolygon(array $points, ImageColor $color)void

Creează un poligon umplut în imaginea $image. (mai mult)

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

Creează un dreptunghi umplut cu $color în imagine, începând cu $x1 & $y1 și terminând cu $x2 & $y2. Punctul 0, 0 este colțul din stânga sus al imaginii. (mai mult)

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

Creează un dreptunghi umplut cu $color în imagine pornind de la punctul $left & $top cu lățimea $width și înălțimea $height. Punctul 0, 0 este colțul din stânga sus al imaginii.

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

Efectuează o umplere de inundație a cărei culoare a marginii este definită de $border. Punctul de plecare pentru umplere este $x, $y (stânga sus este 0, 0) și regiunea este umplută cu culoarea $color. (mai mult)

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

Aplică filtrul dat $filtertype pe imagine. (mai mult)

flip(int $mode): void

Întoarce imaginea folosind datele $mode. (mai mult)

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

Scrieți textul din imagine. (mai mult)

gammaCorrect(float $inputgamma, float $outputgamma)void

Aplică corecția gamma imaginii, având în vedere o gamă de intrare și una de ieșire. (mai mult)

getClip(): array

Obține dreptunghiul de tăiere curent, adică zona dincolo de care nu se va desena niciun pixel. (mai mult)

getHeight(): int

Returnează înălțimea imaginii.

getImageResource(): resource|GdImage

Returnează resursa originală.

getWidth(): int

Returnează lățimea imaginii.

interlace(int $interlace=null)int

Activează sau dezactivează bitul de întrepătrundere. Dacă bitul de întrepătrundere este setat și imaginea este utilizată ca imagine JPEG, imaginea este creată ca o imagine JPEG progresivă. (mai mult)

isTrueColor(): bool

Află dacă imaginea este un truecolor. (mai mult)

layerEffect(int $effect)void

Setați indicatorul de amestecare alfa pentru a utiliza efectele de stratificare. (mai mult)

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

Trasează o linie între cele două puncte date. (mai mult)

openPolygon(array $points, ImageColor $color)void

Desenează un poligon deschis pe imagine. Spre deosebire de polygon(), nu se trasează nicio linie între ultimul și primul punct. (mai mult)

paletteCopy(Image $source)void

Copiază paleta de pe $source pe imagine. (mai mult)

paletteToTrueColor(): void

Convertește o imagine bazată pe palete, creată de funcții precum create(), într-o imagine în culori reale, precum createtruecolor(). (mai mult)

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

Copiază $image în imagine la coordonatele $left și $top. Coordonatele pot fi transmise ca numere întregi în pixeli sau ca șiruri de caractere în procente (de exemplu, '50%').

polygon(array $points, ImageColor $color)void

Creează un poligon în imagine. (mai mult)

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

Creează un dreptunghi care începe la coordonatele specificate. (mai mult)

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

Creează un dreptunghi la coordonatele date.

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

Scală o imagine, vezi mai multe informații. Dimensiunile pot fi transmise ca numere întregi în pixeli sau ca șiruri de caractere în procente (de exemplu, '50%').

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

Permite setarea și obținerea rezoluției unei imagini în DPI (dots per inch). Dacă nu se furnizează niciunul dintre parametrii opționali, rezoluția curentă este returnată sub formă de matrice indexată. Dacă se indică doar $resX, rezoluția orizontală și verticală este setată la această valoare. În cazul în care sunt furnizați ambii parametri opționali, rezoluția orizontală și verticală sunt stabilite la aceste valori.

Rezoluția este utilizată ca meta-informație doar atunci când imaginile sunt citite și scrise în formate care acceptă acest tip de informații (în prezent PNG și JPEG). Aceasta nu afectează nicio operațiune de desenare. Rezoluția implicită pentru imaginile noi este de 96 DPI. (mai mult)

rotate(float $angle, int $backgroundColor)Image

Rotește imaginea folosind $angle în grade. Centrul de rotație este centrul imaginii, iar imaginea rotită poate avea dimensiuni diferite de cele ale imaginii originale. (mai mult)

Necesită Extensie GD la pachet, deci nu este sigur că va funcționa peste tot.

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

Salvează o imagine într-un fișier.

Calitatea compresiei este cuprinsă în intervalul 0…100 pentru JPEG (implicit 85), WEBP (implicit 80) și AVIF (implicit 30) și 0…9 pentru PNG (implicit 9). În cazul în care tipul nu este evident din extensia fișierului, îl puteți specifica folosind una dintre constantele ImageType.

saveAlpha(bool $saveflag)void

Setează stegulețul care determină dacă se păstrează informațiile complete ale canalului alfa (spre deosebire de transparența unei singure culori) la salvarea imaginilor PNG.

Alphablending trebuie să fie dezactivat (alphaBlending(false)) pentru a păstra canalul alfa în primul rând. (mai mult)

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

Redimensionează o imagine folosind algoritmul de interpolare dat. (mai mult)

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

Trimite o imagine în browser.

Calitatea compresiei este cuprinsă în intervalul 0…100 pentru JPEG (implicit 85), WEBP (implicit 80) și AVIF (implicit 30) și 0…9 pentru PNG (implicit 9).

setBrush(Image $brush)void

Stabilește imaginea pensulei care va fi utilizată de toate funcțiile de desenare a liniilor (cum ar fi line() și polygon()) atunci când se desenează cu culorile speciale IMG_COLOR_BRUSHED sau IMG_COLOR_STYLEDBRUSHED. (mai mult)

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

Stabilește dreptunghiul de decupaj curent, adică zona dincolo de care nu se va desena niciun pixel. (mai mult)

setInterpolation(int $method=IMG_BILINEAR_FIXED)void

Stabilește metoda de interpolare care afectează metodele rotate() și affine(). (mai mult)

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

Desenează un pixel la coordonatele specificate. (mai mult)

setStyle(array $style)void

Stabilește stilul care va fi utilizat de toate funcțiile de desenare a liniilor (cum ar fi line() și polygon()) atunci când se desenează cu culoarea specială IMG_COLOR_STYLED sau linii de imagini cu culoarea IMG_COLOR_STYLEDBRUSHED. (mai mult)

setThickness(int $thickness)void

Stabilește grosimea liniilor desenate atunci când se desenează dreptunghiuri, poligoane, arcuri etc. la $thickness pixeli. (mai mult)

setTile(Image $tile)void

Definește imaginea de țiglă care trebuie utilizată de toate funcțiile de umplere a regiunii (cum ar fi fill() și filledPolygon()) atunci când se completează cu culoarea specială IMG_COLOR_TILED.

O țiglă este o imagine utilizată pentru a umple o zonă cu un model repetat. Orice imagine poate fi utilizată ca o țiglă, iar prin setarea indicelui de culoare transparentă a imaginii țiglă cu colorTransparent(), se poate crea o țiglă care permite strălucirea anumitor părți ale zonei de bază. (mai mult)

sharpen(): Image

Acutizează puțin imaginea.

Necesită Extensie GD la pachet, deci nu este sigur că va funcționa peste tot.

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

Produce o imagine în șir de caractere.

Calitatea compresiei este cuprinsă în intervalul 0…100 pentru JPEG (implicit 85), WEBP (implicit 80) și AVIF (implicit 30) și 0…9 pentru PNG (implicit 9).

trueColorToPalette(bool $dither, int $ncolors)void

Convertește o imagine truecolor într-o imagine paletă. (mai mult)

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

Scrie textul dat în imagine. (mai mult)