Manipulando imagens com Intervention Image

Intervention Image, manipulando imagens com PHP

A biblioteca Intervention Image é biblioteca de código aberto e foi desenvolvida para manipulação e processamento de imagens. Com uma interface fluida, é possível criar, editar e compor imagens com facilidade. Além disso, a biblioteca já inclui os componentes de integração do framework Laravel, o que torna seu uso ainda mais simples em conjunto com esse popular framework. Ela suporta duas das mais populares extensões de imagem: GD ou Imagick que tevem estar habilitadas no PHP.

Para instalar a biblioteca utilizamos o composer:

composer require intervention/image

Integrando com o Laravel

A biblioteca Intervention Image já nos fornece as classes Provider e Facade para integra-la com o Laravel. Para isso, deve-se editar o arquivo config/app.php e adicionar no array $providers o valor Intervention\Image\ImageServiceProvider::class e no array $aliases, adicionar ‘Image’ => Intervention\Image\Facades\Image::class.

Para exportar as configurações do Intervention podemos executar o comando do artisan:

php artisan vendor:publish --provider="Intervention\Image\ImageServiceProviderLaravelRecent"

Será criado o arquivo config/image.php, onde podemos alterar as configurações da biblioteca como o driver ela irá utilizar.

O básico do Intervention Image

use Intervention\Image\ImageManager;

$manager = new ImageManager();
//$manager = new ImageManager(['driver' => 'imagick']);

$image = $manager->make('images/castelo.jpg');

$image->resize(300, 200);
$image->save('out/castelo.jpg');

No exemplo acima, na linha 3, criamos um objeto Intervention\Image\Image. Caso passemos um array para o seu construtor, é possível definir qual extensão de processamento de imagem a biblioteca utilizará para manipular as imagens. Por padrão, a biblioteca utiliza o driver gd.

Na linha 6, utilizamos o método make para ler a imagem do sistema de arquivos. Esse método é bastante versátil e permite a leitura de imagens a partir de diversas fontes além do sistema de arquivos (o que veremos mais adiante). A partir dele, criamos um objeto Image no qual realizaremos as manipulações necessárias.

Embora seja possível utilizar a biblioteca da maneira descrita anteriormente, é mais comum utilizá-la de forma estática, encadeando as chamadas dos métodos. O código abaixo é equivalente ao anterior:

use Intervention\Image\ImageManagerStatic as Image;

Image::configure(['driver' => 'gd']);

$image = Image::make('images/castelo.jpg')
            ->resize(300, 200)
            ->save('out/castelo.jpg');

Na linha 1 importamos a classe de ImageManagerStatic e criamos um aliases para ela para não ser necessário escrever este nome comprido. Para configurar o driver a ser utilizado chamamos o método estático configure passando o mesmo array que passaríamos quando utilizamos um construtor.

Para realizar a leitura da imagem, chamamos o método make de forma estática. Como ele retorna um objeto Intervention\Image\Image, é possível encadear a chamada para o método resize, que também retorna o mesmo objeto, e assim por diante.

Vamos agora explorar um pouco mais o método make, uma vez que ele possibilita a leitura de diversas fontes.

// pelo sistema de arquivo
$img = Image::make('images/castelo.jpg')
    ->save('out/imagem1.jpg');

// por url
Image::make('https://www.botecodigital.dev.br/exemplos/intervention-image/castelo.jpg')
    ->save('out/imagem2.jpg');
        
// por binary data
$img = Image::make(file_get_contents('images/castelo.jpg'))
        ->save('out/imagem3.jpg');

// por gd resource
$img = Image::make(imagecreatefromjpeg('images/castelo.jpg'))
    ->save('out/imagem4.jpg');
    
// pelo objeto Laravel file upload
//Image::make($request->file('imagem'))
//        ->save(storage_path('app/public/imagem5.jpg'));



