(16) 981791110 contato@policast.studio

O que é o LiipImagineBundle?

por | mar 21, 2024 | Artigo, Notícias

O que é o LiipImagineBundle?

O LiipImagineBundle é um pacote que adiciona funcionalidade de manipulação de imagem ao Symfony. Ele pode ser usado para recortar, redimensionar, adicionar filtros e muito mais em imagens carregadas dinamicamente pelo seu aplicativo.

O bundle é altamente personalizável e fácil de integrar com o Symfony. Ele também tem um conjunto de filtros internos que podem ser aplicados diretamente em imagens em tempo de execução, sem a necessidade de abrir e editar a imagem manualmente em um editor de imagens.

Com o LiipImagineBundle, é possível carregar imagens menores do que a original para economizar largura de banda do usuário. Ele também pode ser usado para criar miniaturas de imagens em tamanhos personalizados em vez de salvar múltiplas versões da mesma imagem no servidor.

Quais são os requisitos para instalar o LiipImagineBundle?

Para instalar o LiipImagineBundle, é necessário ter o Symfony 2.8 ou superior instalado. Além disso, certifique-se de ter a extensão “php_gd2” habilitada no seu servidor, pois isso é necessário para manipular imagens.

Depois de garantir que seus requisitos são atendidos, você pode instalar o LiipImagineBundle com o Composer usando o seguinte comando: 

composer require liip/imagine-bundle

Como configurar o LiipImagineBundle?

Para configurar o LiipImagineBundle, é necessário adicionar algumas linhas ao arquivo de configuração do Symfony. Aqui está um exemplo básico de configuração:



# app/config/config.yml

liip_imagine:

    filter_sets:

        cache: ~

        thumb:

            quality: 75

            filters:

                thumbnail: { size: [120, 90], mode: outbound }

Neste exemplo, um filtro chamado “thumb” foi definido, que cria uma miniatura de 120 x 90 pixels. O filtro também está configurado para ajustar a imagem de acordo com as dimensões especificadas (modo “outbound”) e aplicar uma qualidade de 75% à imagem final.

Outros filtros padrão também estão disponíveis no LiipImagineBundle, como o ‘rotate’, o ‘grayscale’ e o ‘blur’.

Como usar o LiipImagineBundle em um controlador?

Depois de configurar o LiipImagineBundle, você pode usá-lo em um controlador Symfony para manipular imagens carregadas dinamicamente. Aqui está um exemplo de controlador que aplica um filtro de ajuste à imagem antes de transmiti-la ao navegador:



// src/AppBundle/Controller/ImageController.php


use SymfonyBundleFrameworkBundleControllerController;

use SymfonyComponentHttpFoundationRequest;

use LiipImagineBundleImagineCacheCacheManager;

use LiipImagineBundleImagineFilterFilterManager;


class ImageController extends Controller

{

    public function resizeAction(Request $request, CacheManager $cacheManager, FilterManager $filterManager)

    {

        $imageUrl = $request->get('url');

        $imagePath = $this->getParameter('kernel.root_dir') . '/../web/' . $imageUrl;


        // Define o filtro a ser aplicado

        $filter = 'thumb';


        // Gerar o caminho do cache de acordo com o filtro definido

        $cachePath = $cacheManager->getBrowserPath($imagePath, $filter);


        if (!$cacheManager->isStored($imagePath, $filter)) {

            // A imagem não está em cache, então crie a imagem em cache e salve-a

            $binary = file_get_contents($imagePath);

            $cacheManager->store($filterManager->applyFilter($binary, $filter), $cachePath, $filter);

        }


        // Redirecionar a solicitação para a imagem em cache

        return $this->redirect($cachePath);

    }

}

Neste exemplo, o controlador é usado para manipular uma imagem carregada dinamicamente em um site. Para isso, é necessário passar a URL da imagem como um parâmetro na solicitação HTTP. O controlador, então, aplica um filtro de ajuste ao arquivo da imagem e salva uma versão em cache da imagem otimizada. O cache é posteriormente retornado para o navegador.

Como criar imagens miniatura usando o LiipImagineBundle?

Com o LiipImagineBundle, é fácil criar miniaturas de imagens dinamicamente. Aqui está um exemplo de código PHP que cria uma miniatura de 100 x 100 pixels de uma imagem:



use LiipImagineBundleImagineCacheCacheManager;

use LiipImagineBundleImagineFilterFilterManager;


public function createThumbnail($path, $width, $height)

{

    $filter = 'thumbnail';

    $cacheManager = new CacheManager($this->get('liip_imagine.cache.manager'));

    $filterManager = new FilterManager($this->get('liip_imagine.filter.manager'));


    $image = file_get_contents($path);

    $thumb = $filterManager->applyFilter($image, $filter, array(

        'size' => array($width, $height),

        'mode' => 'outbound'

    ));


    // Gere o caminho da miniatura em cache

    $pathinfo = pathinfo($path);

    $thumbUrl = $pathinfo['filename'] . '_thumb.' . $pathinfo['extension'];

    $thumbPath = $cacheManager->getBrowserPath($path, $filter);


    if (!$cacheManager->isStored($path, $filter)) {

        $cacheManager->store($thumb, $thumbPath, $filter);

    }


    return $thumbUrl;

}

Este exemplo é semelhante ao exemplo do controlador, mas em vez de retornar uma resposta HTTP, ele retorna o URL da miniatura recém-criada.

Depois de gerar a miniatura, você pode adicioná-la a uma página da web como faria com qualquer outra imagem.

Quais são os filtros de imagem disponíveis no LiipImagineBundle?

