LiipImagineBundle
2.13.3
| Unidade PHP | PHP-CS-Fixer | Cobertura | Transferências | Liberar |
|---|---|---|---|---|
Este pacote fornece um kit de ferramentas de abstração de manipulação de imagens para projetos baseados em Symfony.
Conjuntos de filtros: usando qualquer linguagem de configuração suportada pelo Symfony (como YML e XML), você pode criar definições de conjuntos de filtros que especificam rotinas de transformação. Estas definições incluem um conjunto de filtros e pós-processadores , bem como outros parâmetros opcionais.
Filtros: As transformações de imagem são aplicadas usando filtros . Um conjunto de filtros integrados é fornecido pelo pacote, implementando as transformações mais comuns; exemplos incluem miniatura, escala, corte, inversão, faixa e marca d'água. Para transformações mais avançadas, você pode criar facilmente seus próprios filtros personalizados.
Pós-processadores: As modificações do arquivo de imagem binária resultante (criado a partir de seus filtros ) são tratadas por pós-processadores . Os exemplos incluem JPEG Optim, Moz JPEG, Opti PNG e PNG Quant. Assim como os filtros, você pode criar facilmente seus próprios pós-processadores personalizados.
Suponha que você tenha definido um conjunto de filtros my_thumb , que pode ser configurado para executar qualquer número de transformações diferentes. A invocação mais simples seria canalizar o caminho da sua imagem para o filtro imagine_filter Twig fornecido.
< img src = " {{ asset( ' /relative/path/to/image.jpg ' ) | imagine_filter( ' my_thumb ' ) }} " />Este projeto é lançado com um Código de Conduta do Colaborador. Ao participar deste projeto você concorda em cumprir seus termos.
Obrigado aos muitos colaboradores que dedicaram seu tempo e código a este projeto.
A biblioteca PHP Imagine Library independente é usada por este pacote para transformações de imagens.
Este pacote foi bifurcado do AvalancheImagineBundle com o objetivo de tornar o código mais extensível. Consulte AvalancheImagineBundle#25 para obter informações adicionais sobre o raciocínio dessa bifurcação.
Usar este pacote é semelhante a todos os pacotes do Symfony. As seguintes etapas devem ser executadas
Instruções detalhadas de configuração podem ser encontradas no capítulo de instalação da documentação.
Informações detalhadas sobre todas as opções de configuração disponíveis podem ser encontradas no capítulo de configuração da documentação.
Geralmente, esse pacote funciona aplicando conjuntos de filtros às imagens de dentro de um modelo. Seus conjuntos de filtros são definidos no arquivo de configuração do aplicativo (geralmente app/config/config.yml ) e são compostos por uma coleção de filtros , pós-processadores e outros parâmetros opcionais.
Aprenderemos mais sobre pós-processadores e outros parâmetros disponíveis posteriormente, mas por enquanto vamos nos concentrar em como definir um conjunto de filtros simples composto por alguns filtros .
Antes de começarmos, há uma pequena configuração necessária para garantir que nossos carregadores de dados e resolvedores de cache funcionem corretamente. Use o seguinte padrão em seu arquivo de configuração.
# app/config/config.yml
liip_imagine :
# configure resolvers
resolvers :
# setup the default resolver
default :
# use the default web path
web_path : ~
# your filter sets are defined here
filter_sets :
# use the default cache configuration
cache : ~Com a configuração básica definida, começaremos com um exemplo que atende a um caso de uso comum: criar miniaturas. Vamos supor que queremos que as miniaturas resultantes tenham as seguintes transformações aplicadas a elas:
Adicionando ao nosso padrão acima, precisamos definir um conjunto de filtros (que chamaremos de my_thumb ) com dois filtros configurados: os filtros thumbnail e background .
# app/config/config.yml
liip_imagine :
resolvers :
default :
web_path : ~
filter_sets :
cache : ~
# the name of the "filter set"
my_thumb :
# adjust the image quality to 75%
quality : 75
# list of transformations to apply (the "filters")
filters :
# create a thumbnail: set size to 120x90 and use the "outbound" mode
# to crop the image when the size ratio of the input differs
thumbnail : { size : [120, 90], mode : outbound }
# create a 2px black border: center the thumbnail on a black background
# 4px larger to create a 2px border around the final image
background : { size : [124, 94], position : center, color : '#000000' } Agora você criou um conjunto de filtros chamado my_thumb que executa uma transformação de miniaturas. O filtro thumbnail dimensiona a imagem para a largura e altura desejadas (neste exemplo, 120x90px), e sua opção mode: outbound faz com que a imagem resultante seja cortada se a proporção de entrada for diferente. O filtro background resulta em uma borda preta de 2px criando uma tela preta de tamanho 124x94px e posicionando a miniatura no centro.
Nota: Um conjunto de filtros pode ter qualquer número de filtros definidos para ele. Transformações simples podem exigir apenas um único filtro , enquanto transformações complexas podem ter um número ilimitado de filtros definidos para elas.
Existem vários filtros adicionais, mas por enquanto você pode usar o conjunto de filtros my_thumb recém-definido imediatamente dentro de um modelo.
Para modelo baseado em Twig, use:
< img src = " {{ asset( ' /relative/path/to/image.jpg ' ) | imagine_filter( ' my_thumb ' ) }} " />Ou, para modelo baseado em PHP, use:
<img src=" <?php $ this ['imagine']->filter('/relative/path/to/image.jpg', 'my_thumb') ?> " /> Nos bastidores, o pacote aplica os filtros à imagem dinamicamente quando a solicitação da primeira página é atendida. A imagem transformada é então armazenada em cache para solicitações subsequentes. O caminho final da imagem em cache seria semelhante a /media/cache/my_thumb/relative/path/to/image.jpg .
Nota: *Usando o ambiente dev , você pode descobrir que as imagens não são renderizadas corretamente por meio do auxiliar de modelo. Isso geralmente é causado pelo intercept_redirect habilitado na configuração do seu aplicativo. Para garantir que as imagens sejam renderizadas, é altamente recomendável desativar esta opção:
# app/config/config_dev.yml
web_profiler :
intercept_redirects : falseÀs vezes, você pode ter um filtro definido que atenda a 99% dos seus cenários de uso. Em vez de definir um novo filtro para 1% dos casos errados, você pode optar por alterar o comportamento de um filtro em tempo de execução, passando ao auxiliar do modelo uma matriz de opções.
Para modelo baseado em Twig, use:
{% set runtimeConfig = { " thumbnail " : { " size " : [ 50 , 50 ] }} %}
< img src = " {{ asset( ' /relative/path/to/image.jpg ' ) | imagine_filter( ' my_thumb ' , runtimeConfig ) }} " />Ou, para modelo baseado em PHP, use:
<?php
$ runtimeConfig = array (
" thumbnail " => array (
" size " => array ( 50 , 50 )
)
);
?>
<img src=" <?php $ this [ ' imagine ' ]-> filter ( ' /relative/path/to/image.jpg ' , ' my_thumb ' , $ runtimeConfig ) ?> " />Às vezes você precisa resolver o caminho da imagem retornado por este pacote para uma imagem filtrada. Isso pode ser facilmente alcançado usando o binário do console do Symfony ou programaticamente a partir de um controlador ou outro trecho de código.
Você pode resolver um URL de imagem usando o comando do console liip:imagine:cache:resolve . O único argumento obrigatório é um ou mais caminhos de imagem relativos (que devem ser separados por um espaço).
$ php bin/console liip:imagine:cache:resolve relative/path/to/image1.jpg relative/path/to/image2.jpg Além disso, você pode usar a opção --filter para especificar qual filtro deseja resolver (se a opção --filter for omitida, todos os filtros disponíveis serão resolvidos).
$ php bin/console liip:imagine:cache:resolve relative/path/to/image1.jpg --filter=my_thumb Você pode resolver o URL da imagem em seu código usando o método getBrowserPath do serviço liip_imagine.cache.manager . Supondo que você já tenha o serviço atribuído a uma variável chamada $imagineCacheManager , você executaria:
$ imagineCacheManager -> getBrowserPath ( ' /relative/path/to/image.jpg ' , ' my_thumb ' ); Freqüentemente, você precisa realizar esta operação em um controlador. Supondo que seu controlador herde do controlador base do Symfony, você pode aproveitar as vantagens do método get herdado para solicitar o serviço liip_imagine.cache.manager , a partir do qual você pode chamar getBrowserPath em um caminho de imagem relativo para obter sua localização resolvida.
/** @var CacheManager */
$ imagineCacheManager = $ this -> get ( ' liip_imagine.cache.manager ' );
/** @var string */
$ resolvedPath = $ imagineCacheManager -> getBrowserPath ( ' /relative/path/to/image.jpg ' , ' my_thumb ' );Este pacote fornece um conjunto de filtros integrados e você também pode definir facilmente seus próprios filtros. Consulte o capítulo sobre filtros em nossa documentação.
Se precisar usar seus "conjuntos de filtros" definidos em seu controlador, você pode buscar o FilterService deste pacote no contêiner de serviço para fazer o trabalho pesado para você.
<?php
class MyController extends Controller
{
public function indexAction ()
{
/** @var FilterService */
$ imagine = $ this
-> container
-> get ( ' liip_imagine.service.filter ' );
// 1) Simple filter, OR
$ resourcePath = $ imagine -> getUrlOfFilteredImage ( ' uploads/foo.jpg ' , ' my_thumb ' );
// 2) Runtime configuration
$ runtimeConfig = [
' thumbnail ' => [
' size ' => [ 200 , 200 ]
],
];
$ resourcePath = $ imagine -> getUrlOfFilteredImageWithRuntimeFilters (
' uploads/foo.jpg ' ,
' my_thumb ' ,
$ runtimeConfig
);
// ..
}
}
?> Por padrão, o diretório web/ do Symfony é registrado como uma raiz de dados para carregar ativos. Para muitas instalações isso será suficiente, mas em algum momento poderá ser necessário carregar imagens de outros locais. Para fazer isso, você deve definir o parâmetro data_root em sua configuração (geralmente localizado em app/config/config.yml ).
liip_imagine :
loaders :
default :
filesystem :
data_root : /path/to/source/images/dir A partir da versão 1.7.2 você pode registrar múltiplos caminhos de raiz de dados, e o localizador de arquivos irá procurar em cada um deles o arquivo solicitado.
liip_imagine :
loaders :
default :
filesystem :
data_root :
- /path/foo
- /path/bar A partir da versão 1.7.3 você solicita que os caminhos de recursos públicos de todos os pacotes registrados sejam registrados automaticamente como raízes de dados. Isso permite que você carregue ativos das pastas Resources/public que residem nos pacotes carregados. Para ativar esse recurso, configure a opção de configuração bundle_resources.enabled como true .
liip_imagine :
loaders :
default :
filesystem :
bundle_resources :
enabled : true Se você quiser registrar algumas das pastas Resource/public , mas não todas, você pode fazer isso colocando na lista negra os pacotes que você não deseja registrar ou colocando na lista branca os pacotes que você deseja registrar. Por exemplo, para colocar na lista negra (não registrar) os pacotes "FooBundle" e "BarBundle", você usaria a seguinte configuração.
liip_imagine :
loaders :
default :
filesystem :
bundle_resources :
enabled : true
access_control_type : blacklist
access_control_list :
- FooBundle
- BarBundleAlternativamente, se você quiser colocar na lista de permissões (apenas registrar) os pacotes "FooBundle" e "BarBundle", você usaria a seguinte configuração.
liip_imagine :
loaders :
default :
filesystem :
bundle_resources :
enabled : true
access_control_type : whitelist
access_control_list :
- FooBundle
- BarBundle Os locais das imagens devem ser legíveis pelo seu servidor web. Em um sistema que suporta setfacl (como Linux/BSD), use
HTTPDUSER= ` ps axo user,comm | grep -E ' [a]pache|[h]ttpd|[_]www|[w]ww-data|[n]ginx ' | grep -v root | head -1 | cut -d -f1 `
sudo setfacl -R -m u: " $HTTPDUSER " :rwX -m u: ` whoami ` :rwX /path/to/source/images/dir
sudo setfacl -dR -m u: " $HTTPDUSER " :rwX -m u: ` whoami ` :rwX /path/to/source/images/dirConsulte a documentação de permissões do Symfony para comandos compatíveis com macOS e outros ambientes.
Você precisa conceder acesso de leitura ao Apache adicionando o seguinte à configuração do Apache VHost
< VirtualHost *:80>
<!-- Rest of directives like DocumentRoot or ServerName -->
Alias /FavouriteAlias /path/to/source/images/dir
< Directory " /path/to/source/images/dir " >
AllowOverride None
Allow from All
</ Directory >
</ VirtualHost > Alternativamente, você pode colocar a diretiva em um arquivo separado dentro do seu projeto e incluí-la na configuração do Apache VHost. Por exemplo, você pode criar o arquivo app/config/apache/photos.xml e adicionar o seguinte ao seu arquivo VHost
< VirtualHost *:80>
<!-- Rest of directives like DocumentRoot or ServerName -->
Include "/path/to/your/project/app/config/apache/photos.xml"
</ VirtualHost >Este método mantém o arquivo com o restante do seu código, permitindo alterá-lo facilmente ou criar diferentes arquivos de configuração dependentes do ambiente.
Depois de configurar o Apache corretamente, o caminho relativo para uma imagem com o seguinte caminho absoluto /path/to/source/images/dir/logo.png deve ser /FavouriteAlias/logo.png .
Para obter informações mais detalhadas sobre os recursos deste pacote, consulte a documentação.