//por encoded base64
$encodeBase64 = "/9j/4AAQSkZJRgABAQAAAQABAAD/4gHYSUNDX1BST0ZJTEUAAQEAAAHIAAAAAAQwAABtbnRyUkdCIFhZWiAAAAAAAAAAAAAAAABhY3NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlkZXNjAAAA8AAAACRyWFlaAAABFAAAABRnWFlaAAABKAAAABRiWFlaAAABPAAAABR3dHB0AAABUAAAABRyVFJDAAABZAAAAChnVFJDAAABZAAAAChiVFJDAAABZAAAAChjcHJ0AAABjAAAADxtbHVjAAAAAAAAAAEAAAAMZW5VUwAAAAgAAAAcAHMAUgBHAEJYWVogAAAAAAAAb6IAADj1AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9YWVogAAAAAAAA9tYAAQAAAADTLXBhcmEAAAAAAAQAAAACZmYAAPKnAAANWQAAE9AAAApbAAAAAAAAAABtbHVjAAAAAAAAAAEAAAAMZW5VUwAAACAAAAAcAEcAbwBvAGcAbABlACAASQBuAGMALgAgADIAMAAxADb/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAAyADIDASIAAhEBAxEB/8QAHAAAAgIDAQEAAAAAAAAAAAAAAAUDBgIEBwEI/8QAMxAAAQMDAwIFAgQGAwAAAAAAAQIDEQAEIQUSMRNBBiJRYZGBoRQjQrElMjNxotHS8PH/xAAaAQACAwEBAAAAAAAAAAAAAAACAwABBAUG/8QAKxEAAQMCBAQFBQAAAAAAAAAAAQACEQMhBBMxURIUQXEFIjI0kVKBobHR/9oADAMBAAIRAxEAPwBpcWtw3dJKgFSYGeZ9qsdtoNw9YqfeQI/TJj496sOo6Kyt1NwwwS4mMpJIJn7ZIxSnUNTu2kqbvUlEn1/epMqRCLXR7VDQKHyHRz7Gtq1WGHkuPKU6lsz3zFV5eop6nkUJweaY6eLm8SQ2SUOEA4Jj478VIVgq6aJq41S+ct7hpCWH0FtSEiBEfPrUt3b6fYPP2tna26bwNNQhDXYr27uDMFUnvVaZaGlrbcceaLm8JUhCpUn6fA9jgxTjWGtJuNSeXqj11alwNrS6l7yuIgYjOMQcc/NOptvBmEl5tISu71y8t7p5lWoubm1qQeOQYopg7rehdRf8VWcnPR5/xoq8mp9J+FeczcJI1fOWxAN4HYVPkSTJx6fSq74m1Wyty27erUgXBJnZORySBMenxXL9R8e39xZ9JpSbVbZClutFSVKTAA80xMmTgDtnil+n3AvGC4FlDqx+YdxG6TJM/XNZ6lei0QwHuVKfE53nK7FbteHW3yLrXLR0pUkKQ0Scq7BXBGRkEgHFX61a0l7SXbBwWzSEkKQp8gDeoxtBkeaJAzma+Zy3A2JSrqASChfAH24z2rauV3t+ibi4deS2nahtxZUEkY44/ahFaLynGmDZdu8T+IfDlt4Wt0surLaZYaDQClBSQo7k7cGYgmYMyfWqdaalZao+pu3dWt5tMqStJBTBjvg8+pFc/a61u2jY8paAZCFKKhIx/LxwYnkCmGneInrDUUPvICrdQ2uhDYlSZBxPEkDv/qtmE8Ry38PTqsuJwQqNka9Feukmiox4r8OET1o9i2uR9qK7fO0t/wAhcnlKu37XIH9MaRbl91/rqVthAACTHEEdqW3+k3DF0hVo8l62cUQqCB0yeAR2HGcx8S0Fs6lq1bKz+WmDzKlEzEdxmPWM+9YstkqKn3FWzyJ3NhHPfjj39SPpXhWVnNvK7RspEOPW1o6FEIebkDaoQQByPf2zmsdH1Q3DSRcEEFRCVEcxyB7cf948tXGHrdZeDSm0KIMmInGPiobbTrK1uQ5+LSGwNyEEnAIM5P17Yo86xkXRB5tCcLvmkoa6klThhSuNuB/72rG5uQ0QhlCXUAbldQ4UDjyxic/6qJT9o7aLUhBKUjyKByY5E8Tg+npWnpTyHy05C0JcUUCASExHJj7d6Km5hBe8RCbxr0ugmemxn3V/yorb/BaJ+q5d3d/OkUVXP0tj8KXSPRXFqW0pS1FW7kn2rY18n8Zyf6SD9ZoorKfcfZKdopdLabNiZQk4XyP7UkZG67bSrKSBINFFbKXqKEaIYWsaQmFKHlUcHvJpy+S1omjdMlG5QnbicCiilYjQd/6iUoSmB5R8UUUVmTl//9k=";
$img = Image::make($encodeBase64)
    ->save('out/imagem6.jpg');