O LiipImagineBundle tem uma variedade de filtros internos que podem ser aplicados em imagens. Aqui estão alguns dos filtros mais comuns:

  • thumbnail: Redimensiona e recorta a imagem para que ela se ajuste à dimensão especificada.
  • resize: Redimensiona a imagem para a largura e altura especificadas.
  • rotate: Gira a imagem em um determinado ângulo.
  • crop: Recorta a imagem para especificações precisas de largura, altura e posição.
  • grayscale: Converte a imagem para escala de cinza.
  • colorize: Aplica uma cor à imagem.
  • blur: Aplica um efeito de desfoque à imagem.

Como salvar uma imagem manipulada pelo LiipImagineBundle?

O LiipImagineBundle é uma ferramenta para manipular imagens dinamicamente, então não é necessário salvar as imagens manipuladas. Você pode gerar e retornar as imagens manipuladas diretamente no controlador, a menos que você precise armazená-las em cache para melhorar o desempenho.

Caso você realmente precise salvar uma imagem manipulada pelo LiipImagineBundle, você pode usar a biblioteca “intervention/image”. Aqui está um exemplo de código PHP que salva uma imagem manipulada para o diretório raiz do seu projeto:



use LiipImagineBundleImagineCacheCacheManager;

use LiipImagineBundleImagineFilterFilterManager;

use InterventionImageImageManagerStatic as Image;


public function saveImage($path, $filterName)

{

    $cacheManager = new CacheManager($this->get('liip_imagine.cache.manager'));

    $filterManager = new FilterManager($this->get('liip_imagine.filter.manager'));


    $image = file_get_contents($path);

    $filtered = $filterManager->applyFilter($image, $filterName);


    $interventionImage = Image::make($filtered);

    $interventionImage->save('path/to/folder/' . uniqid() . '.jpg');

}

Como depurar problemas com o LiipImagineBundle?

Se você enfrentar problemas ao usar o LiipImagineBundle, há algumas coisas que você pode fazer para depurá-lo. Aqui estão alguns métodos de solução de problemas comuns:

  • Verifique suas configurações. Verifique se suas configurações estão corretas no arquivo “config.yml”. Certifique-se de que você tem uma seção “liip_imagine” definida com filtros definidos.
  • Verifique os logs do Symfony. O LiipImagineBundle gera logs de depuração no Symfony. Verifique o arquivo de log para ver se há uma saída de depuração que possa indicar onde o problema está ocorrendo.
  • Use o modo de depuração. O LiipImagineBundle tem um modo de depuração que pode ser habilitado na configuração. Isso pode ajudá-lo a depurar problemas mais rapidamente. Ative o modo de depuração adicionando esta linha ao seu arquivo de configuração:

    • liip_imagine: {debug: true}

  • Verifique suas permissões de arquivo. Se você estiver tendo problemas ao salvar imagens em cache, verifique se seus diretórios de cache têm permissões de gravação.

Como limpar o cache de imagem gerado pelo LiipImagineBundle?

Para limpar o cache das imagens geradas pelo LiipImagineBundle, você pode executar o seguinte comando do Symfony:

php bin/console cache:clear --env=prod liip_imagine.cache.default_resolver

Este comando remove todos os arquivos de cache padrão gerados pelo LiipImagineBundle.

Como adicionar um filtro personalizado ao LiipImagineBundle?

O LiipImagineBundle permite que você adicione filtros personalizados facilmente. Aqui está um exemplo de como adicionar um filtro personalizado:



# app/config/config.yml

liip_imagine:

    filter_sets:

        my_filter:

            filters:

                my_custom_filter: ~

    # Defina os serviços para seu filtro personalizado

    filters:

        my_custom_filter:

            class: AppBundleImagineFilterMyCustomFilter

            tags:

                - { name: liip_imagine.filter }

Este exemplo adiciona um filtro personalizado chamado “my_custom_filter”. O filtro é definido dentro do conjunto de filtros “my_filter”. O serviço do filtro personalizado é encontrado na classe “MyCustomFilter” em “AppBundleImagineFilter”, que foi definido em outra seção de configuração.

Depois de adicionar o filtro personalizado, ele pode ser usado no controlador ou em outro código PHP da mesma forma que os filtros internos.

Como acessar imagens em um diretório fora do raiz do seu projeto?

Ao usar o LiipImagineBundle, você pode acessar imagens de outros locais que não o diretório raiz do seu projeto. Para fazer isso, você pode definir o caminho completo da imagem na URL, como neste exemplo:



http://localhost:8000/app_dev.php/imagine/cache/path/to/image.jpg?filter=my_filter

Aqui, a imagem está localizada em um subdiretório em “/var/www/images/path/to/image.jpg”, mas é acessada usando a URL completa “/imagine/cache/path/to/image.jpg”.

Também é possível definir o diretório raiz em seu arquivo de configuração, para que você possa acessar diretórios fora de sua raiz de projeto sem ter que especificar a URL completa. Aqui está um exemplo:



liip_imagine:

    cache:

        # Caminho da pasta de armazenamento de cache

        # Use um caminho absoluto fora do diretório raiz do seu projeto para armazenar arquivos

        filesystem: ~

    web_root: %kernel.root_dir%/../web/

    filter_sets:

        my_filter:

            filters:

                thumbnail: { size: [100, 100], mode: outbound }

Neste exemplo, “web_root” é definido para apontar para o diretório raiz do projeto. O cache do LiipImagineBundle é armazenado fora deste diretório raiz, no “filesystem” que é usado para armazenar arquivos temporários.