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])