Na linha 2, uma image é carregada diretamente do sistema de arquivos, nada de novo até então. Já na linha 6, é carregada uma imagem através de uma URL (vale lembrar que a diretiva allow_url_fopen deve estar habilitada).

Já na linha 10, é feita a leitura do conteúdo do arquivo utilizando a função file_get_contents, que retorna o conteúdo binário do arquivo e o utiliza para carregar a imagem. Esse conteúdo poderia ter sido obtido de qualquer outra forma, mas utilizamos a função apenas para facilitar o exemplo.

Na linha 14, a imagem é criada a partir de um recurso GD, gerado através da função imagecreatefromjpeg.

Na linha 18, temos um exemplo de leitura de uma imagem dentro do framework Laravel. O método make também aceita um objeto Illuminate\Http\UploadedFile, que é retornado pelo método file do objeto Illuminate\Http\Request. Esse objeto é utilizado pelo framework para obter os dados enviados na requisição, como entradas de formulário, o que facilita muito o uso da biblioteca Intervention juntamente com o framework.

Na linha 24, temos uma imagem codificada em base64, que é passada para o método make para ser carregada.

Output

Agora, vamos analisar com mais detalhes como transformar o objeto de imagem em um arquivo ou em uma saída para o usuário. Para isso, a biblioteca nos fornece três métodos: encode, save e response.

$jpg = (string) Image::make('images/castelo.jpg')->encode('jpg', 75);
file_put_contents('out/jpg-image.jpg', $jpg);

$png = (string) Image::make('images/castelo.jpg')->encode('png');
file_put_contents('out/png-image.png', $png);

$webp = (string) Image::make('images/castelo.jpg')->encode('webp');
file_put_contents('out/webp-image.webp', $webp);

O método encode codifica o objeto Image em dados binários no formato especificado e o retorna. Ele suporta os seguintes formatos: jpg, png, gif, tif, bmp, ico, psd e webp. Se nenhum formato de imagem for especificado, ele converte para o tipo original da imagem que foi carregada. Se o tipo especificado for jpg, também é possível passar um segundo valor informando a qualidade da imagem.

Image::make('images/castelo.jpg')->save('out/save-image.png');

No método save, o objeto Image salva os dados em um arquivo no sistema de arquivos. Para isso, é necessário informar o caminho desejado (path) e, opcionalmente, a qualidade como segundo parâmetro. Ele salva a imagem no formato correspondente à extensão do arquivo informado no path. Se nenhuma extensão estiver presente, ele verifica o mime-type e, se mesmo assim não for possível, a imagem será salva como jpg. Caso seja necessário forçar um tipo, pode-se informar o tipo como terceiro parâmetro.

$img = Image::make('images/castelo.jpg');

echo $img->response();

O método response é utilizado para enviar a imagem como uma resposta HTTP, com os cabeçalhos (headers) apropriados para que o navegador possa exibi-la corretamente. É possível especificar o formato da imagem que será enviada, assim como nos outros métodos, passando-o como parâmetro.

Caso estejamos utilizando no Laravel o método response irá retornar um objeto Illuminate\Http\Response.

Route::get('/castelo', function() {
    return Image::make(storage_path('app/public/castelo.jpg'))->response('png');
});

Recuperando informações da imagem

Podemos obter informações sobre as dimensões da imagem usando os métodos width e height. O método width retorna a largura da imagem e o método height retorna a altura da imagem. Além disso, podemos recuperar o tipo MIME da imagem usando o método mime.

$img = Image::make('images/castelo.jpg');

echo $img->width() . PHP_EOL;
echo $img->height() . PHP_EOL;
echo $img->mime() . PHP_EOL;

Criando uma imagem em branco

Podemos criar uma imagem em branco para realizar diversas manipulações através do método canvas.

$img = Image::canvas(600, 400, '#000066');

$img->save('out/canvas.png');

O método canvas aceita as dimensões da imagem(largura, altura) como parâmetros, e opcionalmente a cor de fundo. Se a cor não for informada, ela será transparente.

Redimensionando a imagem

Uma das atividades mais comuns que fazemos é redimensionar imagens, e temos alguns métodos para fazer isso. Vamos ver alguns.

`Resize`

Nós utilizamos anteriormente o método resize, que recebe dois argumentos, a largura e a altura, para redimensionar a imagem para valores específicos. Estes valores específicos podem afetar as proporções da imagem, então é bom ter cuidado ao defini-los. Se apenas um dos valores seja fornecido, o método redimensionará a imagem apenas na dimensão fornecida. Entretanto, para evitar distorções na imagem ao redimensioná-la, podemos usar uma função de callback e definir uma restrição para preservar as proporções da imagem. Para isso o método aspectRatio é utilizado.

Image::make('images/castelo.jpg')
            ->resize(100, 100)
            ->save('out/castelo-1.jpg');

Image::make('images/castelo.jpg')
            ->resize(100, null)
            ->save('out/castelo-2.jpg');

Image::make('images/castelo.jpg')
            ->resize(100, null, function($constraint){
                $constraint->aspectRatio();
            })
            ->save('out/castelo-3.jpg');

W`iden` e `Heighten`

Existe um atalho para redimensionar imagens preservando suas proporções originais: os métodos widen (para largura) e heighten (para altura), que redimensionam a imagem em apenas uma dimensão, enquanto mantêm a proporção na outra. Isso torna o processo de redimensionamento mais fácil e rápido.

Image::make('images/castelo.jpg')
            ->widen(200)
            ->save('out/castelo-widen.jpg');

Image::make('images/castelo.jpg')
            ->heighten(200)
            ->save('out/castelo-heighten.jpg');

Crop

Podemos recortar uma imagem utilizando o método crop. Ele recebe a largura e a altura do recorte que desejamos fazer. Podemos especificar o ponto de origem do recorte através dos terceiro e quarto parâmetros. O terceiro parâmetro é a coordenada x e o quarto é a coordenada y do ponto de origem de onde será feito o recorte. Se nenhum ponto de origem for informado, será assumido o ponto x = 0 e y = 0, ou seja, o canto superior esquerdo da imagem.

$img = Image::make('images/castelo.jpg');

$img->crop($img->width(), 100);
$img->save('out/castelo-crop.jpg');

Fit

O método fit é uma opção interessante de redimensionamento, pois ele combina o crop com o resize para ajustar a imagem dentro das dimensões fornecidas, mantendo as proporções. Além disso, ele aceita uma função de callback como terceiro parâmetro, na qual podemos definir restrições, como impedir o upsize da imagem através do método upsize() e especificar a área onde o recorte deve acontecer na imagem. Os valores possíveis para a área de recorte são: top-left, top, top-right, left, center (padrão), right, bottom-left, bottom e bottom-right.

$img = Image::make('images/castelo.jpg');

$img->fit(200, 100);
$img->save('out/castelo-fit-1.jpg');

$img->fit(200, 200, function ($constraint) {
    $constraint->upsize();
}, 'bottom-right');
$img->save('out/castelo-fit-2.jpg');

Ajustando cores

Podemos modificar as cores da imagem utilizando diversos métodos da Intervention Image. A seguir, veremos alguns exemplos:

Greyscale

Primeiro vamos ao método grayscale que deixa a imagem em tons de cinza.

Image::make('images/castelo.jpg')
    ->greyscale()
    ->save('out/castelo-grayscale.jpg');

Brightness

Podemos ajustar o brilho da imagem utilizando o método brightness, onde é possível passar um valor entre -100 e 100. Valores negativos escurecem a imagem, enquanto valores positivos a clareiam.

Image::make('images/castelo.jpg')
    ->brightness(35)
    ->save('out/castelo-brightness-35.jpg');

Contrast

Podemos ajustar o contraste da imagem utilizando o método contrast, que, como o método anterior, aceita valores entre -100 e 100, onde -100 é o mínimo contraste, 0 para nenhuma mudança e 100 para máximo contraste.

Image::make('images/castelo.jpg')
    ->contrast(35)
    ->save('out/castelo-contrast-35.jpg');

Image::make('images/castelo.jpg')
    ->contrast(-35)
    ->save('out/castelo-contrast--35.jpg');

Colorize

O método colorize possibilita ajustar as cores de uma imagem por meio dos canais RGB, alterando o vermelho (red), verde (green) e azul (blue). Para isso, é necessário informar três parâmetros, um para cada cor do RGB, sendo que cada um deles varia de -100 a 100. O valor -100 retira totalmente a cor especificada da imagem, 0 não realiza nenhuma modificação e 100 adiciona o máximo daquela cor.

Image::make('images/castelo.jpg')
    ->colorize(100, 0 , 0)
    ->save('out/castelo-colorize-red.jpg');

Image::make('images/castelo.jpg')
    ->colorize(-100, 0 , 0)
    ->save('out/castelo-colorize-without-red.jpg');

Mask

Podemos aplicar uma máscara em uma imagem utilizando o método mask, passando para ele uma imagem fonte. A imagem fonte pode ser de mesma origem utilizada no método make, como uma URL, um objecto Image, etc.

No exemplo a seguir, uma imagem de castelo é carregada e, em seguida, uma imagem de um círculo com o mesmo tamanho da imagem do castelo é criada com fundo transparente. Um círculo branco é desenhado no centro da imagem em branco. Em seguida, a imagem do círculo é aplicada como uma máscara (linha 9) na imagem do castelo.

$img = Image::make('images/castelo.jpg');

// cria uma imagem de um circulo com fundo transparente e preenchimento branco
$mask = Image::canvas($img->width(), $img->height());
$mask->circle($img->height(), $img->width() / 2, $img->height() / 2, function ($draw) {
    $draw->background('#fff');
});

$img->mask($mask);
$img->save('out/castelo_mask.png');

Flip

Podemos utilizar o método flip para espelhar uma imagem, o qual recebe um parâmetro para definir a direção do espelhamento: ‘v’ para vertical e ‘h’ para horizontal. O valor padrão é horizontal, caso não seja informado.

Image::make('images/castelo.jpg')
    ->flip('v')
    ->save('out/castelo-flip-v.jpg');

Image::make('images/castelo.jpg')
    ->flip('h')
    ->save('out/castelo-flip-h.jpg');

Aplicando Efeitos

Podemos aplicar diversos efeitos em uma imagem com a biblioteca Intervention Image.

Rotate

Para rotacionar uma imagem, utilizamos o método rotate, que aceita como parâmetro o ângulo em que a imagem será girada. O giro será realizado no sentido horário.

Image::make('images/castelo.jpg')
    ->rotate(45)
    ->save('out/castelo-rotate-45.jpg');

Blur

Podemos aplicar o efeito de desfoque em uma imagem através do método blur, passando como parâmetro a intensidade do desfoque que desejamos aplicar, variando de 0 a 100. É importante ter cuidado com valores muito altos, pois utilizando o driver GD pode haver problemas de desempenho.

Image::make('images/castelo.jpg')
    ->blur(5)
    ->save('out/castelo-blur-5.jpg');

Pixelate

O método pixelate aplica um efeito de pixelização na imagem atual. É necessário informar como parâmetro o tamanho do pixel desejado.

Image::make('images/castelo.jpg')
    ->pixelate(5)
    ->save('out/castelo-pixelate-5.jpg');

Opacity

Podemos alterar a transparência de uma imagem através do método opacity, passando para ele um valor inteiro entre 0 e 100, sendo 0 totalmente transparente e 100 sem transparência nenhuma.

Image::make('images/castelo.jpg')
    ->opacity(50)
    ->save('out/opacity.png');

Desenhando

A biblioteca Intervention Image nos fornece diversos métodos para desenhar em uma imagem, entre eles.

Text

Para adicionar texto em uma imagem utilizamos o método text. Esse método recebe como parâmetros o texto a ser inserido e as coordenadas x e y onde o texto será escrito.

Image::canvas(200, 100, '#FFFFFF')
    ->text("Boteco Digital", 10 , 10)
    ->save('out/text-1.jpg');

Podemos definir as configurações do texto, como fonte, tamanho, estilo e cor, através de uma função de callback passada como quarto parâmetro no método text. A função recebe um objeto $font, que pode ser utilizado para chamar diversos métodos e definir as propriedades da fonte. Essas configurações são opcionais.

file: configura o arquivo True Type Font, ou um inteiro de 1 a 5 para as fontes internas do driver GD .
size: o tamanho da fonte. Só é disponível se um arquivo de True Type Font for informado.
color: a cor da fonte no formato RGB.
align: configura o alinhamento horizontal do texto relativo ao seu basepoint. O valores possíveis são left, center, right.
valing: configura o alinhamento vertical do texto relativo ao seu basepoint. Os valores possíveis são top, bottom e middle
angle: configura o angulo de rotação do texto em graus no sentido horário. Só é disponível se um arquivo de True Type Font for informado.

$img = Image::canvas(200, 200, '#FFFFFF');
$img->text('Boteco Digital', $img->width() / 2, $img->height() /2, function($font) {
        $font->file('fonts/Roboto-Medium.ttf');  
        $font->size(24); 
        $font->color('#FF0000'); 
        $font->align('center'); 
        $font->valign('top'); 
        $font->angle(45); 
    })
    ->save('out/text-2.jpg');

Line

Para desenhar uma linha na imagem utilizamos o método line. Ele recebe um ponto de origem x,y e um ponto de destino x,y.

Image::canvas(200, 200, '#FFFFFF')
    ->line(50, 100, 100, 150) // linha 1
    ->line(100, 150, 150, 100) // linha 2
    ->save('out/line.jpg');

Para alterar a cor e a espessura da linha passamos uma função de callback para o método line, esta função recebe um objeto $draw, do qual podemos chamar os métodos, color(para alterar a cor) e width(para alterar a espessura). O método width não está disponível no driver GD.

Image::configure(['driver'=>'imagick']);
Image::canvas(200, 200, '#FFFFFF')
    ->line(10, 100, 190, 100, function($draw){
        $draw->width(5);
        $draw->color('#0000FF');
    })
    ->save('out/line-2.jpg');

Rectangle

Para adicionar um retângulo na imagem utilizamos o método rectangle, ele recebe 4 parâmetros definindo os pontos do retângulo, os dois primeiros são as coordenadas x,y do ponto superior esquerdo do retângulo, do terceiro e quarto são as coordenadas x,y do ponto inferior direito.

Também podemos passar uma função de callback para o método para alterar a cor de fundo e a borda. Esta função recebe um objeto $draw do qual podemos chamar os métodos background e border.

Image::canvas(200, 200, '#FFFFFF')
    ->rectangle(20, 20, 180, 180, function ($draw) {
        $draw->background('#ff0000');
        $draw->border(2,'#0000ff');
    })
    ->save('out/rectangle.jpg');

Circle

Podemos desenhar um círculo, para isso chamamos o método circle passando como primeiro parâmetro o raio deste círculo, como segundo e terceiro parâmetros as coordenadas x,y do centro do círculo. Podemos ainda passar uma função de callback para definir a cor de fundo e borda como fazemos para o retângulo.

Image::canvas(200, 200, '#FFFFFF')
    ->circle(50, 100, 100, function($draw){
        $draw->background('#00FF00');
        $draw->border(2, '#555500');
    })
    ->save('out/circle-1.jpg');

Polygon

Para desenhar um polígono utilizamos o método polygon, passando um array de coordenadas dos pontos que formam. Como o método rectangle e circle podemos passar uma função de callback para definir cor de fundo e borda.

Image::configure(['driver'=>'imagick']);

$points = [
    40,  50,   // ponto 1 (x,y)
    20,  240,  // ponto 2 (x,y) 
    60,  60,   // ponto 3 (x,y)
    240, 20,   // ponto 4 (x,y)
    50,  40,   // ponto 5 (x,y)
    10,  10    // ponto 6 (x,y)
];

Image::canvas(300, 300, '#FFFFFF')
    ->polygon($points, function ($draw) {
        $draw->background('#0000ff');
        $draw->border(1, '#ff0000');
    })
    ->save('out/polygon.jpg');

Criando uma marca d’agua

Vamos a um exemplo um pouco mais concreto, uma tarefa simples, colocar uma marca d’água em uma imagem.

Na linha 3 carregamos a imagem na qual será colocada a marca d’água. Na lina 5 criamos uma imagem para escrever o texto da marca, criamos esta imagem em branco com as dimensões da imagem original. Na linha 6 escrevemos o texto ‘Boteco Digital’ na imagem, posicionando o texto a 200px da margem esquerda ($img->width() - 200 ) no eixo x e 30px da margem inferior ($img->height() - 30). Configuramos uma fonte de um arquivo, de tamanho 24 e cor branca.

Na linha 13 alteramos a transparência da imagem de marca d’água para 30% e na linha 15 inserimos a imagem da marca na imagem original que irá receber a marca através do método insert.

Image::configure(['driver'=>'imagick']);

$img = Image::make('images/castelo.jpg');

$mark = Image::canvas($img->width(), $img->height());
$mark->text('Boteco Digital', $img->width() - 200 , $img->height() - 30, function($font){
    $font->file('fonts/Roboto-Medium.ttf');
    $font->size(24);
    $font->color('#FFF');
    $font->align('left');
    $font->valign('bottom');
});
$mark->opacity(30);

$img->insert($mark);
$img->save('out/watermark.png');

A biblioteca Intervention Image, é uma biblioteca que facilita bastante a manipulação de imagens, deixando o código bastante fluido e legível. Para maiores detalhes e mais métodos de manipulação consulte a documentação dela.

Caso queira ver os exemplos do post, consulte o github, sempre é bom ver os resultados das imagens.

Bom era isso, T++!